@playola-radio/slipstream 0.1.0 → 0.3.0

package/dist/clip-projection-worker.js

@@ -9,9 +9,13 @@
  */
 import { parentPort } from 'node:worker_threads';
 import { computeClipProjection } from "./clip-blob-reader.js";
+import { warmFunctionIndexers } from "./clip-function-parser.js";
 if (!parentPort)
     throw new Error('clip-projection-worker must run as a worker thread');
 const port = parentPort;
+// A replacement worker would otherwise pay parser startup inside its first job's
+// deadline. Warm failures are not retained; a job's own load reports them.
+void warmFunctionIndexers().catch(() => { }).then(() => port.postMessage({ kind: 'ready' }));
 port.on('message', (msg) => {
     const traceTimings = msg.traceTimings ? [] : undefined;
     computeClipProjection(msg.job, traceTimings ? (phase, durationNs) => traceTimings.push({ phase, durationNs }) : undefined).then((result) => port.postMessage({ id: msg.id, ok: true, result, traceTimings }), () => port.postMessage({ id: msg.id, ok: false }));

package/dist/clip-worker-pool.js

@@ -11,6 +11,9 @@ import { Worker } from 'node:worker_threads';
 import { siblingModuleUrl } from "./sibling-module.js";
 import { CLIP_PROJECTION_VERSION } from "./clip-projection.js";
 import { emitProjectionPhase, emitProjectionTrace, traceProcessId } from "./projection-trace.js";
+function isReadyMessage(message) {
+    return 'kind' in message && message.kind === 'ready';
+}
 const WORKER_URL = siblingModuleUrl('clip-projection-worker', import.meta.url);
 function workerErrorResult() {
     return {
@@ -33,6 +36,7 @@ export function createClipWorkerPool(trace) {
     // CPU-heavy worker is still mid-terminate.
     const pendingTerminations = new Set();
     const identities = new WeakMap();
+    let workerReady = Promise.resolve();
     const trackTermination = (w, traceUnitId) => {
         const processId = identities.get(w);
         if (processId !== undefined && traceUnitId !== undefined)
@@ -42,6 +46,8 @@ export function createClipWorkerPool(trace) {
         p.finally(() => pendingTerminations.delete(p));
     };
     const spawn = () => {
+        let resolveReady;
+        workerReady = new Promise(resolve => { resolveReady = resolve; });
         const startedAtNs = trace ? process.hrtime.bigint() : undefined;
         const w = new Worker(WORKER_URL);
         const processId = trace ? traceProcessId() : undefined;
@@ -52,6 +58,10 @@ export function createClipWorkerPool(trace) {
             w.on('exit', code => emitProjectionTrace(trace, { kind: 'process-exit', processId, code, atNs: process.hrtime.bigint() }));
         }
         w.on('message', (resp) => {
+            if (isReadyMessage(resp)) {
+                resolveReady();
+                return;
+            }
             const cur = current;
             if (!cur || cur.id !== resp.id)
                 return; // stale message from before a cancel
@@ -64,6 +74,7 @@ export function createClipWorkerPool(trace) {
             cur.resolve(resp.ok ? resp.result : workerErrorResult());
         });
         w.on('error', () => {
+            resolveReady();
             const cur = current;
             current = null;
             trackTermination(w, cur?.traceUnitId);
@@ -72,6 +83,7 @@ export function createClipWorkerPool(trace) {
             if (cur)
                 cur.resolve(workerErrorResult());
         });
+        w.once('exit', () => resolveReady());
         return w;
     };
     let worker = spawn();
@@ -114,5 +126,5 @@ export function createClipWorkerPool(trace) {
         await worker.terminate().catch(() => { });
         await Promise.all(pendingTerminations);
     };
-    return { run, close };
+    return { run, get ready() { return workerReady; }, close };
 }

package/dist/codex-root-transcript.js

@@ -0,0 +1,46 @@
+import { constants } from 'node:fs';
+import { open, realpath } from 'node:fs/promises';
+const SUPPORTED_CODEX_VERSIONS = new Set(['0.154.0', '0.155.1']);
+const MAX_CODEX_META_BYTES = 64 * 1024;
+/** Verify the selected transcript's own first record. It binds the reported
+ * session and worktree without treating either as authorship. Any missing,
+ * mismatched, or unobserved runtime metadata is `false`. */
+export async function verifyCodexRootTranscript(path, sessionId, worktree) {
+    try {
+        const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+        let bytes;
+        try {
+            if (!(await handle.stat()).isFile())
+                return false;
+            const buffer = Buffer.alloc(MAX_CODEX_META_BYTES + 1);
+            let total = 0;
+            let end = -1;
+            while (total < buffer.length && end < 0) {
+                const { bytesRead } = await handle.read(buffer, total, buffer.length - total, total);
+                if (bytesRead === 0)
+                    break;
+                end = buffer.subarray(total, total + bytesRead).indexOf(0x0a);
+                if (end >= 0)
+                    end += total;
+                total += bytesRead;
+            }
+            if (end < 0 || end > MAX_CODEX_META_BYTES)
+                return false;
+            bytes = buffer.subarray(0, end);
+        }
+        finally {
+            await handle.close();
+        }
+        const record = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+        const payload = record.payload;
+        return record.type === 'session_meta' && !!payload
+            && payload.originator === 'codex_sdk_ts'
+            && (payload.source === 'exec' || payload.source === 'vscode')
+            && SUPPORTED_CODEX_VERSIONS.has(String(payload.cli_version))
+            && payload.session_id === sessionId && typeof payload.cwd === 'string'
+            && await realpath(payload.cwd) === worktree;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/conductor-settings.js

@@ -0,0 +1,178 @@
+/**
+ * Read and edit the `[scripts] setup` / `archive` entries of a Conductor
+ * settings file, keeping every other line as written. Only the plain forms are
+ * handled: a plainly written `[scripts]` table with single-line string values.
+ * Anything else (dotted keys, inline tables, a quoted `["scripts"]` header or key, a
+ * multi-line string anywhere in the file) is refused, so a file is never
+ * rewritten on a guess.
+ */
+export const SCRIPT_KINDS = ['setup', 'archive'];
+export class SettingsError extends Error {
+}
+const HEADER = /^\s*\[\s*([^\[\]]+?)\s*\]\s*(?:#.*)?$/;
+const ARRAY_HEADER = /^\s*\[\[/;
+const KEY = /^\s*(setup|archive)\s*=\s*(.*)$/;
+function unsupported(path, line, why) {
+    return new SettingsError(`${path}:${line} ${why}; Slipstream edits only a [scripts] table with single-line string values. `
+        + 'Nothing was changed.');
+}
+function parseValue(raw, path, line) {
+    const text = raw.trim();
+    let value;
+    let rest;
+    if (text.startsWith('"')) {
+        let end = 1;
+        while (end < text.length && text[end] !== '"')
+            end += text[end] === '\\' ? 2 : 1;
+        if (end >= text.length)
+            throw unsupported(path, line, 'has an unterminated string');
+        try {
+            value = JSON.parse(text.slice(0, end + 1));
+        }
+        catch {
+            throw unsupported(path, line, 'has a string escape Slipstream does not read');
+        }
+        rest = text.slice(end + 1);
+    }
+    else if (text.startsWith("'")) {
+        const end = text.indexOf("'", 1);
+        if (end < 0)
+            throw unsupported(path, line, 'has an unterminated string');
+        value = text.slice(1, end);
+        rest = text.slice(end + 1);
+    }
+    else {
+        throw unsupported(path, line, 'sets a script to something other than a string');
+    }
+    if (rest.trim() !== '' && !rest.trim().startsWith('#'))
+        throw unsupported(path, line, 'has text after the string');
+    return value;
+}
+function usesMultilineString(line) {
+    let quote;
+    for (let i = 0; i < line.length; i++) {
+        const char = line[i];
+        if (!quote) {
+            if (char === '#')
+                return false;
+            if ((char === '"' || char === "'") && line.slice(i, i + 3) === char.repeat(3))
+                return true;
+            if (char === '"' || char === "'")
+                quote = char;
+            continue;
+        }
+        if (quote === '"' && char === '\\') {
+            i += 1;
+            continue;
+        }
+        if (char === quote)
+            quote = undefined;
+    }
+    return false;
+}
+/** Whether a line's leading quoted key could name `scripts`. A key whose
+ * escapes don't decode is assumed to, so it is refused rather than guessed. */
+function mayQuoteScripts(line) {
+    const key = /^\s*("(?:[^"\\]|\\.)*"|'[^']*')/.exec(line)?.[1];
+    if (key === undefined)
+        return true;
+    if (key.startsWith("'"))
+        return key.slice(1, -1) === 'scripts';
+    try {
+        return JSON.parse(key) === 'scripts';
+    }
+    catch {
+        return true;
+    }
+}
+function locate(text, path) {
+    const lines = text.split('\n');
+    const scripts = {};
+    const at = {};
+    let table = '';
+    let found;
+    for (const [i, line] of lines.entries()) {
+        if (usesMultilineString(line))
+            throw unsupported(path, i + 1, 'uses a multi-line string');
+        if (ARRAY_HEADER.test(line)) {
+            table = null;
+            continue;
+        }
+        const header = HEADER.exec(line);
+        if (header) {
+            table = header[1];
+            if (/^["']/.test(table))
+                throw unsupported(path, i + 1, 'quotes a table name');
+            if (table === 'scripts') {
+                if (found !== undefined)
+                    throw unsupported(path, i + 1, 'repeats the [scripts] table');
+                found = i;
+            }
+            continue;
+        }
+        if (table === '' && /^\s*["']/.test(line) && mayQuoteScripts(line)) {
+            throw unsupported(path, i + 1, 'quotes a top-level scripts key');
+        }
+        if (table === '' && /^\s*scripts\s*[.=]/.test(line))
+            throw unsupported(path, i + 1, 'sets scripts outside a [scripts] table');
+        if (table !== 'scripts')
+            continue;
+        if (/^\s*["']/.test(line))
+            throw unsupported(path, i + 1, 'quotes a script key');
+        const key = KEY.exec(line);
+        if (!key)
+            continue;
+        const kind = key[1];
+        scripts[kind] = parseValue(key[2], path, i + 1);
+        at[kind] = i;
+    }
+    return { scripts, lines, header: found, at };
+}
+export function readTomlScripts(text, path) {
+    return locate(text, path).scripts;
+}
+/** `text` with these scripts set, every other line kept. */
+export function writeTomlScripts(text, scripts, path) {
+    const { lines, header, at } = locate(text, path);
+    const entries = SCRIPT_KINDS.filter((k) => scripts[k] !== undefined).map((k) => [k, `${k} = ${JSON.stringify(scripts[k])}`]);
+    const missing = [];
+    for (const [kind, line] of entries) {
+        if (at[kind] !== undefined)
+            lines[at[kind]] = line;
+        else
+            missing.push(line);
+    }
+    if (missing.length === 0)
+        return lines.join('\n');
+    if (header !== undefined) {
+        lines.splice(header + 1, 0, ...missing);
+        return lines.join('\n');
+    }
+    const body = lines.join('\n');
+    const sep = body === '' ? '' : body.endsWith('\n\n') ? '' : body.endsWith('\n') ? '\n' : '\n\n';
+    return `${body}${sep}[scripts]\n${missing.join('\n')}\n`;
+}
+/** `text` with generated script entries removed, retaining all other text. */
+export function removeTomlScripts(text, kinds, path) {
+    const { lines, at } = locate(text, path);
+    const remove = kinds.map((kind) => at[kind]).filter((line) => line !== undefined).sort((a, b) => b - a);
+    for (const line of remove)
+        lines.splice(line, 1);
+    return lines.join('\n');
+}
+/** The scripts of a legacy `conductor.json`. */
+export function readLegacyScripts(text, path) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new SettingsError(`${path} is not valid JSON. Nothing was changed.`);
+    }
+    const scripts = parsed?.scripts;
+    const out = {};
+    for (const kind of SCRIPT_KINDS)
+        if (typeof scripts?.[kind] === 'string')
+            out[kind] = scripts[kind];
+    return out;
+}

package/dist/conductor.js

@@ -0,0 +1,313 @@
+/**
+ * Conductor integration: `slipstream conductor install | setup | archive | enroll`.
+ *
+ * Install chains `slipstream conductor setup` / `archive` into the personal
+ * Conductor scripts (`~/.conductor/settings.toml`) and, for a repo that defines
+ * its own scripts and so overrides the personal ones, into that repo's
+ * `.conductor/settings.local.toml`, ahead of the repo's own command. Conductor
+ * runs setup after it creates a workspace and archive before it archives one,
+ * but it was observed (README, "Capture every Conductor workspace") starting the
+ * agent without waiting for setup to finish, so capture can begin after an
+ * agent's first edits. The first baseline is then the first state observed,
+ * never a claim of the original one.
+ */
+import { mkdir, readFile, rename, stat, unlink, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { shellWord } from "./attach-workflow.js";
+import { SCRIPT_KINDS, SettingsError, readLegacyScripts, readTomlScripts, removeTomlScripts, writeTomlScripts, } from "./conductor-settings.js";
+import { InstallError, entryPaths, installLaunchAgent, readManagedInstall, writeManagedInstall, } from "./launch-agent.js";
+export function slipstreamCommand(kind, p) {
+    return [p.node, p.cli, 'conductor', kind, '--store', p.store].map(shellWord).join(' ');
+}
+/** Slipstream first, then the repo's own command whatever Slipstream returned, so
+ * Slipstream never stops a workspace being set up or archived. The script fails
+ * with the repo's code if its command fails, otherwise with Slipstream's. The
+ * subshell keeps an `exit` in the repo's command from skipping that. */
+export function chainScript(ours, own) {
+    if (own === null || own.trim() === '')
+        return ours;
+    return `slipstream_status=0\n${ours} || slipstream_status=$?\n(\n${own}\n) || exit $?\nexit $slipstream_status`;
+}
+const WORD = String.raw `(?:[\w@%+=:,./-]+|'[^']*'(?:\\''[^']*')*)`;
+const OURS = String.raw `${WORD} ${WORD} conductor (?:setup|archive) --store ${WORD}`;
+const CHAINED = new RegExp(String.raw `^(?:${OURS}|slipstream_status=0\n${OURS} \|\| slipstream_status=\$\?\n\(\n([\s\S]*)\n\) \|\| exit \$\?\nexit \$slipstream_status)$`);
+/** The command a Slipstream chain runs after its own, or undefined when `value`
+ * is not a Slipstream chain. */
+export function chainedOwn(value) {
+    const m = CHAINED.exec(value);
+    return m ? { own: m[1] ?? null } : undefined;
+}
+async function readText(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return null;
+        throw err;
+    }
+}
+async function writeAtomic(path, text) {
+    await mkdir(dirname(path), { recursive: true });
+    const tmp = `${path}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(tmp, text, { flag: 'wx' });
+        await rename(tmp, path);
+    }
+    catch (err) {
+        await unlink(tmp).catch(() => { });
+        throw err;
+    }
+}
+export function localSettingsPath(root) {
+    return join(root, '.conductor', 'settings.local.toml');
+}
+/** A repo's shared scripts: `settings.toml`, then legacy `conductor.json`, per key. */
+export async function sharedScripts(root) {
+    const tomlPath = join(root, '.conductor', 'settings.toml');
+    const jsonPath = join(root, 'conductor.json');
+    const toml = await readText(tomlPath);
+    const json = await readText(jsonPath);
+    return { ...(json === null ? {} : readLegacyScripts(json, jsonPath)), ...(toml === null ? {} : readTomlScripts(toml, tomlPath)) };
+}
+/** Where the shared scripts no longer match what the install chained. */
+export function driftOf(recorded, shared) {
+    return SCRIPT_KINDS.filter((k) => (shared[k] ?? null) !== recorded[k]);
+}
+export async function runConductorInstall(deps) {
+    try {
+        return await install(deps);
+    }
+    catch (err) {
+        if (!(err instanceof InstallError) && !(err instanceof SettingsError) && !(err instanceof InventoryError))
+            throw err;
+        deps.err(`slipstream: ${err.message}`);
+        return 1;
+    }
+}
+async function install(deps) {
+    const paths = await entryPaths(deps.execPath, deps.nodeVersion, deps.cliPath);
+    const ours = (kind) => slipstreamCommand(kind, { ...paths, store: deps.store });
+    const prior = await readManagedInstall(deps.store);
+    const writes = [];
+    const notes = [];
+    // Plan every edit before writing any, so a settings file Slipstream cannot
+    // read leaves the machine as it was.
+    const personalPath = join(deps.home, '.conductor', 'settings.toml');
+    const personalText = (await readText(personalPath)) ?? '';
+    const personal = readTomlScripts(personalText, personalPath);
+    const personalNext = {};
+    for (const kind of SCRIPT_KINDS) {
+        const current = personal[kind];
+        const chain = current === undefined ? undefined : chainedOwn(current);
+        const own = chain ? chain.own : current ?? null;
+        personalNext[kind] = chainScript(ours(kind), own);
+    }
+    const personalOut = writeTomlScripts(personalText, personalNext, personalPath);
+    if (personalOut !== personalText)
+        writes.push({ path: personalPath, text: personalOut });
+    const managedPath = join(deps.home, '.conductor', 'settings.managed.toml');
+    const managedText = await readText(managedPath);
+    if (managedText !== null && Object.keys(readTomlScripts(managedText, managedPath)).length > 0) {
+        notes.push(`warning: ${managedPath} sets Conductor scripts, which override Slipstream's on this machine; `
+            + 'workspaces will not be captured until those scripts run `slipstream conductor setup`.');
+    }
+    const repos = [];
+    const chained = [];
+    for (const root of [...new Set(await deps.listRepos())].sort()) {
+        if (!(await stat(root).catch(() => null))?.isDirectory()) {
+            notes.push(`skipped ${root}: Conductor lists it, but it is not a directory here.`);
+            continue;
+        }
+        const shared = await sharedScripts(root);
+        const localPath = localSettingsPath(root);
+        const localText = await readText(localPath);
+        const local = localText === null ? {} : readTomlScripts(localText, localPath);
+        const before = prior?.repos.find((r) => r.root === root);
+        const next = {};
+        const remove = [];
+        for (const kind of SCRIPT_KINDS) {
+            const value = local[kind];
+            const ourChain = value === undefined ? undefined : chainedOwn(value);
+            let own;
+            if (ourChain) {
+                // Follow a shared script that changed since the last install, unless the
+                // chained command was edited by hand.
+                if (before && ourChain.own === before[kind] && shared[kind] === undefined) {
+                    remove.push(kind);
+                    continue;
+                }
+                own = before && ourChain.own === before[kind] ? shared[kind] ?? null : ourChain.own;
+            }
+            else if (value !== undefined)
+                own = value;
+            else if (shared[kind] !== undefined)
+                own = shared[kind];
+            else
+                continue;
+            next[kind] = chainScript(ours(kind), own);
+        }
+        if (Object.keys(next).length === 0 && remove.length === 0)
+            continue;
+        let out = localText ?? '';
+        if (remove.length > 0)
+            out = removeTomlScripts(out, remove, localPath);
+        if (Object.keys(next).length > 0)
+            out = writeTomlScripts(out, next, localPath);
+        if (out !== localText)
+            writes.push({ path: localPath, text: out });
+        repos.push({ root, setup: shared.setup ?? null, archive: shared.archive ?? null });
+        chained.push(localPath);
+        const ignored = await deps.run('git', ['-C', root, 'check-ignore', '-q', join('.conductor', 'settings.local.toml')]);
+        if (ignored.code === 1) {
+            notes.push(`warning: ${localPath} is not ignored by git. It holds paths for this machine only; do not commit it.`);
+        }
+    }
+    const upgraded = prior !== null && (prior.package_version !== deps.packageVersion || prior.node !== paths.node);
+    const agent = await installLaunchAgent({ ...paths, home: deps.home, store: deps.store, uid: deps.uid, restart: upgraded }, deps.run);
+    for (const w of writes)
+        await writeAtomic(w.path, w.text);
+    await writeManagedInstall(deps.store, { version: 1, package_version: deps.packageVersion, ...paths, log: agent.log, repos });
+    deps.out(`LaunchAgent: ${agent.plist}${agent.reloaded ? ' (loaded; the daemon was started on these paths)' : ' (unchanged)'}`);
+    deps.out(`Daemon log: ${agent.log}`);
+    deps.out(`Node: ${paths.node}`);
+    deps.out(`Slipstream: ${paths.cli} (${deps.packageVersion})`);
+    deps.out(`Personal Conductor scripts: ${personalPath}`);
+    for (const path of chained)
+        deps.out(`Repo override: ${path}`);
+    for (const note of notes)
+        deps.out(note);
+    deps.out('Conductor runs setup after it creates a workspace but does not wait for it to finish before starting '
+        + 'the agent, so a capture may begin after the agent\'s first edits; Slipstream then records the first state it '
+        + 'sees as the baseline.');
+    deps.out('Run `slipstream conductor enroll` to capture workspaces that already exist. '
+        + 'Run this install again after upgrading Node or Slipstream.');
+    return 0;
+}
+export async function runConductorSetup(deps) {
+    const dir = deps.env.CONDUCTOR_WORKSPACE_PATH;
+    if (!dir) {
+        deps.err('slipstream: CONDUCTOR_WORKSPACE_PATH is not set; `slipstream conductor setup` runs as a Conductor setup script.');
+        return 2;
+    }
+    await warnOfDrift(deps);
+    try {
+        await deps.ensureDaemon();
+    }
+    catch (err) {
+        deps.err(`slipstream: ${err.message}`);
+        deps.err(`slipstream: ${dir} is NOT recording.`);
+        return 1;
+    }
+    return deps.attach(dir);
+}
+async function warnOfDrift(deps) {
+    let install;
+    try {
+        install = await readManagedInstall(deps.store);
+    }
+    catch (err) {
+        deps.err(`slipstream: warning: ${err.message}`);
+        return;
+    }
+    if (!install)
+        return;
+    if (install.package_version !== deps.packageVersion) {
+        deps.err(`slipstream: warning: the install was recorded by Slipstream ${install.package_version}, but this is `
+            + `${deps.packageVersion}. Run \`slipstream conductor install\` to refresh the daemon and scripts.`);
+    }
+    const root = deps.env.CONDUCTOR_ROOT_PATH;
+    const recorded = root ? install.repos.find((r) => r.root === root) : undefined;
+    if (!recorded)
+        return;
+    let shared;
+    try {
+        shared = await sharedScripts(recorded.root);
+    }
+    catch (err) {
+        deps.err(`slipstream: warning: ${err.message}`);
+        return;
+    }
+    for (const kind of driftOf(recorded, shared)) {
+        deps.err(`slipstream: warning: this repo's own ${kind} script changed since \`slipstream conductor install\` chained it; `
+            + `${localSettingsPath(recorded.root)} still runs the old one. Run \`slipstream conductor install\` to update it.`);
+    }
+}
+export async function runConductorArchive(deps) {
+    const dir = deps.env.CONDUCTOR_WORKSPACE_PATH;
+    if (!dir) {
+        deps.err('slipstream: CONDUCTOR_WORKSPACE_PATH is not set; `slipstream conductor archive` runs as a Conductor archive script.');
+        return 2;
+    }
+    return deps.withdraw(dir);
+}
+export class InventoryError extends Error {
+}
+/** Conductor's own record of its workspaces and repos, opened read-only. Its
+ * columns are checked, not assumed: a schema this does not recognize fails. */
+export async function readConductorInventory(dbPath) {
+    if (!(await stat(dbPath).catch(() => null))?.isFile())
+        throw new InventoryError(`Conductor's database ${dbPath} was not found`);
+    const { DatabaseSync } = await import('node:sqlite');
+    const db = new DatabaseSync(dbPath, { readOnly: true });
+    try {
+        const columns = (table) => new Set(db.prepare(`PRAGMA table_info(${table})`).all().map((r) => String(r.name)));
+        const ws = columns('workspaces');
+        const repos = columns('repos');
+        const missing = [...['state', 'workspace_path'].filter((c) => !ws.has(c)).map((c) => `workspaces.${c}`),
+            ...(repos.has('root_path') ? [] : ['repos.root_path'])];
+        if (missing.length > 0) {
+            throw new InventoryError(`Conductor's database ${dbPath} has no ${missing.join(', ')}; this Conductor version is not one `
+                + 'Slipstream can read. Nothing was enrolled.');
+        }
+        const byActivity = ws.has('last_activity_at');
+        const order = byActivity ? 'last_activity_at IS NULL, last_activity_at DESC, rowid' : 'rowid';
+        const workspaces = db.prepare(`SELECT workspace_path FROM workspaces WHERE state != 'archived' AND workspace_path IS NOT NULL `
+            + `AND workspace_path != '' ORDER BY ${order}`).all().map((r) => String(r.workspace_path));
+        const roots = db.prepare(`SELECT root_path FROM repos WHERE root_path IS NOT NULL AND root_path != ''`).all()
+            .map((r) => String(r.root_path));
+        return { workspaces, byActivity, repos: roots };
+    }
+    finally {
+        db.close();
+    }
+}
+/** Ask for a watch-only capture of every workspace, in order. A workspace that
+ * already has one keeps it. */
+export async function runConductorEnroll(inventory, deps) {
+    try {
+        await deps.ensureDaemon();
+    }
+    catch (err) {
+        deps.err(`slipstream: ${err.message}`);
+        return 1;
+    }
+    deps.out(`Enrolling ${inventory.workspaces.length} Conductor workspace(s), ${inventory.byActivity
+        ? 'most recently active first (Conductor\'s last activity time)'
+        : 'in Conductor\'s inventory order (it records no activity time)'}.`);
+    let recording = 0;
+    let starting = 0;
+    let failed = 0;
+    for (const dir of inventory.workspaces) {
+        const res = await deps.control({ verb: 'attach', mode: 'watch-only', worktree: dir });
+        if (!res.ok) {
+            failed++;
+            deps.err(`slipstream: ${dir}: NOT recording (${res.code}: ${res.message})`);
+        }
+        else if (res.state === 'recording') {
+            recording++;
+            deps.out(`${dir}: recording`);
+        }
+        else if (res.state === 'queued' || res.state === 'baselining') {
+            starting++;
+            deps.out(`${dir}: starting (${String(res.state)})`);
+        }
+        else {
+            failed++;
+            deps.err(`slipstream: ${dir}: NOT recording (${String(res.reason ?? res.state)}${res.message ? `: ${String(res.message)}` : ''})`);
+        }
+    }
+    deps.out(`${recording} recording, ${starting} starting, ${failed} not recording.`);
+    return failed > 0 ? 1 : 0;
+}

package/dist/control-protocol.js

@@ -1,7 +1,8 @@
 /**
  * The Slipstream daemon control protocol: newline-delimited JSON over an
  * owner-only `node:net` unix socket. This is a PRIVATE CONTROL channel — its
- * verbs (attach / detach / status / begin_task / delete_session / gc) WRITE
+ * verbs (attach / detach / unlink / status / begin_task / ask / record_question_exchange /
+ * record_question_relay_update / claim_question / answer_question / delete_session / gc) WRITE
  * public events or maintain the store and never read or serve the feed. Readers
  * keep serving the public HTTP/disk view; there is no privileged back channel
  * for reading.