@playola-radio/slipstream 0.1.0 → 0.3.0

package/dist/cli.js

@@ -9,25 +9,45 @@
  *   slipstream serve [dir] [--store <dir>]
  *   slipstream view  ...
  *
- * Shared daemon (Stage 3): one long-lived daemon owns the shared store, one
- * public reader, and at most one active capture; the other verbs are thin
- * control clients that talk to it over its private socket. `start` comes up
- * detached — attach a worktree to begin capture.
+ * Shared daemon: one long-lived daemon owns the shared store, one public
+ * reader, and one capture per workspace (up to the capture cap); the other verbs
+ * are thin control clients that talk to it over its private socket. `start` comes
+ * up with nothing recording — attach a worktree to begin capture.
  *
  *   slipstream start  [--store <dir>]
+ *   slipstream attach [dir] [--store <dir>]   (from inside the agent chat to connect)
+ *   slipstream attach --watch-only [dir] [--wait] [--store <dir>]
  *   slipstream attach [dir] [--store <dir>] --harness <name> --harness-session-id <id>
- *   slipstream status [--store <dir>]
- *   slipstream detach [--store <dir>]
+ *   slipstream status [<target>] [--store <dir>]
+ *   slipstream detach [<target>] [--store <dir>]   (target: session id or workspace; default: this directory)
+ *   slipstream unlink --session <id> [--store <dir>]
+ *
+ * Conductor integration: install the LaunchAgent and chain setup/archive into
+ * Conductor's scripts, the scripts themselves, and enrollment of existing
+ * workspaces.
+ *
+ *   slipstream conductor install|setup|archive|enroll [--store <dir>]
+ *
+ * Workspaces without Conductor: a git worktree under ~/slipstream/workspaces,
+ * set up and recorded, and later archived.
+ *
+ *   slipstream workspace create <repo-dir> [--store <dir>]
+ *   slipstream workspace archive <workspace-dir> [--store <dir>]
  *
  * Maintenance of retained sessions (only while the daemon is detached):
  *
  *   slipstream delete <session-id> [--store <dir>]
  *   slipstream gc     [--store <dir>]
  */
-import { readFile, open, lstat, constants } from 'node:fs/promises';
-import { resolve } from 'node:path';
+import { readFile, open, lstat, realpath, constants } from 'node:fs/promises';
+import { spawn, execFile } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { join, resolve } from 'node:path';
 import { defaultDaemonStore, controlSocketPath } from "./daemon-location.js";
 import { startCapture } from "./session.js";
+import { acquireSessionLock, SessionOwnedError } from "./lock.js";
+import { mkdirpDurable } from "./storage.js";
+import { intentPath } from "./intent-store.js";
 import { startReaderServer } from "./http-reader.js";
 import { startDaemon, probeSocket, PROBE_TIMEOUT_MS } from "./daemon.js";
 import { sendControlRequest, OutcomeUnknownError } from "./control-client.js";
@@ -36,9 +56,18 @@ import { MAX_MESSAGE_BYTES } from "./control-protocol.js";
 import { QUESTION_TTL_MS } from "./questions.js";
 import { codexPostToolUse, claudePostToolUse, readHookInput } from "./question-hook.js";
 import { runTui } from "./tui.js";
+import { runAttachWorkflow, runWatchOnlyAttach, runIdentityAttach } from "./attach-workflow.js";
+import { runUnlink, runWithdraw } from "./withdraw-workflow.js";
+import { DaemonUnavailableError, ensureDaemon } from "./ensure-daemon.js";
+import { kickstartLaunchAgent, readManagedInstall } from "./launch-agent.js";
+import { InventoryError, readConductorInventory, runConductorArchive, runConductorEnroll, runConductorInstall, runConductorSetup, sharedScripts, } from "./conductor.js";
+import { runWorkspaceArchive, runWorkspaceCreate } from "./workspace.js";
 import { isMainModule } from "./entrypoint.js";
 import { loadConfig } from "./config.js";
 import { homedir } from 'node:os';
+const CONDUCTOR_ACTIONS = ['install', 'setup', 'archive', 'enroll'];
+const WORKSPACE_ACTIONS = ['create', 'archive'];
+const CONDUCTOR_DB = join(homedir(), 'Library', 'Application Support', 'com.conductor.app', 'conductor.db');
 /** The shared daemon's default store lives under the home dir, not the worktree:
  * one daemon serves every worktree from a single owner-only root. */
 const DEFAULT_DAEMON_STORE = defaultDaemonStore();
