presubmit 0.1.0

package/dist/apps/server/src/dev-server.js

@@ -0,0 +1,201 @@
+import { fork } from 'node:child_process';
+import { request } from 'node:http';
+import { connect } from 'node:net';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** Private streaming proxy; frontend crashes never restart the authoritative session host. */
+export async function startDevServer(root, tailscaleOrigin) {
+    const directory = await mkdtemp(join(tmpdir(), 'ps-vite-'));
+    const socketPath = join(directory, 'http.sock');
+    const worker = new URL(import.meta.url.endsWith('.ts') ? './dev-worker.ts' : './dev-worker.js', import.meta.url);
+    let child;
+    let ready = false;
+    let closed = false;
+    let retry;
+    let failures = 0;
+    let exited = Promise.resolve();
+    const connections = new Set();
+    const track = (socket) => {
+        // The HTTP agent reuses sockets across requests; install cleanup only once.
+        if (connections.has(socket))
+            return socket;
+        connections.add(socket);
+        socket.once('close', () => connections.delete(socket));
+        return socket;
+    };
+    async function launch() {
+        await rm(socketPath, { force: true });
+        if (closed)
+            return;
+        // Do not inherit provider credentials or the application's account/data configuration.
+        const env = {};
+        for (const key of [
+            'PATH',
+            'TMPDIR',
+            'TMP',
+            'TEMP',
+            'SystemRoot',
+            'NODE_ENV',
+            'FORCE_COLOR',
+            'PRESUBMIT_DIAGNOSTICS',
+        ])
+            if (process.env[key] !== undefined)
+                env[key] = process.env[key];
+        const current = fork(fileURLToPath(worker), [root, socketPath, tailscaleOrigin ?? ''], {
+            env,
+            execArgv: worker.pathname.endsWith('.ts') ? ['--import', import.meta.resolve('tsx')] : [],
+            stdio: ['ignore', 'inherit', 'inherit', 'ipc'],
+        });
+        child = current;
+        exited = new Promise((resolve) => {
+            current.once('exit', () => resolve());
+            current.once('error', () => {
+                if (!current.pid)
+                    resolve();
+            });
+        });
+        await new Promise((resolve, reject) => {
+            let started = false;
+            const timeout = setTimeout(() => {
+                reject(new Error('Frontend worker startup timed out'));
+                current.kill('SIGKILL');
+            }, 30_000);
+            current.on('message', (message) => {
+                if (message?.type !== 'ready' || closed || started)
+                    return;
+                started = true;
+                ready = true;
+                clearTimeout(timeout);
+                resolve();
+            });
+            current.once('error', (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+            current.once('exit', () => {
+                clearTimeout(timeout);
+                ready = false;
+                for (const connection of connections)
+                    connection.destroy();
+                if (!started)
+                    reject(new Error('Frontend worker exited before becoming ready'));
+                if (!closed && started)
+                    scheduleRestart();
+            });
+        }).catch(async (error) => {
+            current.kill('SIGKILL');
+            await exited;
+            throw error;
+        });
+    }
+    function scheduleRestart() {
+        if (closed)
+            return;
+        const wait = Math.min(30_000, 1000 * 2 ** Math.min(failures++, 5));
+        console.error(`Frontend worker stopped. Retrying in ${wait / 1000}s; agent sessions remain active.`);
+        retry = setTimeout(() => {
+            void launch().catch(() => scheduleRestart());
+        }, wait);
+    }
+    function headers(req) {
+        const { cookie: _cookie, authorization: _authorization, ...rest } = req.headers;
+        // The public server has already checked authentication and exact Host/Origin.
+        // Vite uses a private socket; normalize its transport host so enabling a remote
+        // origin at runtime needs no frontend or authoritative host restart.
+        return { ...rest, host: '127.0.0.1' };
+    }
+    function assetPath(req) {
+        const url = new URL(req.url ?? '/', 'http://127.0.0.1');
+        // Browser location keeps the bootstrap token; transforms never need to receive it.
+        url.searchParams.delete('token');
+        return url.pathname + url.search;
+    }
+    let closing;
+    function close() {
+        return (closing ??= (async () => {
+            closed = true;
+            ready = false;
+            clearTimeout(retry);
+            for (const connection of connections)
+                connection.destroy();
+            const current = child;
+            const kill = setTimeout(() => current?.kill('SIGKILL'), 3000);
+            current?.kill('SIGTERM');
+            await exited;
+            clearTimeout(kill);
+            await rm(directory, { recursive: true, force: true });
+        })());
+    }
+    try {
+        await launch();
+    }
+    catch (error) {
+        await close();
+        throw error;
+    }
+    return {
+        close,
+        // Used by diagnostics and lifecycle tests; not exposed over HTTP.
+        get pid() {
+            return child?.pid;
+        },
+        request(req, res) {
+            if (!ready) {
+                res.writeHead(503, {
+                    'Content-Type': 'text/plain',
+                    'Retry-After': '1',
+                    'Cache-Control': 'no-store',
+                });
+                res.end('Frontend is restarting. Agent sessions are still running. Reload shortly.');
+                return;
+            }
+            const upstream = request({ socketPath, path: assetPath(req), method: req.method, headers: headers(req) }, (response) => {
+                res.writeHead(response.statusCode ?? 502, {
+                    ...response.headers,
+                    'cache-control': 'no-store',
+                    'referrer-policy': 'no-referrer',
+                });
+                response.on('error', () => res.destroy());
+                response.pipe(res);
+            });
+            upstream.on('socket', track);
+            upstream.on('error', () => {
+                if (res.headersSent)
+                    res.destroy();
+                else {
+                    res.writeHead(503, { 'Cache-Control': 'no-store' });
+                    res.end('Frontend unavailable. Reload shortly.');
+                }
+            });
+            req.once('aborted', () => upstream.destroy());
+            res.once('close', () => upstream.destroy());
+            req.pipe(upstream);
+        },
+        upgrade(req, socket, head) {
+            if (!ready) {
+                socket.end('HTTP/1.1 503 Service Unavailable\r\nConnection: close\r\n\r\n');
+                return;
+            }
+            const upstream = track(connect(socketPath));
+            track(socket);
+            upstream.on('error', () => socket.destroy());
+            socket.on('error', () => upstream.destroy());
+            upstream.once('close', () => socket.destroy());
+            socket.once('close', () => upstream.destroy());
+            upstream.once('connect', () => {
+                upstream.write(`${req.method} ${req.url} HTTP/${req.httpVersion}\r\n`);
+                for (const [key, value] of Object.entries(headers(req))) {
+                    for (const item of Array.isArray(value) ? value : [value])
+                        if (item !== undefined)
+                            upstream.write(`${key}: ${item}\r\n`);
+                }
+                upstream.write('\r\n');
+                if (head.length)
+                    upstream.write(head);
+                socket.pipe(upstream).pipe(socket);
+            });
+        },
+    };
+}

package/dist/apps/server/src/dev-worker.js

@@ -0,0 +1,48 @@
+import { createServer } from 'node:http';
+import { createServer as createViteServer } from 'vite';
+import { recordHttp, startDiagnostics } from './diagnostics.js';
+// This process owns frontend transforms only. No application stores or agent SDK are loaded.
+const [root, socketPath, tailscaleOrigin] = process.argv.slice(2);
+if (!root || !socketPath || !process.send)
+    throw new Error('Missing dev worker options');
+// If the host crashes, this frontend has no owner and must exit even during startup.
+process.once('disconnect', () => process.exit(0));
+const stopDiagnostics = startDiagnostics('vite');
+const server = createServer((req, res) => {
+    recordHttp(req, res, true);
+    vite.middlewares(req, res, () => {
+        res.writeHead(404);
+        res.end('Not found');
+    });
+});
+const vite = await createViteServer({
+    configFile: false,
+    root,
+    appType: 'spa',
+    server: {
+        middlewareMode: true,
+        allowedHosts: tailscaleOrigin ? [new URL(tailscaleOrigin).hostname] : [],
+        // Let the browser select its own port and ws/wss protocol behind Serve as well as locally.
+        hmr: { server, path: '/__vite_hmr' },
+    },
+});
+let stopping = false;
+async function stop() {
+    if (stopping)
+        return;
+    stopping = true;
+    stopDiagnostics();
+    await vite.close();
+    server.closeAllConnections();
+    server.close(() => process.exit(0));
+}
+for (const signal of ['SIGTERM', 'SIGINT'])
+    process.once(signal, () => void stop());
+await new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(socketPath, resolve);
+});
+if (!process.connected)
+    await stop();
+else
+    process.send({ type: 'ready' });

