conductor-remote 1.39.0 → 1.41.0

package/dist/index.html

@@ -13,8 +13,8 @@
 		<title>Conductor Remote</title>
 		<!-- Runs before the module bundle so it can catch a stale shell that fails to boot. -->
 		<script src="/self-heal.js"></script>
-		<script type="module" crossorigin src="/assets/index-CHhZJBVH.js"></script>
-		<link rel="stylesheet" crossorigin href="/assets/index-UopM0hHW.css">
+		<script type="module" crossorigin src="/assets/index-BSDnFvjd.js"></script>
+		<link rel="stylesheet" crossorigin href="/assets/index-95IdnA_r.css">
 	<link rel="manifest" href="/manifest.webmanifest"></head>
 	<body>
 		<div id="root"></div>

package/dist/push-sw.js

@@ -13,6 +13,25 @@
 // 2. **A tap focuses the existing window** rather than navigating it. The app is a
 //    token-gated SPA; `openWindow` on a live client would remount the whole thing and
 //    throw away in-progress composer text, so we focus and post a route instead.
+// 3. **The route is also parked in Cache Storage**, because on iOS neither of the two
+//    direct routes survives. A backgrounded home-screen web app is resumed on whatever
+//    screen it was left on — `openWindow`'s path is ignored, and a `postMessage` to a
+//    frozen page is dropped (WebKit, reported from iOS 17.1 through 18.x and still
+//    open). The cache outlives both, so the app reads its target when it comes back to
+//    the front; see `usePushRouting` in web/src/hooks.ts.
+
+/** One entry, overwritten per tap: only the newest tap can still be waiting to land. */
+const ROUTE_CACHE = 'push-route'
+const ROUTE_KEY = '/__push-route'
+
+async function parkRoute(url) {
+	try {
+		const cache = await caches.open(ROUTE_CACHE)
+		await cache.put(ROUTE_KEY, new Response(JSON.stringify({ url, ts: Date.now() })))
+	} catch {
+		// Storage refused it (quota, a private window). The two direct routes below still stand.
+	}
+}
 
 self.addEventListener('push', event => {
 	const fallback = { title: 'Conductor Remote', body: 'Something changed in a workspace.', url: '/', tag: 'conductor' }
@@ -28,8 +47,9 @@ self.addEventListener('push', event => {
 	event.waitUntil(
 		self.registration.showNotification(data.title, {
 			body: data.body,
-			// Tagged per workspace by the relay: a chatty agent replaces its own notification
-			// instead of stacking. `renotify` keeps the replacement audible.
+			// Tagged per chat by the relay: a chatty agent replaces its own notification
+			// instead of stacking, while a sibling chat keeps its own (they open different
+			// screens). `renotify` keeps the replacement audible.
 			tag: data.tag,
 			renotify: true,
 			icon: '/icon-192.png',
@@ -45,18 +65,23 @@ self.addEventListener('notificationclick', event => {
 	const url = (event.notification.data && event.notification.data.url) || '/'
 	event.waitUntil(
 		(async () => {
+			// Park first. Everything below can succeed and still leave the phone on the wrong
+			// screen, and this is the copy the app reads when it wakes up.
+			await parkRoute(url)
 			const clients = await self.clients.matchAll({ type: 'window', includeUncontrolled: true })
 			for (const client of clients) {
 				if (new URL(client.url).origin !== self.location.origin) continue
+				// Handled in web/src/hooks.ts (usePushRouting) — an in-app route change, so the
+				// token gate and React state survive the tap. Posted before the focus, since a
+				// refused focus is no reason to skip a message the page may well receive.
+				client.postMessage({ type: 'push-navigate', url })
 				try {
 					await client.focus()
-					// Handled in web/src/hooks.ts (usePushRouting) — an in-app route change,
-					// so the token gate and React state survive the tap.
-					client.postMessage({ type: 'push-navigate', url })
-					return
 				} catch {
-					// focus() can be refused (no user activation on some platforms) — fall through to openWindow
+					// focus() can be refused (no user activation on some platforms); on iOS the
+					// system foregrounds the web app on the tap regardless.
 				}
+				return
 			}
 			await self.clients.openWindow(url)
 		})()

package/dist/sw.js

@@ -1 +1 @@
-if(!self.define){let e,s={};const i=(i,n)=>(i=new URL(i+".js",n).href,s[i]||new Promise(s=>{if("document"in self){const e=document.createElement("script");e.src=i,e.onload=s,document.head.appendChild(e)}else e=i,importScripts(i),s()}).then(()=>{let e=s[i];if(!e)throw new Error(`Module ${i} didn’t register its module`);return e}));self.define=(n,r)=>{const o=e||("document"in self?document.currentScript.src:"")||location.href;if(s[o])return;let l={};const t=e=>i(e,o),c={module:{uri:o},exports:l,require:t};s[o]=Promise.all(n.map(e=>c[e]||t(e))).then(e=>(r(...e),l))}}define(["./workbox-9c191d2f"],function(e){"use strict";importScripts("/push-sw.js"),self.addEventListener("message",e=>{e.data&&"SKIP_WAITING"===e.data.type&&self.skipWaiting()}),e.clientsClaim(),e.precacheAndRoute([{url:"self-heal.js",revision:"49bd63adb25a09341f8d2610e8bd3c76"},{url:"push-sw.js",revision:"890f6a70e97d144f4d025254e90892a1"},{url:"index.html",revision:"79c117a92e7635dd0174f5aeb1f3940c"},{url:"assets/workbox-window.prod.es5-BBnX5xw4.js",revision:null},{url:"assets/index-UopM0hHW.css",revision:null},{url:"assets/index-CHhZJBVH.js",revision:null},{url:"apple-touch-icon.png",revision:"2b9301416b880d45d4bb655f2600d1f2"},{url:"icon-192.png",revision:"c5e01ac58768627e18ee7b8b6a9239ef"},{url:"icon-512.png",revision:"a40638c55e310312457a621c9a0002c8"},{url:"icon-maskable-512.png",revision:"a40638c55e310312457a621c9a0002c8"},{url:"icon.svg",revision:"c1aee186821798733dd477e69a0ef243"},{url:"manifest.webmanifest",revision:"cf88fbc5755108a7fe0616fa160a8a15"}],{}),e.cleanupOutdatedCaches(),e.registerRoute(new e.NavigationRoute(e.createHandlerBoundToURL("/index.html"),{denylist:[/^\/api\//]}))});
+if(!self.define){let e,s={};const i=(i,n)=>(i=new URL(i+".js",n).href,s[i]||new Promise(s=>{if("document"in self){const e=document.createElement("script");e.src=i,e.onload=s,document.head.appendChild(e)}else e=i,importScripts(i),s()}).then(()=>{let e=s[i];if(!e)throw new Error(`Module ${i} didn’t register its module`);return e}));self.define=(n,r)=>{const o=e||("document"in self?document.currentScript.src:"")||location.href;if(s[o])return;let l={};const t=e=>i(e,o),c={module:{uri:o},exports:l,require:t};s[o]=Promise.all(n.map(e=>c[e]||t(e))).then(e=>(r(...e),l))}}define(["./workbox-9c191d2f"],function(e){"use strict";importScripts("/push-sw.js"),self.addEventListener("message",e=>{e.data&&"SKIP_WAITING"===e.data.type&&self.skipWaiting()}),e.clientsClaim(),e.precacheAndRoute([{url:"self-heal.js",revision:"49bd63adb25a09341f8d2610e8bd3c76"},{url:"push-sw.js",revision:"e1e682e2e5e88fa03b7808ae9db8e098"},{url:"index.html",revision:"9a6849700ab5e2d2b416d9108090e5af"},{url:"assets/workbox-window.prod.es5-BBnX5xw4.js",revision:null},{url:"assets/index-BSDnFvjd.js",revision:null},{url:"assets/index-95IdnA_r.css",revision:null},{url:"apple-touch-icon.png",revision:"2b9301416b880d45d4bb655f2600d1f2"},{url:"icon-192.png",revision:"c5e01ac58768627e18ee7b8b6a9239ef"},{url:"icon-512.png",revision:"a40638c55e310312457a621c9a0002c8"},{url:"icon-maskable-512.png",revision:"a40638c55e310312457a621c9a0002c8"},{url:"icon.svg",revision:"c1aee186821798733dd477e69a0ef243"},{url:"manifest.webmanifest",revision:"cf88fbc5755108a7fe0616fa160a8a15"}],{}),e.cleanupOutdatedCaches(),e.registerRoute(new e.NavigationRoute(e.createHandlerBoundToURL("/index.html"),{denylist:[/^\/api\//]}))});

package/dist-node/src/notify.js

@@ -218,6 +218,15 @@ export async function notifyDevice(id, message) {
 export function deviceCount() {
     return load().devices.length;
 }
+/**
+ * Where a tapped notification lands. The chat id rides along because the phone
+ * otherwise picks the tab itself (Conductor's active session, else the first one)
+ * — and on a multi-chat workspace that is rarely the chat that just finished.
+ * Kept here so the notifier and the parked-prompt queue can't drift apart.
+ */
+export function chatRoute(workspaceId, sessionId) {
+    return `/w/${workspaceId}?session=${encodeURIComponent(sessionId)}`;
+}
 /** Collapse a transcript entry to one lock-screen line: no code fences, no blank runs. */
 function oneLine(text) {
     return clip(text
@@ -287,9 +296,11 @@ async function fire(reads, sessionId, kind, state) {
     const sent = await notifyAll({
         title: state.repoName ? `${where} — ${state.repoName}` : where,
         body,
-        // Per workspace, so a chatty agent replaces its own notification instead of stacking.
-        tag: state.workspaceId,
-        url: `/w/${state.workspaceId}`,
+        // Per chat, so a chatty agent replaces its own notification instead of stacking —
+        // and two chats in one workspace stay separately tappable, since each now lands
+        // somewhere different.
+        tag: sessionId,
+        url: chatRoute(state.workspaceId, sessionId),
         kind,
         ts: Date.now()
     });

package/dist-node/src/reads.js

@@ -4,6 +4,29 @@ import path from 'node:path';
 import { describeRepoIcon, resolveRepoIcon } from "./icons.js";
 import { parseMessage } from "./transcript.js";
 const worktreeCache = new Map();
+/**
+ * Neutralize LIKE's own wildcards in a user's search word. `queryTokens` already
+ * strips everything but letters, digits and `_` — and `_` is LIKE's single-character
+ * wildcard, so "add_set" would quietly also match "addaset" without this.
+ */
+function escapeLike(s) {
+    return s.replace(/[\\%_]/g, m => `\\${m}`);
+}
+/** Shared row → `SearchWorkspace` shape for the two search reads below. */
+function toSearchWorkspace(r) {
+    return {
+        id: r.id,
+        workspace_name: r.workspace_name,
+        pr_title: r.pr_title,
+        branch: r.branch,
+        directory_name: r.directory_name,
+        state: r.state,
+        updated_at: r.updated_at,
+        repo_name: r.repo_name,
+        icon: describeRepoIcon({ icon: r.repo_icon, repoRoot: r.repo_root, remoteUrl: r.remote_url }),
+        archived: r.state === 'archived'
+    };
+}
 /**
  * Conductor's sidebar title for a workspace: manual name → PR title → humanized
  * branch → worktree codename → id. Deliberately a second copy of the web's
@@ -131,6 +154,55 @@ export class Reads {
             icon: describeRepoIcon({ icon: r.icon, repoRoot: r.root_path, remoteUrl: r.remote_url })
         }));
     }
+    /**
+     * Map chat ids to the workspace that owns them, archived included.
+     *
+     * `listWorkspaces` filters to `state IN ('ready','setting_up')`, which is right for
+     * the sidebar and wrong for search: the whole point of searching the transcript is
+     * to reach work you finished and put away. One query for the whole hit set, because
+     * a search fans out over up to 300 chunks and a per-chat lookup would be 300 of them.
+     */
+    searchTargets(sessionIds) {
+        const out = new Map();
+        if (!sessionIds.length)
+            return out;
+        const holes = sessionIds.map(() => '?').join(',');
+        const rows = this.db.query(`SELECT s.id AS session_id, s.title AS session_title,
+			        w.id, w.workspace_name, w.pr_title, w.branch, w.directory_name, w.state, w.updated_at,
+			        r.name AS repo_name, r.icon AS repo_icon, r.root_path AS repo_root, r.remote_url AS remote_url
+			 FROM sessions s
+			 JOIN workspaces w ON w.id = s.workspace_id
+			 LEFT JOIN repos r ON r.id = w.repository_id
+			 WHERE s.id IN (${holes})`, sessionIds);
+        for (const r of rows)
+            out.set(r.session_id, { sessionTitle: r.session_title, workspace: toSearchWorkspace(r) });
+        return out;
+    }
+    /**
+     * Workspaces whose own identity matches every token — name, PR title, branch,
+     * worktree codename or repo. Archived included, same reason as `searchTargets`.
+     *
+     * This is the half of search the transcript index cannot do. A workspace named for
+     * the thing you are looking for may never have said those words in its chat, and
+     * one whose chat is empty has no chunks at all.
+     */
+    findWorkspacesByName(tokens, limit = 20) {
+        if (!tokens.length)
+            return [];
+        const fields = ['w.workspace_name', 'w.pr_title', 'w.branch', 'w.directory_name', 'r.name'];
+        // AND across tokens, OR across fields: "auk lamp" should find the lamp workspace in
+        // the auk repo, where no single column holds both words.
+        const where = tokens.map(() => `(${fields.map(f => `${f} LIKE ? ESCAPE '\\'`).join(' OR ')})`).join(' AND ');
+        const params = tokens.flatMap(t => fields.map(() => `%${escapeLike(t)}%`));
+        const rows = this.db.query(`SELECT w.id, w.workspace_name, w.pr_title, w.branch, w.directory_name, w.state, w.updated_at,
+			        r.name AS repo_name, r.icon AS repo_icon, r.root_path AS repo_root, r.remote_url AS remote_url
+			 FROM workspaces w
+			 LEFT JOIN repos r ON r.id = w.repository_id
+			 WHERE ${where}
+			 ORDER BY (w.state = 'archived'), w.updated_at DESC
+			 LIMIT ?`, [...params, limit]);
+        return rows.map(toSearchWorkspace);
+    }
     /** Resolve a repo's icon by its name (the sidebar avatar) — null if the repo or icon is unknown. */
     resolveRepoIcon(repoName) {
         const rows = this.db.query('SELECT root_path FROM repos WHERE name = ? LIMIT 1', [

package/dist-node/src/search.js

@@ -0,0 +1,333 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { parseMessage } from "./transcript.js";
+/**
+ * Full-text search over the chat history, in a sidecar DB the relay owns.
+ *
+ * Two facts decide the whole shape of this file.
+ *
+ * **Prose is 1.2% of the transcript.** Measured over this Mac's 1.7M
+ * `session_messages` rows (3,106 MB of `content`): tool_result output is 799 MB,
+ * `type:"system"` frames 522 MB, tool_use arguments 162 MB, thinking 77 MB — and
+ * what a person would ever search for, the assistant's own words plus the prompts
+ * they typed, is **38 MB**. So this indexes prose only. A grep of the raw column
+ * would be a 3 GB scan to search 38 MB, and it would rank a file dump the agent
+ * happened to `cat` above the sentence that explained the decision.
+ *
+ * **`node:sqlite` ships FTS5.** Porter stemming, `bm25()`, `snippet()`, `NEAR()`
+ * all work on the bundled SQLite (3.51.2), so the index costs no runtime
+ * dependency — which the tarball rule requires (see CLAUDE.md ▸ Traps). Measured
+ * on the full history: 7.6s to build, 111,079 chunks, queries in 1–7ms.
+ *
+ * The index is **never** written into `conductor.db`. That handle is read-only and
+ * stays that way; this opens its own file under the relay's state dir, and it is
+ * disposable — delete it and the next start rebuilds it.
+ */
+/** Bump to force a rebuild: a tokenizer or extraction change makes every stored chunk wrong. */
+const SCHEMA_VERSION = 1;
+/**
+ * Source rows advanced per tick. The cursor moves by *scanned* rowid rather than
+ * matched rowid, so a caught-up index re-scans nothing — get that wrong and every
+ * idle poll re-reads the 3 GB tail looking for rows it already rejected.
+ */
+const WINDOW_ROWS = 4000;
+/** Yield to the event loop between batches: the backfill is ~19ms of blocking work per window. */
+const BACKFILL_PAUSE_MS = 5;
+/** Once caught up, look for new messages at about the rate a chat produces them. */
+const IDLE_POLL_MS = 15_000;
+/** A pathological single message can't be allowed to dominate the index. */
+const MAX_CHUNK_CHARS = 64_000;
+/** How many chunks a query ranks before they are folded into workspaces. */
+const CHUNK_LIMIT = 300;
+/**
+ * Snippet highlight markers. Control characters rather than brackets: they survive
+ * JSON, they need no escaping on the way to the phone, and no transcript contains
+ * them, so `web/src/lib/format.ts` can split on them without a parser. The client
+ * must not render them literally — see `splitSnippet`.
+ */
+export const HIT_OPEN = '\u0001';
+export const HIT_CLOSE = '\u0002';
+/**
+ * Turn a phone query into an FTS5 MATCH expression.
+ *
+ * Every token is quoted, because FTS5 reads `-`, `*`, `:`, `(`, `AND`, `NEAR` and
+ * friends as syntax: an unquoted apostrophe or hyphen is a *parse error*, not a
+ * poor result, so a raw query would fail rather than under-match. Tokens are OR'd
+ * because someone reaching for a workspace on a phone is recalling it, not
+ * filtering it — BM25 is what puts the message matching four of four words above
+ * the one matching one, and requiring all four would return nothing whenever a
+ * single word is misremembered.
+ *
+ * The last token gets a prefix `*` so search-as-you-type matches mid-word, but only
+ * from three characters: `"a"*` matches a large fraction of the index and would
+ * spend the whole query budget on a keystroke that means nothing yet.
+ */
+export function matchQuery(raw) {
+    const tokens = raw.toLowerCase().match(/[\p{L}\p{N}_]+/gu);
+    if (!tokens?.length)
+        return null;
+    const terms = tokens.map(t => `"${t}"`);
+    const last = tokens[tokens.length - 1];
+    if (!/\s$/.test(raw) && last.length >= 3)
+        terms[terms.length - 1] = `"${last}"*`;
+    return terms.join(' OR ');
+}
+/** The tokens `matchQuery` will search for — what a caller matches names against. */
+export function queryTokens(raw) {
+    return raw.toLowerCase().match(/[\p{L}\p{N}_]+/gu) ?? [];
+}
+export class SearchIndex {
+    source;
+    file;
+    db = null;
+    openError = null;
+    cursor = 0;
+    caughtUp = false;
+    timer = null;
+    sourceMax = 0;
+    constructor(source, file) {
+        this.source = source;
+        this.file = file;
+    }
+    /** Open (or rebuild) the sidecar and start indexing in the background. */
+    start() {
+        try {
+            this.open();
+        }
+        catch (err) {
+            // A search index is a convenience; failing to open one must never stop the relay
+            // serving state, transcripts or sends. Report it on /api/search instead.
+            this.openError = err instanceof Error ? err.message : String(err);
+            console.warn(`⚠ search index unavailable (${this.openError}) — /api/search will report it`);
+            return;
+        }
+        this.schedule(0);
+    }
+    stop() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+    }
+    open() {
+        fs.mkdirSync(path.dirname(this.file), { recursive: true });
+        const db = new DatabaseSync(this.file);
+        db.exec('PRAGMA journal_mode = WAL');
+        db.exec('PRAGMA synchronous = NORMAL');
+        // A dev relay on another port shares this file with the LaunchAgent's. WAL lets them
+        // both read; the writer that loses waits rather than throwing away its batch, and a
+        // tick that still fails is retried by the scheduler with nothing lost (the cursor
+        // only advances on commit).
+        db.exec('PRAGMA busy_timeout = 5000');
+        db.exec('CREATE TABLE IF NOT EXISTS meta (k TEXT PRIMARY KEY, v TEXT NOT NULL)');
+        const version = Number(this.readMeta(db, 'version') ?? 0);
+        if (version !== SCHEMA_VERSION) {
+            db.exec('DROP TABLE IF EXISTS chunks');
+            db.exec(`
+				CREATE VIRTUAL TABLE chunks USING fts5(
+					body,
+					session_id UNINDEXED,
+					src_rowid UNINDEXED,
+					role UNINDEXED,
+					at UNINDEXED,
+					tokenize='porter unicode61'
+				)
+			`);
+            db.prepare('INSERT OR REPLACE INTO meta(k, v) VALUES (?, ?)').run('version', String(SCHEMA_VERSION));
+            db.prepare('INSERT OR REPLACE INTO meta(k, v) VALUES (?, ?)').run('cursor', '0');
+            if (version)
+                console.log(`search index schema ${version} → ${SCHEMA_VERSION}, rebuilding`);
+        }
+        this.db = db;
+        this.cursor = Number(this.readMeta(db, 'cursor') ?? 0);
+    }
+    readMeta(db, key) {
+        const row = db.prepare('SELECT v FROM meta WHERE k = ?').get(key);
+        return row?.v ?? null;
+    }
+    schedule(ms) {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = setTimeout(() => {
+            let more = false;
+            try {
+                more = this.tick();
+            }
+            catch (err) {
+                console.warn(`⚠ search index tick failed: ${err instanceof Error ? err.message : err}`);
+            }
+            this.schedule(more ? BACKFILL_PAUSE_MS : IDLE_POLL_MS);
+        }, ms);
+        this.timer.unref?.();
+    }
+    /**
+     * Index one window of source rows. Returns true while there is more to do.
+     *
+     * The window is picked by rowid *before* the prose filter runs, so the cursor
+     * advances past rows that hold nothing worth indexing. Filtering first and
+     * advancing to the last match instead would leave a caught-up index re-scanning
+     * every tool_result between the last prose row and the end of the table, every
+     * poll, forever.
+     */
+    tick() {
+        const db = this.db;
+        if (!db)
+            return false;
+        const window = this.source.query('SELECT rowid FROM session_messages WHERE rowid > ? ORDER BY rowid LIMIT ?', [this.cursor, WINDOW_ROWS]);
+        if (!window.length) {
+            this.caughtUp = true;
+            return false;
+        }
+        const end = window[window.length - 1].rowid;
+        // Only rows that can hold prose: a plain-text prompt, or a frame carrying a text
+        // block. Everything else is tool plumbing and 98.8% of the bytes.
+        const rows = this.source.query(`SELECT rowid, id, session_id, role, content, full_message, created_at, sent_at, queue_order
+			 FROM session_messages
+			 WHERE rowid > ? AND rowid <= ? AND session_id IS NOT NULL
+			   AND (role = 'user' OR content LIKE '%"type":"text"%')
+			 ORDER BY rowid`, [this.cursor, end]);
+        const insert = db.prepare('INSERT INTO chunks(body, session_id, src_rowid, role, at) VALUES (?, ?, ?, ?, ?)');
+        db.exec('BEGIN');
+        try {
+            for (const row of rows) {
+                // Reuse the transcript parser rather than a second JSON walk: it already knows
+                // that text inside a `type:"user"` frame is injected context and not the user's
+                // words, and indexing something the chat view would never show is how a search
+                // result becomes impossible to find once you open it.
+                for (const entry of parseMessage(row, null)) {
+                    if (entry.role !== 'user' && entry.role !== 'assistant')
+                        continue;
+                    const body = entry.text.trim();
+                    if (!body)
+                        continue;
+                    insert.run(body.slice(0, MAX_CHUNK_CHARS), row.session_id, row.rowid, entry.role, entry.ts);
+                }
+            }
+            db.prepare('INSERT OR REPLACE INTO meta(k, v) VALUES (?, ?)').run('cursor', String(end));
+            db.exec('COMMIT');
+        }
+        catch (err) {
+            db.exec('ROLLBACK');
+            throw err;
+        }
+        this.cursor = end;
+        return true;
+    }
+    status() {
+        if (this.openError)
+            return { chunks: 0, ready: false, progress: 0, error: this.openError };
+        const db = this.db;
+        if (!db)
+            return { chunks: 0, ready: false, progress: 0 };
+        const chunks = Number(db.prepare('SELECT COUNT(*) c FROM chunks').get().c);
+        if (this.caughtUp)
+            return { chunks, ready: true, progress: 1 };
+        // Only re-read the source's high-water mark while backfilling; it costs a query
+        // and the answer only matters for the progress bar.
+        if (!this.sourceMax) {
+            const max = this.source.query('SELECT MAX(rowid) m FROM session_messages')[0]?.m;
+            this.sourceMax = max ?? 0;
+        }
+        const progress = this.sourceMax ? Math.min(1, this.cursor / this.sourceMax) : 0;
+        return { chunks, ready: false, progress };
+    }
+    /** Top matching chunks, best first. Empty when the query has no searchable tokens. */
+    search(raw, limit = CHUNK_LIMIT) {
+        const db = this.db;
+        if (!db)
+            return [];
+        const match = matchQuery(raw);
+        if (!match)
+            return [];
+        let rows;
+        try {
+            rows = db
+                .prepare(`SELECT session_id, src_rowid, role, at, -bm25(chunks) AS score,
+					        snippet(chunks, 0, ?, ?, '…', 24) AS snippet
+					 FROM chunks WHERE chunks MATCH ? ORDER BY bm25(chunks) LIMIT ?`)
+                .all(HIT_OPEN, HIT_CLOSE, match, limit);
+        }
+        catch (err) {
+            // A MATCH that still fails to parse is a bug in matchQuery, not user error —
+            // report it rather than showing an empty result that looks like "no matches".
+            throw new Error(`search failed for ${JSON.stringify(match)}: ${err instanceof Error ? err.message : err}`);
+        }
+        return rows.map(r => ({
+            sessionId: r.session_id,
+            srcRowid: Number(r.src_rowid),
+            role: r.role === 'user' ? 'user' : 'assistant',
+            at: r.at,
+            score: Number(r.score),
+            snippet: r.snippet
+        }));
+    }
+}
+const SNIPPETS_PER_RESULT = 3;
+/**
+ * Fold chunk hits up into workspaces.
+ *
+ * Chunk-level results are the wrong unit here: one long conversation produces a
+ * dozen and buries every other workspace. What to do with those dozen is the whole
+ * ranking decision, and it was measured rather than guessed — searching this Mac's
+ * history for "removing adding lamp manual", where the right answer is a chat that
+ * says "Add by name is gone. Removed the form":
+ *
+ *   summing every hit   → right answer ranks 9th
+ *   best single hit     → 5th
+ *   sum of the top 3    → 5th, and steadier across other queries
+ *
+ * Summing everything ranks by *volume*: a 32-message conversation about lamps beat
+ * the four messages that actually removed the feature. So only the best
+ * `SNIPPETS_PER_RESULT` hits score, which caps what repetition can buy and makes
+ * the number mean something the user can check — the score is exactly the strength
+ * of the snippets shown under the row. `hits` still counts them all.
+ *
+ * Hits whose session no longer resolves to a workspace are dropped; a result nobody
+ * can open is worse than one fewer result.
+ */
+export function foldHits(hits, resolve) {
+    const byWorkspace = new Map();
+    for (const hit of hits) {
+        const workspace = resolve(hit.sessionId);
+        if (!workspace)
+            continue;
+        let entry = byWorkspace.get(workspace.id);
+        if (!entry) {
+            entry = {
+                workspace,
+                sessionId: null,
+                hits: 0,
+                score: 0,
+                at: null,
+                snippets: [],
+                byName: false,
+                bestBySession: new Map()
+            };
+            byWorkspace.set(workspace.id, entry);
+        }
+        entry.hits++;
+        if (!entry.at || hit.at > entry.at)
+            entry.at = hit.at;
+        entry.bestBySession.set(hit.sessionId, Math.max(entry.bestBySession.get(hit.sessionId) ?? 0, hit.score));
+        // `hits` arrives in BM25 order, so the first few of a workspace are its best few:
+        // scoring and snippeting the same slice needs no second sort.
+        if (entry.snippets.length < SNIPPETS_PER_RESULT) {
+            entry.score += hit.score;
+            entry.snippets.push({ sessionId: hit.sessionId, role: hit.role, at: hit.at, text: hit.snippet });
+        }
+    }
+    const results = [];
+    for (const entry of byWorkspace.values()) {
+        const { bestBySession, ...rest } = entry;
+        let sessionId = null;
+        let best = -Infinity;
+        for (const [id, score] of bestBySession) {
+            if (score <= best)
+                continue;
+            best = score;
+            sessionId = id;
+        }
+        results.push({ ...rest, sessionId });
+    }
+    return results.sort((a, b) => b.score - a.score);
+}

package/dist-node/src/server.js

@@ -12,10 +12,11 @@ import { workspaceDiff } from "./git.js";
 import { installLogCapture, isManaged, LOG_FILE_NAMES, logFiles, processStartedAt, recentLogs, redactSecrets, tailLogFile } from "./logbuf.js";
 import { mergePr } from "./merge.js";
 import { armNoSleep, disarmNoSleep, MAX_SECONDS as NOSLEEP_MAX_SECONDS, nosleepState, watchNoSleepExpiry } from "./nosleep.js";
-import { notifyAll, notifyDevice, pushConfig, startNotifier, subscribeDevice, unsubscribeDevice } from "./notify.js";
+import { chatRoute, notifyAll, notifyDevice, pushConfig, startNotifier, subscribeDevice, unsubscribeDevice } from "./notify.js";
 import { ParkedPromptQueue } from "./parked.js";
 import { attachPrStatus } from "./pr.js";
 import { Reads } from "./reads.js";
+import { foldHits, queryTokens, SearchIndex } from "./search.js";
 import { readSettings, writeSettings } from "./settings.js";
 import { driftWarningLines, tailscaleBin } from "./tailscale.js";
 import { autoJoinHotspotMode, currentSsid, looksLikeHotspot, preferredNetworks } from "./wifi.js";
@@ -27,6 +28,11 @@ const cfg = loadConfig();
 const db = new ConductorDb(cfg.dbPath);
 const reads = new Reads(db, cfg.workspacesRoot);
 const actuator = pickActuator(cfg.writeStrategy);
+// Full-text index over the chat prose, in the relay's own sidecar DB — never in
+// Conductor's (see src/search.ts). It backfills in the background and is disposable:
+// deleting the file rebuilds it on the next start.
+const search = new SearchIndex(db, path.join(stateDir(), 'search.db'));
+search.start();
 // A windowless Conductor that ignores reopen *and* a Dock click can only be fixed
 // by restarting it — and quitting takes any agent mid-turn down with it. So the
 // write path may only do that while nothing is working, which is a DB fact, not
@@ -288,7 +294,7 @@ const parkedPrompts = new ParkedPromptQueue(path.join(stateDir(), 'parked-prompt
             body: error ? `Parked prompt failed: ${error}` : `Sent after unlock: ${preview}`,
             // Per chat, so a second parked prompt replaces the first's notification.
             tag: `parked-${entry.sessionId}`,
-            url: `/w/${entry.workspaceId}`,
+            url: chatRoute(entry.workspaceId, entry.sessionId),
             kind: error ? 'error' : 'done',
             ts: Date.now()
         });
@@ -418,6 +424,49 @@ const server = http.createServer(async (req, res) => {
                 update
             });
         }
+        // GET /api/search?q= — find a workspace by its name or by what was said in its chats.
+        //
+        // Two sources, merged. `findWorkspacesByName` matches the workspace's own identity
+        // and wins ties, because someone who types a name wants that workspace and not the
+        // twelve chats that mention it. The transcript index answers the harder question —
+        // "which workspace did I do this in" — and is the only one that can, since the
+        // words you remember are usually the agent's, not the branch's.
+        //
+        // Both reach archived workspaces. That is the point: 1,846 of the 1,886 here are
+        // archived, so a search limited to the live sidebar would miss almost everything.
+        if (req.method === 'GET' && pathname === '/api/search') {
+            const q = url.searchParams.get('q') ?? '';
+            // 12, not 50: an OR query over common words ("add", "remove") has a long weak tail,
+            // and past the first screenful nobody scrolls — they retype instead.
+            const limit = Math.min(50, Math.max(1, Number(url.searchParams.get('limit') ?? 12) || 12));
+            const index = search.status();
+            const tokens = queryTokens(q);
+            if (!tokens.length)
+                return json(req, res, 200, { query: q, results: [], index });
+            const hits = search.search(q);
+            const targets = reads.searchTargets([...new Set(hits.map(h => h.sessionId))]);
+            const fromChats = foldHits(hits, sid => targets.get(sid)?.workspace ?? null);
+            const remaining = new Map(fromChats.map(r => [r.workspace.id, r]));
+            const merged = [];
+            for (const workspace of reads.findWorkspacesByName(tokens, limit)) {
+                const evidence = remaining.get(workspace.id);
+                remaining.delete(workspace.id);
+                // Keep the chat evidence when there is any: the snippet is what tells you this
+                // is the right "fix-lamp-thing" out of three with similar names.
+                merged.push(evidence
+                    ? { ...evidence, byName: true }
+                    : { workspace, sessionId: null, hits: 0, score: 0, at: null, snippets: [], byName: true });
+            }
+            merged.push(...remaining.values());
+            return json(req, res, 200, {
+                query: q,
+                index,
+                results: merged.slice(0, limit).map(r => ({
+                    ...r,
+                    sessionTitle: r.sessionId ? (targets.get(r.sessionId)?.sessionTitle ?? null) : null
+                }))
+            });
+        }
         // GET /api/repos — repos a new workspace can be created in
         if (req.method === 'GET' && pathname === '/api/repos') {
             return json(req, res, 200, { repos: reads.listRepos() });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "conductor-remote",
-	"version": "1.39.0",
+	"version": "1.41.0",
 	"type": "module",
 	"packageManager": "yarn@4.15.0",
 	"description": "Phone control panel for local Conductor agents. Reads ride SQLite + git; prompts ride Conductor's own dispatch path.",