@@ -202,16 +231,62 @@ function parseAsk(rest) {
         return null;
     return { store, sessionId, requestId, inputPath };
 }
+/** `[<target>] [--store <dir>]` for `status` and `detach`. A session id is sent
+ * as is; anything else is a workspace path, made absolute here because the
+ * daemon runs in another directory. */
+function parseTargeted(rest) {
+    let store;
+    let target;
+    for (let i = 0; i < rest.length; i++) {
+        const arg = rest[i];
+        if (arg === '--store') {
+            const value = rest[++i];
+            if (value === undefined || value.startsWith('--'))
+                return null;
+            store = resolve(value);
+        }
+        else if (arg.startsWith('--') || target !== undefined)
+            return null;
+        else
+            target = isValidSessionId(arg) ? arg : resolve(arg);
+    }
+    return { store: store ?? DEFAULT_DAEMON_STORE, ...(target !== undefined ? { target } : {}) };
+}
+function parseUnlink(rest) {
+    let store;
+    let sessionId;
+    for (let i = 0; i < rest.length; i++) {
+        const arg = rest[i];
+        const value = rest[++i];
+        if (value === undefined || value.startsWith('--'))
+            return null;
+        if (arg === '--store')
+            store = resolve(value);
+        else if (arg === '--session' && sessionId === undefined)
+            sessionId = value;
+        else
+            return null;
+    }
+    if (sessionId === undefined)
+        return null;
+    return { store: store ?? DEFAULT_DAEMON_STORE, sessionId };
+}
 function parseAttach(rest) {
     let dir = process.cwd();
     let store;
     let harness;
     let harnessSessionId;
     let rootTranscript;
+    let watchOnly = false;
+    let wait = false;
     let sawDir = false;
     for (let i = 0; i < rest.length; i++) {
         const arg = rest[i];
-        if (arg === '--store' || arg === '--harness' || arg === '--harness-session-id' || arg === '--root-transcript') {
+        if (arg === '--watch-only')
+            watchOnly = true;
+        else if (arg === '--wait')
+            wait = true;
+        else if (arg === '--store' || arg === '--harness' || arg === '--harness-session-id' || arg === '--root-transcript') {
             const value = rest[++i];
             if (value === undefined || value.startsWith('--'))
                 return null;
@@ -233,6 +308,13 @@ function parseAttach(rest) {
         else
             return null; // unknown flag
     }
+    if (wait && !watchOnly)
+        return null;
+    if (watchOnly) {
+        if (harness !== undefined || harnessSessionId !== undefined || rootTranscript !== undefined)
+            return null;
+        return { dir, store: store ?? DEFAULT_DAEMON_STORE, watchOnly, wait };
+    }
     return { dir, store: store ?? DEFAULT_DAEMON_STORE, harness, harnessSessionId, ...(rootTranscript ? { rootTranscript } : {}) };
 }
 export function parseArgs(argv) {
@@ -249,12 +331,24 @@ export function parseArgs(argv) {
             return null;
         return { command, store: parsed.store, configPath: parsed.configPath, overrides: parsed.overrides };
     }
-    if (command === 'status' || command === 'detach' || command === 'gc') {
+    if (command === 'gc') {
         const store = parseStoreOnly(argv.slice(1));
         if (store === null)
             return null;
         return { command, store };
     }
+    if (command === 'status') {
+        const parsed = parseTargeted(argv.slice(1));
+        return parsed && { command, ...parsed };
+    }
+    if (command === 'detach') {
+        const parsed = parseTargeted(argv.slice(1));
+        return parsed && { command, store: parsed.store, target: parsed.target ?? process.cwd() };
+    }
+    if (command === 'unlink') {
+        const parsed = parseUnlink(argv.slice(1));
+        return parsed && { command, ...parsed };
+    }
     if (command === 'attach') {
         const parsed = parseAttach(argv.slice(1));
         if (!parsed)
@@ -281,6 +375,17 @@ export function parseArgs(argv) {
             return null;
         return { command: 'ask', ...parsed };
     }
+    if (command === 'conductor' && CONDUCTOR_ACTIONS.includes(argv[1] ?? '')) {
+        const store = parseStoreOnly(argv.slice(2));
+        return store === null ? null : { command, action: argv[1], store };
+    }
+    if (command === 'workspace' && WORKSPACE_ACTIONS.includes(argv[1] ?? '')) {
+        const dir = argv[2];
+        if (dir === undefined || dir.startsWith('--'))
+            return null;
+        const store = parseStoreOnly(argv.slice(3));
+        return store === null ? null : { command, action: argv[1], dir: resolve(dir), store };
+    }
     if (command === 'view')
         return { command: 'view' };
     return null;
@@ -294,11 +399,19 @@ function usage() {
     console.error('       slipstream serve  [dir] [--store <dir>]');
     console.error('       slipstream start  [--store <dir>] [--config <file>] [--enable <harness>]');
     console.error('                         [--window-ms N] [--grace-ms N] [--claude-home <dir>] [--codex-home <dir>] [--codex-scan-limit N]');
+    console.error('       slipstream attach [dir] [--store <dir>]   (run inside the agent chat to connect)');
+    console.error('       slipstream attach --watch-only [dir] [--wait] [--store <dir>]');
     console.error('       slipstream attach [dir] [--store <dir>] --harness <name> --harness-session-id <id> [--root-transcript <path>]');
     console.error('       slipstream hook codex post-tool-use --store <dir>');
     console.error('       slipstream hook claude-code post-tool-use --store <dir>');
-    console.error('       slipstream status [--store <dir>]');
-    console.error('       slipstream detach [--store <dir>]');
+    console.error('       slipstream status [<session-id or dir>] [--store <dir>]');
+    console.error('       slipstream detach [<session-id or dir>] [--store <dir>]   (default: this directory)');
+    console.error('       slipstream unlink --session <session-id> [--store <dir>]');
+    console.error('       slipstream conductor install [--store <dir>]   (LaunchAgent + Conductor setup/archive scripts)');
+    console.error('       slipstream conductor enroll  [--store <dir>]   (capture every existing Conductor workspace)');
+    console.error('       slipstream conductor setup|archive [--store <dir>]   (run by Conductor\'s scripts)');
+    console.error('       slipstream workspace create <repo-dir> [--store <dir>]   (new worktree under ~/slipstream/workspaces)');
+    console.error('       slipstream workspace archive <workspace-dir> [--store <dir>]');
     console.error('       slipstream ask --store <dir> --session <capture-id> --request-id <uuid> --input <json-file>');
     console.error('       slipstream delete <session-id> [--store <dir>]');
     console.error('       slipstream gc     [--store <dir>]');
@@ -451,11 +564,14 @@ export function retryGuidance(verb) {
             return 'run `slipstream status` before retrying; the request may have committed.';
     }
 }
-async function runControl(store, request) {
+async function runControl(store, request, printOk) {
     const socketPath = controlSocketPath(store);
     try {
         const res = await sendControlRequest({ socketPath, request: { v: 1, ...request } });
-        reportControl(res);
+        if (res.ok && printOk)
+            printOk(res);
+        else
+            reportControl(res);
     }
     catch (err) {
         if (err instanceof OutcomeUnknownError) {
@@ -469,6 +585,226 @@ async function runControl(store, request) {
         throw err;
     }
 }
+/** Detach, unlink or archive: through the daemon, or recorded offline without one. */
+async function runWithdrawal(store, run, verb) {
+    const socketPath = controlSocketPath(store);
+    try {
+        process.exitCode = await run({ store, out: (line) => console.log(line), err: (line) => console.error(line),
+            control: (request) => sendControlRequest({ socketPath, request: { v: 1, ...request } }) });
+    }
+    catch (err) {
+        if (!(err instanceof OutcomeUnknownError))
+            throw err;
+        console.error(`slipstream: outcome unknown — ${err.message}`);
+        console.error(`slipstream: ${retryGuidance(verb)}`);
+        process.exitCode = 3;
+    }
+}
+/** Human-readable `status`: the daemon, then one block per capture. */
+export function formatStatus(res) {
+    const lines = [`reader_url: ${String(res.reader_url)}`];
+    const slots = res.binding_slots;
+    if (slots)
+        lines.push(`linked_chats: ${slots.used}/${slots.limit}`);
+    const rows = res.capture ? [res.capture] : (res.captures ?? []);
+    if (!res.capture)
+        lines.push(`captures: ${rows.length}`);
+    for (const row of rows) {
+        lines.push('', `${String(row.root)}`);
+        lines.push(`  session_id: ${String(row.session_id)}`);
+        lines.push(`  state: ${String(row.state)}${row.reason ? ` (${String(row.reason)})` : ''}`);
+        if (row.message)
+            lines.push(`  ${String(row.message)}`);
+        const b = row.binding;
+        lines.push(b
+            ? `  chat: ${String(b.harness)} ${String(b.harness_session_id)} ${String(b.state)} (generation ${String(b.binding_generation)})`
+            : '  chat: none');
+    }
+    return lines;
+}
+/** `slipstream attach --watch-only` records a workspace without linking a chat. */
+async function runWatchOnly(dir, store, wait) {
+    const socketPath = controlSocketPath(store);
+    try {
+        return await runWatchOnlyAttach({ dir, wait }, {
+            out: (line) => console.log(line),
+            err: (line) => console.error(line),
+            control: (request) => sendControlRequest({ socketPath, request: { v: 1, ...request } }),
+        });
+    }
+    catch (err) {
+        if (!(err instanceof OutcomeUnknownError))
+            throw err;
+        console.error(`slipstream: outcome unknown — ${err.message}`);
+        console.error(`slipstream: ${retryGuidance('attach')}`);
+        return 3;
+    }
+}
+/** Watch-only attach that first starts this store's daemon when none is running. */
+async function watchOnlyWithDaemon(dir, store, wait) {
+    const cliPath = await realpath(fileURLToPath(import.meta.url));
+    try {
+        await ensureDaemon(store, await daemonStarter(store, cliPath));
+    }
+    catch (err) {
+        if (!(err instanceof DaemonUnavailableError))
+            throw err;
+        console.error(`slipstream: ${err.message}`);
+        return 1;
+    }
+    return runWatchOnly(dir, store, wait);
+}
+const runCommand = (command, commandArgs) => new Promise((done) => {
+    execFile(command, commandArgs, { timeout: 30_000 }, (err, stdout, stderr) => {
+        const code = err ? (typeof err.code === 'number' ? err.code : null) : 0;
+        done({ code, output: `${stdout}${stderr}` });
+    });
+});
+/** How to start this store's daemon: through launchd when `conductor install`
+ * manages it, so there is only ever the supervised one; otherwise detached. */
+async function daemonStarter(store, cliPath) {
+    const socketPath = controlSocketPath(store);
+    const probe = () => probeSocket(socketPath, PROBE_TIMEOUT_MS);
+    const managed = await readManagedInstall(store).catch(() => null);
+    if (managed && process.getuid) {
+        const uid = process.getuid();
+        return { probe, logPath: managed.log, startDaemon: () => kickstartLaunchAgent(uid, runCommand) };
+    }
+    return {
+        probe,
+        startDaemon: () => {
+            const child = spawn(process.execPath, [cliPath, 'start', '--store', store], { cwd: homedir(), detached: true, stdio: 'ignore' });
+            const exited = new Promise((done) => {
+                child.once('exit', (code) => done(code));
+                child.once('error', () => done(null));
+            });
+            child.unref();
+            return { exited };
+        },
+    };
+}
+async function packageVersion() {
+    return JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf8')).version;
+}
+async function runConductor(action, store) {
+    const cliPath = await realpath(fileURLToPath(import.meta.url));
+    const socketPath = controlSocketPath(store);
+    const out = (line) => console.log(line);
+    const err = (line) => console.error(line);
+    const control = (request) => sendControlRequest({ socketPath, request: { v: 1, ...request } });
+    const ensure = async () => ensureDaemon(store, await daemonStarter(store, cliPath));
+    if (action === 'install') {
+        if (!process.getuid) {
+            err('slipstream: `conductor install` needs macOS launchd.');
+            return 1;
+        }
+        return runConductorInstall({
+            home: homedir(), store, uid: process.getuid(), execPath: process.execPath, nodeVersion: process.versions.node,
+            cliPath, packageVersion: await packageVersion(), run: runCommand, out, err,
+            listRepos: async () => (await readConductorInventory(CONDUCTOR_DB)).repos,
+        });
+    }
+    if (action === 'setup') {
+        return runConductorSetup({ env: process.env, store, packageVersion: await packageVersion(), ensureDaemon: ensure, err,
+            attach: (dir) => runWatchOnly(dir, store, true) });
+    }
+    if (action === 'archive') {
+        await runWithdrawal(store, (deps) => runConductorArchive({ env: process.env, err,
+            withdraw: (target) => runWithdraw({ target, reason: 'archived', missingOk: true }, deps) }), 'detach');
+        return Number(process.exitCode ?? 0);
+    }
+    let inventory;
+    try {
+        inventory = await readConductorInventory(CONDUCTOR_DB);
+    }
+    catch (e) {
+        if (!(e instanceof InventoryError))
+            throw e;
+        err(`slipstream: ${e.message}`);
+        return 1;
+    }
+    try {
+        return await runConductorEnroll(inventory, { ensureDaemon: ensure, control, out, err });
+    }
+    catch (e) {
+        if (!(e instanceof OutcomeUnknownError))
+            throw e;
+        err(`slipstream: outcome unknown — ${e.message}`);
+        err(`slipstream: ${retryGuidance('attach')}`);
+        return 3;
+    }
+}
+async function runWorkspace(action, dir, store) {
+    const deps = {
+        home: homedir(),
+        git: (args, cwd) => new Promise((done) => {
+            execFile('git', args, { cwd, env: { ...process.env, GIT_TERMINAL_PROMPT: '0' } }, (err, stdout, stderr) => {
+                done({ code: err ? (typeof err.code === 'number' ? err.code : null) : 0, output: `${stdout}${stderr}` });
+            });
+        }),
+        record: (path) => watchOnlyWithDaemon(path, store, true),
+        withdraw: async (path) => {
+            await runWithdrawal(store, (w) => runWithdraw({ target: path, reason: 'archived', missingOk: true }, w), 'detach');
+            return Number(process.exitCode ?? 0);
+        },
+        scripts: sharedScripts,
+        runScript: (script, cwd, env) => new Promise((done) => {
+            const child = spawn('/bin/sh', ['-c', script], { cwd, env: { ...process.env, ...env }, stdio: ['ignore', 'inherit', 'inherit'] });
+            child.once('exit', (code) => done(code ?? 1));
+            child.once('error', () => done(1));
+        }),
+        exists: (path) => lstat(path).then(() => true, () => false),
+        realpath: (path) => realpath(path),
+        out: (line) => console.log(line),
+        err: (line) => console.error(line),
+    };
+    return action === 'create' ? runWorkspaceCreate(dir, deps) : runWorkspaceArchive(dir, deps);
+}
+async function runIdentity(store, request) {
+    const socketPath = controlSocketPath(store);
+    try {
+        process.exitCode = await runIdentityAttach(request, {
+            out: (line) => console.log(line),
+            err: (line) => console.error(line),
+            control: (req) => sendControlRequest({ socketPath, request: { v: 1, ...req } }),
+            report: (res) => reportControl({ v: 1, ok: true, ...res }),
+        });
+    }
+    catch (err) {
+        if (!(err instanceof OutcomeUnknownError))
+            throw err;
+        console.error(`slipstream: outcome unknown — ${err.message}`);
+        console.error(`slipstream: ${retryGuidance('attach')}`);
+        process.exitCode = 3;
+    }
+}
+/** `slipstream attach` without identity flags connects the chat it runs in. */
+async function runThisChatAttach(dir, store) {
+    const socketPath = controlSocketPath(store);
+    const cliPath = await realpath(fileURLToPath(import.meta.url));
+    try {
+        process.exitCode = await runAttachWorkflow({ dir, store }, {
+            env: process.env, home: homedir(), nodePath: process.execPath, cliPath,
+            out: (line) => console.log(line),
+            err: (line) => console.error(line),
+            ...await daemonStarter(store, cliPath),
+            control: (request) => sendControlRequest({ socketPath, request: { v: 1, ...request } }),
+            run: (command, commandArgs, cwd) => new Promise((done) => {
+                execFile(command, commandArgs, { cwd, timeout: 30_000 }, (err, stdout, stderr) => {
+                    const code = err ? (typeof err.code === 'number' ? err.code : null) : 0;
+                    done({ code, output: `${stdout}${stderr}` });
+                });
+            }),
+        });
+    }
+    catch (err) {
+        if (!(err instanceof OutcomeUnknownError))
+            throw err;
+        console.error(`slipstream: outcome unknown — ${err.message}`);
+        console.error(`slipstream: ${retryGuidance('attach')}`);
+        process.exitCode = 3;
+    }
+}
 async function main() {
     const args = parseArgs(process.argv.slice(2));
     if (!args) {
@@ -504,7 +840,7 @@ async function main() {
         const daemon = await startDaemon({ storeDir: args.store, config });
         console.error(`slipstream: daemon control ${daemon.socketPath}`);
         console.error(`slipstream: reader ${daemon.readerUrl}`);
-        console.error('slipstream: detached; `slipstream attach <dir>` a worktree to begin capture');
+        console.error('slipstream: nothing is recording yet; `slipstream attach <dir>` a worktree to begin capture');
         console.error('slipstream: press Ctrl-C to stop');
         let stopping = false;
         const stop = async () => {
@@ -519,11 +855,15 @@ async function main() {
         return;
     }
     if (args.command === 'status') {
-        await runControl(args.store, { verb: 'status' });
+        await runControl(args.store, { verb: 'status', ...(args.target !== undefined ? { target: args.target } : {}) }, (res) => formatStatus(res).forEach((line) => console.log(line)));
         return;
     }
     if (args.command === 'detach') {
-        await runControl(args.store, { verb: 'detach' });
+        await runWithdrawal(args.store, (deps) => runWithdraw({ target: args.target, reason: 'detached' }, deps), 'detach');
+        return;
+    }
+    if (args.command === 'unlink') {
+        await runWithdrawal(args.store, (deps) => runUnlink({ sessionId: args.sessionId }, deps), 'unlink');
         return;
     }
     if (args.command === 'ask') {
@@ -544,8 +884,24 @@ async function main() {
         });
         return;
     }
+    if (args.command === 'attach' && args.watchOnly) {
+        process.exitCode = await watchOnlyWithDaemon(args.dir, args.store, args.wait === true);
+        return;
+    }
+    if (args.command === 'conductor') {
+        process.exitCode = await runConductor(args.action, args.store);
+        return;
+    }
+    if (args.command === 'workspace') {
+        process.exitCode = await runWorkspace(args.action, args.dir, args.store);
+        return;
+    }
+    if (args.command === 'attach' && !args.harness && !args.harnessSessionId && !args.rootTranscript) {
+        await runThisChatAttach(args.dir, args.store);
+        return;
+    }
     if (args.command === 'attach') {
-        await runControl(args.store, {
+        await runIdentity(args.store, {
             verb: 'attach',
             worktree: args.dir,
             harness: args.harness,
@@ -573,10 +929,52 @@ async function main() {
     // Standalone capture: never over a daemon-owned store.
     if (await isDaemonOwned(args.store))
         return;
-    const session = await startCapture({ root: args.dir, storeDir: args.store });
+    // Hold the store lock for the whole capture, as the daemon does: gc and offline
+    // intent writers then know this store has a writer they must not run beside.
+    await mkdirpDurable(args.store);
+    let session;
+    let storeLock;
+    try {
+        storeLock = await acquireSessionLock(args.store, { onCompromised: (reason) => {
+                console.error(`slipstream: lost the store lock (${reason}); stopping capture`);
+                void (session?.stop() ?? Promise.resolve()).finally(() => process.exit(1));
+            } });
+    }
+    catch (err) {
+        if (!(err instanceof SessionOwnedError))
+            throw err;
+        console.error(`slipstream: ${args.store} is in use by another slipstream process (${err.message}).`);
+        console.error('slipstream: use `slipstream attach` to capture through the daemon, or choose another --store.');
+        process.exitCode = 2;
+        return;
+    }
+    // Readers take a live store lock to mean a daemon will start this store's
+    // queued captures (contracts.md §7), so never hold a daemon store's lock for
+    // a capture. Checked under the lock: only a lock holder creates the record.
+    const daemonStore = await lstat(intentPath(args.store)).then(() => true, async (err) => {
+        if (err.code === 'ENOENT')
+            return false;
+        await storeLock.release();
+        throw err;
+    });
+    if (daemonStore) {
+        await storeLock.release();
+        console.error(`slipstream: ${args.store} belongs to the slipstream daemon (it has capture intent).`);
+        console.error('slipstream: use `slipstream attach` to capture through the daemon, or choose another --store.');
+        process.exitCode = 2;
+        return;
+    }
+    try {
+        session = await startCapture({ root: args.dir, storeDir: args.store });
+    }
+    catch (err) {
+        await storeLock.release().catch(() => { });
+        throw err;
+    }
+    const captured = session;
     console.error(`slipstream: watching ${args.dir}`);
-    console.error(`slipstream: session ${session.sessionId}`);
-    console.error(`slipstream: log ${session.logPath}`);
+    console.error(`slipstream: session ${captured.sessionId}`);
+    console.error(`slipstream: log ${captured.logPath}`);
     // Shared clean-shutdown wiring for both watch and serve. `teardown` runs any
     // subsystem stop (e.g. the reader server) BEFORE capture stops, so both report
     // cleanly and the log's tail append and drain complete.
@@ -587,9 +985,10 @@ async function main() {
                 return;
             stopping = true;
             await teardown();
-            await session.stop();
-            const n = await countRecords(session.logPath);
-            console.error(`slipstream: stopped; ${n} record(s) committed to ${session.logPath}`);
+            await captured.stop();
+            await storeLock.release();
+            const n = await countRecords(captured.logPath);
+            console.error(`slipstream: stopped; ${n} record(s) committed to ${captured.logPath}`);
             process.exit(0);
         };
         process.on('SIGINT', stop);
@@ -606,16 +1005,17 @@ async function main() {
     try {
         server = await startReaderServer({
             storeDir: args.store,
-            active: { id: session.sessionId, health: session.health, logPath: session.logPath },
+            active: { id: captured.sessionId, health: captured.health, logPath: captured.logPath },
         });
     }
     catch (err) {
         try {
-            await session.stop();
+            await captured.stop();
         }
         catch (stopError) {
             console.error('slipstream: capture cleanup failed', stopError);
         }
+        await storeLock.release().catch(() => { });
         throw err;
     }
     console.error(`slipstream: reader ${server.url}`);

package/dist/clip-function-parser.js

@@ -1,7 +1,7 @@
 import { createRequire } from 'node:module';
 import { Parser, Language } from 'web-tree-sitter';
-// Computing callers prepare only the requested grammar. Initialization remains
-// inside the existing job/deadline; unused grammars do not tax cold requests.
+// Computing callers prepare only the requested grammar. A clip worker also warms
+// every grammar when it starts, so cold startup is off the request deadline.
 const require = createRequire(import.meta.url);
 let initialization;
 const grammars = new Map();
@@ -23,6 +23,13 @@ export async function createFunctionIndexer(language) {
     const grammar = await pending;
     return text => indexFunctions(text, grammar);
 }
+/** Load and first-parse each grammar ahead of any request. A failed load is not
+ *  retained, so the request path retries it and reports its own failure. */
+export async function warmFunctionIndexers() {
+    await Promise.all(['typescript', 'tsx', 'javascript'].map(async (language) => {
+        (await createFunctionIndexer(language))('function f() {}\n');
+    }));
+}
 const FUNCTION_TYPES = new Set([
     'function_declaration', 'function_expression', 'generator_function_declaration',
     'generator_function', 'arrow_function', 'method_definition',

package/dist/clip-projection-service.js

@@ -155,6 +155,28 @@ export function createClipProjectionService(opts) {
                 return false;
         return true;
     };
+    // A replacement may be installed while waiting, so re-check the current worker.
+    const currentReady = () => opts.compute ? opts.compute.ready : pool.ready;
+    const workerReadyWithin = async (first, ms) => {
+        const giveUpAt = Date.now() + ms;
+        let ready = first;
+        while (ready) {
+            let timer;
+            const remaining = giveUpAt - Date.now();
+            const settled = remaining > 0 && await Promise.race([
+                ready.then(() => true),
+                new Promise(resolve => { timer = setTimeout(() => resolve(false), remaining); }),
+            ]);
+            clearTimeout(timer);
+            if (!settled)
+                return false;
+            const current = currentReady();
+            if (current === ready)
+                return true;
+            ready = current;
+        }
+        return true;
+    };
     const get = async (req) => {
         if (closed)
             return transient(req.changeSeq, 'worker-error');
@@ -168,6 +190,12 @@ export function createClipProjectionService(opts) {
             }
             cache.delete(key); // referenced blob GC'd — never serve a stale hit
         }
+        // Worker warm-up stays outside the compute deadline, but a request waits on
+        // it for at most one deadline. A still-warming worker is never dispatched
+        // to, so it is not terminated; the request reports a transient timeout.
+        const ready = currentReady();
+        if (ready && !(await workerReadyWithin(ready, deadlineMs)))
+            return transient(req.changeSeq, 'timeout');
         // Only the coalescing leader's `run` is ever invoked (the budget calls it
         // once per flight); a coalesced waiter never sees this flip, so only the
         // leader writes the cache entry — waiters would otherwise redundantly