package/dist/apps/server/src/diagnostics.js

@@ -0,0 +1,105 @@
+import { PerformanceMetrics } from '../../../packages/protocol/src/metrics.js';
+import { monitorEventLoopDelay, performance } from 'node:perf_hooks';
+import { getHeapStatistics } from 'node:v8';
+export const diagnosticsEnabled = process.env.PRESUBMIT_DIAGNOSTICS === '1';
+export const performanceMetrics = new PerformanceMetrics();
+export const diagnosticGauges = new Map();
+const collectionStarted = performance.now();
+const initialCpu = process.cpuUsage();
+const initialLoop = performance.eventLoopUtilization();
+export function timed(name, operation) {
+    if (!diagnosticsEnabled)
+        return operation();
+    const start = performance.now();
+    try {
+        return operation();
+    }
+    finally {
+        performanceMetrics.observe(name, performance.now() - start);
+    }
+}
+export function recordHttp(req, res, internal) {
+    if (!diagnosticsEnabled)
+        return;
+    const start = performance.now();
+    const kind = req.url?.startsWith('/api/') ? 'api' : 'assets';
+    const scope = internal ? 'internal' : 'public';
+    res.once('close', () => {
+        performanceMetrics.observe(`http.${scope}.${kind}`, performance.now() - start);
+        if (!res.writableFinished)
+            performanceMetrics.count('http.aborted');
+        else if (res.statusCode >= 400)
+            performanceMetrics.count('http.errors');
+    });
+}
+/** Opt-in process metrics only: no prompts, paths, credentials, or heap contents. */
+export function startDiagnostics(role) {
+    if (process.env.PRESUBMIT_DIAGNOSTICS !== '1')
+        return () => { };
+    const delay = monitorEventLoopDelay({ resolution: 20 });
+    delay.enable();
+    let lastTime = collectionStarted;
+    let lastCpu = initialCpu;
+    let lastLoop = initialLoop;
+    const report = () => {
+        const now = performance.now();
+        const intervalMs = now - lastTime;
+        const cpu = process.cpuUsage();
+        const loop = performance.eventLoopUtilization();
+        const utilization = performance.eventLoopUtilization(loop, lastLoop);
+        const memory = process.memoryUsage();
+        const mib = (value) => Math.round(value / 1024 / 1024);
+        const report = {
+            role,
+            intervalMs: Math.round(intervalMs),
+            cpuPercent: intervalMs > 0
+                ? Math.round((cpu.user - lastCpu.user + cpu.system - lastCpu.system) / (intervalMs * 10))
+                : 0,
+            eventLoopUtilization: Math.round(utilization.utilization * 1000) / 1000,
+            ...performanceMetrics.drain(),
+            gauges: Object.fromEntries(diagnosticGauges),
+            pid: process.pid,
+            rssMiB: mib(memory.rss),
+            heapUsedMiB: mib(memory.heapUsed),
+            heapLimitMiB: mib(getHeapStatistics().heap_size_limit),
+            externalMiB: mib(memory.external),
+            eventLoopP99Ms: Math.round(delay.percentile(99) / 1e6),
+            eventLoopMaxMs: Math.round(delay.max / 1e6),
+        };
+        if (process.env.PRESUBMIT_DIAGNOSTICS_FORMAT === 'json')
+            console.error('[presubmit metrics]', JSON.stringify(report));
+        else
+            console.error(formatDiagnostics(report));
+        lastTime = now;
+        lastCpu = cpu;
+        lastLoop = loop;
+        delay.reset();
+    };
+    report();
+    const timer = setInterval(report, 30_000);
+    timer.unref();
+    return () => {
+        clearInterval(timer);
+        delay.disable();
+    };
+}
+export function formatDiagnostics(r) {
+    const memory = (mib) => (mib >= 1024 ? `${(mib / 1024).toFixed(2)} GiB` : `${mib} MiB`);
+    const duration = (ms) => ms >= 1000 ? `${(ms / 1000).toFixed(2)} s` : `${ms.toFixed(2)} ms`;
+    const lines = [
+        `[presubmit metrics] ${r.role} · PID ${r.pid} · last ${(r.intervalMs / 1000).toFixed(1)} s`,
+        `  CPU ${r.cpuPercent}% (${(r.cpuPercent / 100).toFixed(2)} cores) · event loop ${(r.eventLoopUtilization * 100).toFixed(1)}% busy`,
+        `  Memory: RSS ${memory(r.rssMiB)} · JS heap ${memory(r.heapUsedMiB)} / ${memory(r.heapLimitMiB)} limit · external ${memory(r.externalMiB)}`,
+        `  Event-loop delay: p99 ${r.eventLoopP99Ms} ms · max ${r.eventLoopMaxMs} ms`,
+    ];
+    if (r.gauges['workspace.watchers'] !== undefined)
+        lines.push(`  File watching: ${r.gauges['workspace.watchers']} shared watchers · ${r.gauges['workspace.subscribers']} session subscribers · ${r.counters['workspace.fileEvents'] ?? 0} events · ${r.counters['workspace.changeBatches'] ?? 0} batches`);
+    if (r.counters['ws.messages'] !== undefined || r.counters['ws.bytes'] !== undefined)
+        lines.push(`  WebSocket: ${r.counters['ws.messages'] ?? 0} messages · ${((r.counters['ws.bytes'] ?? 0) / 1024 / 1024).toFixed(2)} MiB enqueued (includes internal relays)`);
+    for (const [name, value] of Object.entries(r.timings).sort(([a], [b]) => a.localeCompare(b)))
+        lines.push(`  ${name}: ${value.count} calls · avg ${duration(value.meanMs)} · p95 ≤ ${duration(value.p95UpperMs)} · max ${duration(value.maxMs)} · total ${duration(value.totalMs)}`);
+    for (const [name, count] of Object.entries(r.counters))
+        if (!['ws.messages', 'ws.bytes', 'workspace.fileEvents', 'workspace.changeBatches'].includes(name))
+            lines.push(`  ${name}: ${count}`);
+    return lines.join('\n');
+}

