@msvesper/vesper-link 0.1.4

package/dist/operational-log.js

@@ -0,0 +1,48 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+const DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
+const DEFAULT_FILE_COUNT = 5;
+async function fileSize(filePath) {
+    try {
+        return (await fs.stat(filePath)).size;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return 0;
+        }
+        throw error;
+    }
+}
+async function rotate(logPath, fileCount) {
+    await fs.rm(`${logPath}.${fileCount - 1}`, { force: true });
+    for (let index = fileCount - 2; index >= 1; index -= 1) {
+        try {
+            await fs.rename(`${logPath}.${index}`, `${logPath}.${index + 1}`);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+    }
+    try {
+        await fs.rename(logPath, `${logPath}.1`);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+}
+export async function appendSyncLog(logsDir, record, options = {}) {
+    const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+    const fileCount = options.fileCount ?? DEFAULT_FILE_COUNT;
+    const line = `${JSON.stringify(record)}\n`;
+    const logPath = path.join(logsDir, 'sync.log');
+    await fs.mkdir(logsDir, { recursive: true });
+    const currentSize = await fileSize(logPath);
+    if (currentSize > 0 && currentSize + Buffer.byteLength(line) > maxBytes) {
+        await rotate(logPath, fileCount);
+    }
+    await fs.appendFile(logPath, line, 'utf8');
+}

package/dist/paths.d.ts

@@ -0,0 +1,23 @@
+export interface LinkPaths {
+    homeDir: string;
+    stateDir: string;
+    configPath: string;
+    pendingDir: string;
+    sessionsDir: string;
+    syncStatePath: string;
+    lockPath: string;
+    tsnetDir: string;
+    transportDir: string;
+    transportRendezvousPath: string;
+    transportLockPath: string;
+    runtimeDir: string;
+    currentPath: string;
+    launcherPath: string;
+    installStatePath: string;
+    installProgressPath: string;
+    logsDir: string;
+    claudeProjectsDir: string;
+    copilotSessionsDir: string;
+    codexHome: string;
+}
+export declare function resolveLinkPaths(environment?: NodeJS.ProcessEnv): LinkPaths;

package/dist/paths.js

@@ -0,0 +1,36 @@
+import * as os from 'node:os';
+import * as path from 'node:path';
+export function resolveLinkPaths(environment = process.env) {
+    const homeDir = environment.HOME || environment.USERPROFILE || os.homedir();
+    const rawStateDir = path.normalize(environment.VESPER_LINK_HOME || path.join(homeDir, '.vesper-link'));
+    const root = path.parse(rawStateDir).root;
+    if (rawStateDir === root) {
+        throw new Error('VESPER_LINK_HOME must not be a filesystem root');
+    }
+    const stateDir = rawStateDir.replace(/[\\/]+$/, '');
+    const codexHome = environment.CODEX_HOME || path.join(homeDir, '.codex');
+    return {
+        homeDir,
+        stateDir,
+        configPath: path.join(stateDir, 'config.json'),
+        pendingDir: path.join(stateDir, 'pending'),
+        sessionsDir: path.join(stateDir, 'sessions'),
+        syncStatePath: path.join(stateDir, 'sync-state.json'),
+        // This lock must outlive stateDir so destructive uninstall cannot remove
+        // the lock while its critical section is still active.
+        lockPath: stateDir + '.lock',
+        tsnetDir: path.join(stateDir, 'tsnet'),
+        transportDir: path.join(stateDir, 'transport'),
+        transportRendezvousPath: path.join(stateDir, 'transport', 'transport.json'),
+        transportLockPath: path.join(stateDir, 'transport', 'owner.lock'),
+        runtimeDir: path.join(stateDir, 'runtime'),
+        currentPath: path.join(stateDir, 'current.json'),
+        launcherPath: path.join(stateDir, 'current', 'cli.mjs'),
+        installStatePath: path.join(stateDir, 'install-state.json'),
+        installProgressPath: path.join(stateDir, 'install-progress.json'),
+        logsDir: path.join(stateDir, 'logs'),
+        claudeProjectsDir: path.join(homeDir, '.claude', 'projects'),
+        copilotSessionsDir: path.join(homeDir, '.copilot', 'session-state'),
+        codexHome,
+    };
+}

package/dist/pending.d.ts

@@ -0,0 +1,7 @@
+import { type PendingMarker } from './session.js';
+export declare function writePendingMarker(pendingDir: string, marker: PendingMarker): Promise<string>;
+export declare function readPendingMarkers(pendingDir: string): Promise<Array<{
+    path: string;
+    marker: PendingMarker;
+}>>;
+export declare function removePendingMarker(markerPath: string): Promise<void>;

package/dist/pending.js

@@ -0,0 +1,35 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { isProvider } from './contracts.js';
+import { listJsonFiles, readJsonFile, writeJsonAtomic } from './atomic-json.js';
+import { stableSessionKey } from './session.js';
+export async function writePendingMarker(pendingDir, marker) {
+    if (marker.schemaVersion !== 1 || !isProvider(marker.provider) || !marker.providerSessionId || !marker.transcriptPath) {
+        throw new Error('Invalid pending marker');
+    }
+    const markerPath = path.join(pendingDir, `${stableSessionKey(marker.provider, marker.providerSessionId)}.json`);
+    await writeJsonAtomic(markerPath, {
+        schemaVersion: 1,
+        provider: marker.provider,
+        providerSessionId: marker.providerSessionId,
+        transcriptPath: path.resolve(marker.transcriptPath),
+        queuedAt: marker.queuedAt,
+    });
+    return markerPath;
+}
+export async function readPendingMarkers(pendingDir) {
+    const files = await listJsonFiles(pendingDir);
+    const markers = [];
+    for (const filePath of files) {
+        const marker = await readJsonFile(filePath);
+        if (!marker || marker.schemaVersion !== 1 || !isProvider(marker.provider)
+            || !marker.providerSessionId || !marker.transcriptPath || !marker.queuedAt) {
+            throw new Error(`Malformed pending marker: ${filePath}`);
+        }
+        markers.push({ path: filePath, marker });
+    }
+    return markers;
+}
+export async function removePendingMarker(markerPath) {
+    await fs.rm(markerPath, { force: true });
+}

package/dist/process-runner.d.ts

@@ -0,0 +1,11 @@
+export interface ProcessResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+export interface ProcessRunner {
+    run(command: string, args: string[], input?: string, environment?: NodeJS.ProcessEnv): Promise<ProcessResult>;
+}
+export declare class NodeProcessRunner implements ProcessRunner {
+    run(command: string, args: string[], input?: string, environment?: NodeJS.ProcessEnv): Promise<ProcessResult>;
+}

package/dist/process-runner.js

@@ -0,0 +1,21 @@
+import { spawn } from 'node:child_process';
+export class NodeProcessRunner {
+    run(command, args, input, environment) {
+        return new Promise((resolve, reject) => {
+            const child = spawn(command, args, {
+                stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true, env: environment ?? process.env,
+            });
+            const stdout = [];
+            const stderr = [];
+            child.stdout.on('data', (chunk) => stdout.push(Buffer.from(chunk)));
+            child.stderr.on('data', (chunk) => stderr.push(Buffer.from(chunk)));
+            child.once('error', reject);
+            child.once('close', (code) => resolve({
+                code: code ?? 1,
+                stdout: Buffer.concat(stdout).toString('utf8'),
+                stderr: Buffer.concat(stderr).toString('utf8'),
+            }));
+            child.stdin.end(input);
+        });
+    }
+}

package/dist/provider-integrations.d.ts

@@ -0,0 +1,42 @@
+import type { LinkPaths } from './paths.js';
+export type SupportedProvider = 'claude-code' | 'github-copilot' | 'openai-codex';
+interface JsonObject {
+    [key: string]: unknown;
+}
+export interface OwnedProviderIntegrations {
+    providers: SupportedProvider[];
+    claudeHook?: JsonObject;
+    copilotHook?: JsonObject;
+    claudeMcp?: JsonObject;
+    copilotMcp?: JsonObject;
+    claudeInstruction?: string;
+    copilotInstruction?: string;
+    codexMcpBlock?: string;
+    codexInstruction?: string;
+}
+export interface ProviderLocations {
+    claudeSettingsPath: string;
+    claudeUserConfigPath: string;
+    claudeInstructionPath: string;
+    copilotSettingsPath: string;
+    copilotMcpPath: string;
+    copilotInstructionPath: string;
+    codexConfigPath: string;
+    codexInstructionPath: string;
+}
+export type ProviderMutation = 'claude-hook' | 'claude-mcp' | 'claude-instruction' | 'copilot-hook' | 'copilot-mcp' | 'copilot-instruction' | 'codex-mcp' | 'codex-instruction';
+export declare function providerLocations(paths: LinkPaths): ProviderLocations;
+export declare function detectInstalledProviders(paths: LinkPaths): Promise<SupportedProvider[]>;
+export declare function providerTargetPaths(paths: LinkPaths, providers: SupportedProvider[]): string[];
+export declare function applyProviderIntegrations(options: {
+    paths: LinkPaths;
+    providers: SupportedProvider[];
+    trusted: boolean;
+    nodePath: string;
+    launcherPath: string;
+    previous?: OwnedProviderIntegrations;
+    installHooks?: boolean;
+    afterMutation?: (mutation: ProviderMutation) => Promise<void> | void;
+}): Promise<OwnedProviderIntegrations>;
+export declare function removeProviderIntegrations(paths: LinkPaths, owned: OwnedProviderIntegrations): Promise<void>;
+export {};

package/dist/provider-integrations.js

@@ -0,0 +1,339 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { readJsonFile, writeJsonAtomic } from './atomic-json.js';
+const CODEX_MCP_BEGIN = '# BEGIN vesper-link:vesper-memory MCP';
+const CODEX_MCP_END = '# END vesper-link:vesper-memory MCP';
+const INSTRUCTION_BEGIN = '<!-- BEGIN vesper-link:vesper-memory -->';
+const INSTRUCTION_END = '<!-- END vesper-link:vesper-memory -->';
+const MEMORY_INSTRUCTION = `Use the vesper-memory search_memory tool when prior preferences, decisions, facts, or context may matter. Use add_fact only when the user explicitly asks you to remember something.`;
+export function providerLocations(paths) {
+    return {
+        claudeSettingsPath: path.join(paths.homeDir, '.claude', 'settings.json'),
+        claudeUserConfigPath: path.join(paths.homeDir, '.claude.json'),
+        claudeInstructionPath: path.join(paths.homeDir, '.claude', 'CLAUDE.md'),
+        copilotSettingsPath: path.join(paths.homeDir, '.copilot', 'settings.json'),
+        copilotMcpPath: path.join(paths.homeDir, '.copilot', 'mcp-config.json'),
+        copilotInstructionPath: path.join(paths.homeDir, '.copilot', 'instructions', 'vesper-memory.instructions.md'),
+        codexConfigPath: path.join(paths.codexHome, 'config.toml'),
+        codexInstructionPath: path.join(paths.codexHome, 'AGENTS.md'),
+    };
+}
+function objectValue(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function arrayValue(value) {
+    return Array.isArray(value) ? value : [];
+}
+function equalJson(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+async function exists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+}
+async function readJsonObject(filePath) {
+    const value = await readJsonFile(filePath);
+    if (value === null) {
+        return {};
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`Configuration file must contain a JSON object: ${filePath}`);
+    }
+    return value;
+}
+async function readText(filePath) {
+    try {
+        return await fs.readFile(filePath, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return '';
+        }
+        throw error;
+    }
+}
+async function writeTextAtomic(filePath, content) {
+    if (!content) {
+        await fs.rm(filePath, { force: true });
+        return;
+    }
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    try {
+        await fs.writeFile(temporary, content, 'utf8');
+        await fs.rename(temporary, filePath);
+    }
+    finally {
+        await fs.rm(temporary, { force: true }).catch(() => undefined);
+    }
+}
+function markedInstruction() {
+    return `${INSTRUCTION_BEGIN}\n${MEMORY_INSTRUCTION}\n${INSTRUCTION_END}`;
+}
+function replaceMarkedBlock(content, begin, end, replacement) {
+    const beginIndex = content.indexOf(begin);
+    const endIndex = content.indexOf(end);
+    if ((beginIndex >= 0) !== (endIndex >= 0) || (beginIndex >= 0 && endIndex < beginIndex)) {
+        throw new Error(`Malformed managed block: ${begin}`);
+    }
+    let without = content;
+    if (beginIndex >= 0) {
+        without = `${content.slice(0, beginIndex)}${content.slice(endIndex + end.length)}`;
+    }
+    without = without.replace(/\s+$/, '');
+    if (!replacement) {
+        return without ? `${without}\n` : '';
+    }
+    return without ? `${without}\n\n${replacement}\n` : `${replacement}\n`;
+}
+function assertMarkedBlockOwned(content, begin, end, previous) {
+    const beginIndex = content.indexOf(begin);
+    const endIndex = content.indexOf(end);
+    if ((beginIndex >= 0) !== (endIndex >= 0) || (beginIndex >= 0 && endIndex < beginIndex)) {
+        throw new Error('Malformed managed block: ' + begin);
+    }
+    const current = beginIndex >= 0 ? content.slice(beginIndex, endIndex + end.length) : undefined;
+    if (previous !== undefined && current !== undefined && current !== previous) {
+        throw new Error('Managed block changed ownership: ' + begin);
+    }
+    if (previous === undefined && current !== undefined) {
+        throw new Error('Managed block already exists without owned install state: ' + begin);
+    }
+}
+function quoteToml(value) {
+    return JSON.stringify(value);
+}
+function codexMcpBlock(nodePath, launcherPath) {
+    return `${CODEX_MCP_BEGIN}\n[mcp_servers.vesper-memory]\ncommand = ${quoteToml(nodePath)}\nargs = [${quoteToml(launcherPath)}, "mcp"]\n${CODEX_MCP_END}`;
+}
+function quoteCommand(value) {
+    return '"' + value.replace(/"/g, '\\"') + '"';
+}
+function ownedClaudeHook(nodePath, launcherPath) {
+    return {
+        hooks: [{
+                type: 'command', command: `${quoteCommand(nodePath)} ${quoteCommand(launcherPath)} report-session --provider claude-code`,
+                timeout: 10, statusMessage: 'Queue session for Vesper Memory',
+            }],
+    };
+}
+function ownedCopilotHook(nodePath, launcherPath) {
+    return { type: 'command', exec: nodePath, args: [launcherPath, 'report-session', '--provider', 'github-copilot'], timeoutSec: 10 };
+}
+function stdioMcp(type, nodePath, launcherPath) {
+    return type === 'stdio'
+        ? { type, command: nodePath, args: [launcherPath, 'mcp'], env: {} }
+        : { type, command: nodePath, args: [launcherPath, 'mcp'], tools: ['*'] };
+}
+export async function detectInstalledProviders(paths) {
+    const candidates = [
+        ['claude-code', path.join(paths.homeDir, '.claude')],
+        ['github-copilot', path.join(paths.homeDir, '.copilot')],
+        ['openai-codex', paths.codexHome],
+    ];
+    const found = [];
+    for (const [provider, location] of candidates) {
+        if (await exists(location)) {
+            found.push(provider);
+        }
+    }
+    return found;
+}
+export function providerTargetPaths(paths, providers) {
+    const locations = providerLocations(paths);
+    const result = [];
+    if (providers.includes('claude-code')) {
+        result.push(locations.claudeSettingsPath, locations.claudeUserConfigPath, locations.claudeInstructionPath);
+    }
+    if (providers.includes('github-copilot')) {
+        result.push(locations.copilotSettingsPath, locations.copilotMcpPath, locations.copilotInstructionPath);
+    }
+    if (providers.includes('openai-codex')) {
+        result.push(locations.codexConfigPath, locations.codexInstructionPath);
+    }
+    return result;
+}
+export async function applyProviderIntegrations(options) {
+    const locations = providerLocations(options.paths);
+    const owned = { providers: [...options.providers] };
+    if (options.providers.includes('claude-code')) {
+        if (options.installHooks !== false) {
+            const settings = await readJsonObject(locations.claudeSettingsPath);
+            const hooks = objectValue(settings.hooks);
+            let entries = arrayValue(hooks.SessionEnd);
+            if (options.previous?.claudeHook) {
+                entries = entries.filter((entry) => !equalJson(entry, options.previous.claudeHook));
+            }
+            owned.claudeHook = ownedClaudeHook(options.nodePath, options.launcherPath);
+            if (!entries.some((entry) => equalJson(entry, owned.claudeHook))) {
+                entries.push(owned.claudeHook);
+            }
+            hooks.SessionEnd = entries;
+            settings.hooks = hooks;
+            await writeJsonAtomic(locations.claudeSettingsPath, settings);
+            await options.afterMutation?.('claude-hook');
+        }
+        const config = await readJsonObject(locations.claudeUserConfigPath);
+        const servers = objectValue(config.mcpServers);
+        if (options.previous?.claudeMcp) {
+            if (servers['vesper-memory'] !== undefined && !equalJson(servers['vesper-memory'], options.previous.claudeMcp)) {
+                throw new Error('Claude MCP vesper-memory changed ownership; refusing to modify it');
+            }
+            delete servers['vesper-memory'];
+        }
+        if (options.trusted) {
+            if (servers['vesper-memory'] !== undefined) {
+                throw new Error('Claude MCP name vesper-memory is already owned by another configuration');
+            }
+            owned.claudeMcp = stdioMcp('stdio', options.nodePath, options.launcherPath);
+            servers['vesper-memory'] = owned.claudeMcp;
+        }
+        if (Object.keys(servers).length > 0) {
+            config.mcpServers = servers;
+        }
+        else {
+            delete config.mcpServers;
+        }
+        if (Object.keys(config).length > 0 || await exists(locations.claudeUserConfigPath)) {
+            await writeJsonAtomic(locations.claudeUserConfigPath, config);
+            await options.afterMutation?.('claude-mcp');
+        }
+        owned.claudeInstruction = options.trusted ? markedInstruction() : undefined;
+        const claudeInstructions = await readText(locations.claudeInstructionPath);
+        assertMarkedBlockOwned(claudeInstructions, INSTRUCTION_BEGIN, INSTRUCTION_END, options.previous?.claudeInstruction);
+        await writeTextAtomic(locations.claudeInstructionPath, replaceMarkedBlock(claudeInstructions, INSTRUCTION_BEGIN, INSTRUCTION_END, owned.claudeInstruction));
+        await options.afterMutation?.('claude-instruction');
+    }
+    if (options.providers.includes('github-copilot')) {
+        if (options.installHooks !== false) {
+            const settings = await readJsonObject(locations.copilotSettingsPath);
+            const hooks = objectValue(settings.hooks);
+            let entries = arrayValue(hooks.sessionEnd);
+            if (options.previous?.copilotHook) {
+                entries = entries.filter((entry) => !equalJson(entry, options.previous.copilotHook));
+            }
+            owned.copilotHook = ownedCopilotHook(options.nodePath, options.launcherPath);
+            if (!entries.some((entry) => equalJson(entry, owned.copilotHook))) {
+                entries.push(owned.copilotHook);
+            }
+            hooks.sessionEnd = entries;
+            settings.hooks = hooks;
+            await writeJsonAtomic(locations.copilotSettingsPath, settings);
+            await options.afterMutation?.('copilot-hook');
+        }
+        const config = await readJsonObject(locations.copilotMcpPath);
+        const servers = objectValue(config.mcpServers);
+        if (options.previous?.copilotMcp) {
+            if (servers['vesper-memory'] !== undefined && !equalJson(servers['vesper-memory'], options.previous.copilotMcp)) {
+                throw new Error('Copilot MCP vesper-memory changed ownership; refusing to modify it');
+            }
+            delete servers['vesper-memory'];
+        }
+        if (options.trusted) {
+            if (servers['vesper-memory'] !== undefined) {
+                throw new Error('Copilot MCP name vesper-memory is already owned by another configuration');
+            }
+            owned.copilotMcp = stdioMcp('local', options.nodePath, options.launcherPath);
+            servers['vesper-memory'] = owned.copilotMcp;
+        }
+        if (Object.keys(servers).length > 0) {
+            config.mcpServers = servers;
+        }
+        else {
+            delete config.mcpServers;
+        }
+        if (Object.keys(config).length > 0 || await exists(locations.copilotMcpPath)) {
+            await writeJsonAtomic(locations.copilotMcpPath, config);
+            await options.afterMutation?.('copilot-mcp');
+        }
+        if (options.trusted) {
+            owned.copilotInstruction = `${MEMORY_INSTRUCTION}\n`;
+            const current = await readText(locations.copilotInstructionPath);
+            if (current && current !== options.previous?.copilotInstruction && current !== owned.copilotInstruction) {
+                throw new Error('Copilot vesper-memory instruction file is not owned by vesper-link');
+            }
+            await writeTextAtomic(locations.copilotInstructionPath, owned.copilotInstruction);
+            await options.afterMutation?.('copilot-instruction');
+        }
+        else {
+            const current = await readText(locations.copilotInstructionPath);
+            if (current && options.previous?.copilotInstruction !== undefined && current !== options.previous.copilotInstruction) {
+                throw new Error('Copilot vesper-memory instruction file changed ownership; refusing to modify it');
+            }
+            if (!current || current === options.previous?.copilotInstruction) {
+                await fs.rm(locations.copilotInstructionPath, { force: true });
+            }
+        }
+    }
+    if (options.providers.includes('openai-codex')) {
+        let config = await readText(locations.codexConfigPath);
+        assertMarkedBlockOwned(config, CODEX_MCP_BEGIN, CODEX_MCP_END, options.previous?.codexMcpBlock);
+        const unmanagedTable = /^\s*\[mcp_servers\.vesper-memory\]\s*$/m.test(replaceMarkedBlock(config, CODEX_MCP_BEGIN, CODEX_MCP_END));
+        if (options.trusted && unmanagedTable) {
+            throw new Error('Codex MCP name vesper-memory is already owned by another configuration');
+        }
+        owned.codexMcpBlock = options.trusted ? codexMcpBlock(options.nodePath, options.launcherPath) : undefined;
+        config = replaceMarkedBlock(config, CODEX_MCP_BEGIN, CODEX_MCP_END, owned.codexMcpBlock);
+        await writeTextAtomic(locations.codexConfigPath, config);
+        await options.afterMutation?.('codex-mcp');
+        owned.codexInstruction = options.trusted ? markedInstruction() : undefined;
+        const codexInstructions = await readText(locations.codexInstructionPath);
+        assertMarkedBlockOwned(codexInstructions, INSTRUCTION_BEGIN, INSTRUCTION_END, options.previous?.codexInstruction);
+        await writeTextAtomic(locations.codexInstructionPath, replaceMarkedBlock(codexInstructions, INSTRUCTION_BEGIN, INSTRUCTION_END, owned.codexInstruction));
+        await options.afterMutation?.('codex-instruction');
+    }
+    return owned;
+}
+export async function removeProviderIntegrations(paths, owned) {
+    await applyProviderIntegrations({
+        paths, providers: owned.providers, trusted: false, nodePath: '', launcherPath: '', previous: owned,
+        installHooks: false,
+    });
+    const locations = providerLocations(paths);
+    for (const provider of owned.providers) {
+        if (provider === 'claude-code' && owned.claudeHook) {
+            const settings = await readJsonObject(locations.claudeSettingsPath);
+            const hooks = objectValue(settings.hooks);
+            const entries = arrayValue(hooks.SessionEnd).filter((entry) => !equalJson(entry, owned.claudeHook));
+            if (entries.length > 0) {
+                hooks.SessionEnd = entries;
+            }
+            else {
+                delete hooks.SessionEnd;
+            }
+            if (Object.keys(hooks).length > 0) {
+                settings.hooks = hooks;
+            }
+            else {
+                delete settings.hooks;
+            }
+            await writeJsonAtomic(locations.claudeSettingsPath, settings);
+        }
+        if (provider === 'github-copilot' && owned.copilotHook) {
+            const settings = await readJsonObject(locations.copilotSettingsPath);
+            const hooks = objectValue(settings.hooks);
+            const entries = arrayValue(hooks.sessionEnd).filter((entry) => !equalJson(entry, owned.copilotHook));
+            if (entries.length > 0) {
+                hooks.sessionEnd = entries;
+            }
+            else {
+                delete hooks.sessionEnd;
+            }
+            if (Object.keys(hooks).length > 0) {
+                settings.hooks = hooks;
+            }
+            else {
+                delete settings.hooks;
+            }
+            await writeJsonAtomic(locations.copilotSettingsPath, settings);
+        }
+    }
+}

package/dist/queue.d.ts

@@ -0,0 +1,19 @@
+import { type PendingMarker, type SessionCandidate, type SessionState } from './session.js';
+export declare const STABLE_FILE_AGE_MS: number;
+export declare const MAX_SESSIONS_PER_RUN = 2000;
+export interface QueueItem {
+    candidate: SessionCandidate;
+    markerPath?: string;
+    markerQueuedAt?: string;
+}
+export declare function isStableForUpload(candidate: Pick<SessionCandidate, 'discovery' | 'archived'>, mtimeMs: number, nowMs: number): boolean;
+export declare function selectQueueItems(options: {
+    markers: Array<{
+        path: string;
+        marker: PendingMarker;
+    }>;
+    scanned: SessionCandidate[];
+    states: Map<string, SessionState>;
+    nowMs: number;
+    limit?: number;
+}): Promise<QueueItem[]>;