package/dist/apps/server/src/fast-mode.js

@@ -0,0 +1,8 @@
+/** Catalog capabilities are server-owned; clients cannot opt unsupported models into paid tiers. */
+export function parseFastMode(value, model) {
+    if (value !== undefined && typeof value !== 'boolean')
+        throw new Error('Fast mode must be a boolean.');
+    if (value === true && model?.supportsFastMode !== true)
+        throw new Error('Fast mode is unavailable for the selected model.');
+    return value;
+}

package/dist/apps/server/src/folder-picker.js

@@ -0,0 +1,54 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const exec = promisify(execFile);
+export async function pickProjectFolder(platform = process.platform, run = (file, args) => exec(file, args, { maxBuffer: 64 * 1024 })) {
+    try {
+        let stdout;
+        if (platform === 'darwin') {
+            ({ stdout } = await run('osascript', [
+                '-e',
+                'try\nactivate\nreturn POSIX path of (choose folder with prompt "Choose a project folder")\non error number -128\nreturn ""\nend try',
+            ]));
+        }
+        else if (platform === 'win32') {
+            ({ stdout } = await run('powershell.exe', [
+                '-NoProfile',
+                '-STA',
+                '-Command',
+                'Add-Type -AssemblyName System.Windows.Forms; $picker = New-Object System.Windows.Forms.FolderBrowserDialog; $picker.Description = "Choose a project folder"; $picker.ShowNewFolderButton = $false; try { if ($picker.ShowDialog() -eq "OK") { [Console]::OutputEncoding = [System.Text.Encoding]::UTF8; [Console]::WriteLine($picker.SelectedPath) } } finally { $picker.Dispose() }',
+            ]));
+        }
+        else if (platform === 'linux') {
+            try {
+                ({ stdout } = await run('zenity', [
+                    '--file-selection',
+                    '--directory',
+                    '--title=Choose a project folder',
+                ]));
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+                ({ stdout } = await run('kdialog', [
+                    '--getexistingdirectory',
+                    '.',
+                    '--title',
+                    'Choose a project folder',
+                ]));
+            }
+        }
+        else {
+            throw new Error('Folder picking is not supported on this operating system.');
+        }
+        // Remove the command's line ending without trimming valid spaces in folder names.
+        return stdout.replace(/\r?\n$/, '') || null;
+    }
+    catch (error) {
+        if (platform === 'linux' && error.code === 1)
+            return null;
+        throw new Error('Could not open the folder picker on this computer. ' +
+            (platform === 'linux'
+                ? 'A desktop session with Zenity or KDialog is required.'
+                : 'Please try again.'), { cause: error });
+    }
+}

package/dist/apps/server/src/git-blobs.js

@@ -0,0 +1,62 @@
+import { execFile } from 'node:child_process';
+/** Read immutable objects in bounded batches instead of spawning Git for every file. */
+export async function* readTreeBlobs(cwd, tree, maxFileBytes) {
+    const entries = tree
+        .split('\0')
+        .filter(Boolean)
+        .map((entry) => {
+        const match = /^(\d+) (\w+) ([a-f0-9]{40,64})\s+(\d+|-)\t([\s\S]+)$/.exec(entry);
+        if (!match)
+            throw new Error('Invalid Git tree entry');
+        const [, mode, type, object, size, name] = match;
+        return {
+            name: name,
+            object: object,
+            size: Number(size),
+            ...(type !== 'blob' || mode === '120000' || Number(size) > maxFileBytes
+                ? { excluded: 'non-text, symlink, or oversized' }
+                : {}),
+        };
+    });
+    let offset = 0;
+    while (offset < entries.length) {
+        const batch = [];
+        let size = 0;
+        while (offset < entries.length && batch.length < 128) {
+            const entry = entries[offset];
+            const bytes = entry.excluded ? 0 : entry.size;
+            if (batch.length && size + bytes > maxFileBytes)
+                break;
+            batch.push(entry);
+            size += bytes;
+            offset++;
+        }
+        const requested = batch.filter((entry) => !entry.excluded);
+        const output = requested.length
+            ? await new Promise((resolve, reject) => {
+                const child = execFile('git', ['cat-file', '--batch'], { cwd, encoding: 'buffer', maxBuffer: size + requested.length * 128 }, (error, stdout) => (error ? reject(error) : resolve(stdout)));
+                child.stdin.on('error', reject);
+                child.stdin.end(requested.map((entry) => entry.object + '\n').join(''));
+            })
+            : Buffer.alloc(0);
+        let cursor = 0;
+        for (const entry of batch) {
+            if (entry.excluded) {
+                yield { name: entry.name, excluded: entry.excluded };
+                continue;
+            }
+            const end = output.indexOf(10, cursor);
+            const header = output.subarray(cursor, end).toString('ascii');
+            if (end < cursor || header !== `${entry.object} blob ${entry.size}`)
+                throw new Error('Invalid Git blob response');
+            cursor = end + 1;
+            const content = output.subarray(cursor, cursor + entry.size);
+            cursor += entry.size;
+            if (content.length !== entry.size || output[cursor++] !== 10)
+                throw new Error('Incomplete Git blob response');
+            yield { name: entry.name, content };
+        }
+        if (cursor !== output.length)
+            throw new Error('Unexpected Git blob response');
+    }
+}

package/dist/apps/server/src/git-handoff.js

@@ -0,0 +1,127 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { access, realpath } from 'node:fs/promises';
+import { listSessionBranches, validateSessionWorkspace } from './session-workspaces.js';
+const execute = promisify(execFile);
+export const shellQuote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+async function git(cwd, ...args) {
+    const { stdout } = await execute('git', args, {
+        cwd,
+        encoding: 'utf8',
+        timeout: 15_000,
+        maxBuffer: 1024 * 1024,
+        env: { ...process.env, GIT_OPTIONAL_LOCKS: '0', GIT_TERMINAL_PROMPT: '0' },
+    });
+    return stdout.trim();
+}
+async function inspect(path) {
+    const [branch, commit, status, unmerged, gitDir] = await Promise.all([
+        git(path, 'rev-parse', '--abbrev-ref', 'HEAD'),
+        git(path, 'rev-parse', '--verify', 'HEAD^{commit}'),
+        git(path, 'status', '--porcelain=v1', '-z', '--untracked-files=all'),
+        git(path, 'ls-files', '--unmerged'),
+        git(path, 'rev-parse', '--absolute-git-dir'),
+    ]);
+    const operations = await Promise.all([
+        'MERGE_HEAD',
+        'CHERRY_PICK_HEAD',
+        'REVERT_HEAD',
+        'rebase-merge',
+        'rebase-apply',
+        'sequencer',
+    ].map(async (name) => {
+        try {
+            await access(`${gitDir}/${name}`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }));
+    return {
+        path,
+        branch: branch === 'HEAD' ? null : branch,
+        commit,
+        dirty: !!status,
+        conflict: !!unmerged || operations.some(Boolean),
+    };
+}
+/** Read-only snapshot. Never executes any suggested mutation or predicts conflict-free merging. */
+export async function inspectGitHandoff(repository, session, sessions, destination) {
+    const result = {
+        checkedAt: new Date().toISOString(),
+        branches: [],
+        blockers: [],
+        inspection: '',
+    };
+    if (!session.branch || session.workspace === repository) {
+        result.blockers.push('Guided Git handoff is only available for worktree sessions.');
+        return result;
+    }
+    try {
+        result.branches = (await listSessionBranches(repository)).branches;
+        await validateSessionWorkspace(repository, session.workspace, session.branch);
+        const source = await inspect(session.workspace);
+        result.source = source;
+        result.inspection = `git -C ${shellQuote(source.path)} status\ngit -C ${shellQuote(source.path)} log -5 --oneline`;
+        if (source.branch !== session.branch)
+            result.blockers.push('Source branch changed or HEAD is detached. Restore the session branch, then refresh; do not switch with unsaved work.');
+        if (source.dirty)
+            result.blockers.push('Source has uncommitted or untracked work. Review and commit intended changes yourself, then refresh. Only committed changes can be integrated.');
+        if (source.conflict)
+            result.blockers.push('Source has conflicts or an unfinished Git operation. Resolve it manually before continuing.');
+        if (!destination) {
+            result.blockers.push('Choose a destination branch.');
+            return result;
+        }
+        if (!result.branches.includes(destination)) {
+            result.blockers.push('Destination branch is unavailable.');
+            return result;
+        }
+        if (destination === source.branch) {
+            result.blockers.push('Choose a different destination branch.');
+            return result;
+        }
+        const entries = (await git(repository, 'worktree', 'list', '--porcelain', '-z')).split('\0\0');
+        const entry = entries.find((item) => item.split('\0').includes(`branch refs/heads/${destination}`));
+        const destinationPath = entry
+            ?.split('\0')
+            .find((line) => line.startsWith('worktree '))
+            ?.slice(9);
+        if (!destinationPath) {
+            result.blockers.push('Destination is not checked out. In a clean, idle checkout, switch to the chosen branch (or create a worktree yourself), then refresh. Inspect git worktree list first.');
+            return result;
+        }
+        const target = await inspect(destinationPath);
+        result.destination = { ...target, branch: destination };
+        if (target.branch !== destination)
+            result.blockers.push('Destination changed during inspection. Refresh.');
+        if (target.dirty)
+            result.blockers.push('Destination has uncommitted or untracked work. Preserve it with a commit or stash yourself before integrating.');
+        if (target.conflict)
+            result.blockers.push('Destination has conflicts or an unfinished Git operation. Resolve it manually before continuing.');
+        const paths = await Promise.all([realpath(source.path), realpath(target.path)]);
+        for (const peer of sessions) {
+            if (!['running', 'waiting', 'unavailable'].includes(peer.status))
+                continue;
+            const peerPath = await realpath(peer.workspace).catch(() => peer.workspace);
+            if (paths.includes(peerPath))
+                result.blockers.push(`Session “${peer.title}” is ${peer.status}. Stop/wait for all sessions using these workspaces, including child tasks, before Git operations.`);
+        }
+        const ancestor = await git(repository, 'merge-base', source.commit, target.commit).catch(() => '');
+        result.contained = ancestor === source.commit;
+        const prefix = `git -C ${shellQuote(target.path)}`;
+        result.inspection += `\n${prefix} status\n${prefix} log --oneline ${shellQuote(`${target.commit}..${source.commit}`)}\n${prefix} diff --stat ${shellQuote(target.commit)} ${shellQuote(source.commit)}`;
+        if (!result.blockers.length && !result.contained) {
+            // Preconditions fail closed if either HEAD or the working files changed since inspection.
+            result.integration = `test "$(git -C ${shellQuote(source.path)} symbolic-ref --quiet HEAD)" = ${shellQuote(`refs/heads/${session.branch}`)} &&\ntest "$(git -C ${shellQuote(source.path)} rev-parse HEAD)" = ${shellQuote(source.commit)} &&\nhandoff_status=$(git -C ${shellQuote(source.path)} status --porcelain) && test -z "$handoff_status" &&\ntest "$(${prefix} symbolic-ref --quiet HEAD)" = ${shellQuote(`refs/heads/${destination}`)} &&\ntest "$(${prefix} rev-parse HEAD)" = ${shellQuote(target.commit)} &&\nhandoff_status=$(${prefix} status --porcelain) && test -z "$handoff_status" &&\n${prefix} merge --no-edit ${shellQuote(source.commit)}`;
+        }
+        if (!result.blockers.length && result.contained) {
+            result.cleanup = `git -C ${shellQuote(repository)} worktree remove -- ${shellQuote(source.path)}\n# Optional, only after verifying the branch is no longer needed:\ngit -C ${shellQuote(target.path)} branch -d -- ${shellQuote(session.branch)}`;
+        }
+    }
+    catch {
+        result.blockers.push('Worktree or Git status is unavailable. Restore missing worktrees or repository access and refresh. Nothing was changed.');
+    }
+    return result;
+}

package/dist/apps/server/src/history-sources.js

@@ -0,0 +1,59 @@
+import { createHash } from 'node:crypto';
+/** Cache source extraction by visible reply sequence and completed prompts. */
+export function historySources(sessions) {
+    const cache = new WeakMap();
+    return () => sessions().flatMap((session) => {
+        session.store.replySearch.sync();
+        const runs = session.runs.filter((run) => run.status !== 'running');
+        const latest = session.store.db
+            .prepare('SELECT max(seq) AS seq FROM reply_search_chunks')
+            .get();
+        const signature = JSON.stringify([
+            session.title,
+            latest?.seq,
+            runs.map((r) => [r.id, r.prompt, r.createdAt]),
+        ]);
+        const saved = cache.get(session.store);
+        if (saved?.signature === signature)
+            return saved.docs;
+        const docs = [];
+        const byId = new Map(runs.map((run) => [run.id, run]));
+        function add(run, kind, block, text) {
+            // Keep model inputs well below the local embedding model's context window.
+            for (let offset = 0; offset < text.length; offset += 1040) {
+                let start = offset;
+                let end = Math.min(text.length, offset + 1200);
+                // Do not split an emoji or other surrogate pair at either chunk boundary.
+                if (start && /[\uDC00-\uDFFF]/.test(text[start]))
+                    start--;
+                if (end < text.length && /[\uDC00-\uDFFF]/.test(text[end]))
+                    end--;
+                const part = text.slice(start, end);
+                if (!part.trim())
+                    continue;
+                docs.push({
+                    sourceId: createHash('sha256')
+                        .update(JSON.stringify([session.id, run.id, kind, block, offset]))
+                        .digest('hex'),
+                    sessionId: session.id,
+                    sessionTitle: session.title,
+                    runId: run.id,
+                    kind,
+                    createdAt: run.createdAt,
+                    text: part,
+                });
+            }
+        }
+        for (const run of runs)
+            add(run, 'prompt', 'prompt', run.prompt);
+        for (const row of session.store.db
+            .prepare('SELECT id,run_id,json_quote(text) AS text FROM reply_search_chunks')
+            .iterate()) {
+            const run = byId.get(String(row.run_id));
+            if (run)
+                add(run, 'reply', String(row.id), JSON.parse(String(row.text)));
+        }
+        cache.set(session.store, { signature, docs });
+        return docs;
+    });
+}