@withtruing/companion 0.13.2 → 0.14.0

package/dist/whole-read-shared-source.js

@@ -0,0 +1,194 @@
+import { acquireAttemptSource, } from './whole-read-temp.js';
+const DEFAULT_IDLE_MS = 5_000;
+const LEASE_EXTENSION_MS = 24 * 60 * 60_000;
+function exactKey(value) {
+    return `${value.assignmentId}\0${value.assignmentRevision}\0${value.snapshotSha}`;
+}
+export function createWholeReadSharedSourceManager(dependencies = {}) {
+    const acquireLease = dependencies.acquireLease ?? acquireAttemptSource;
+    const idleMs = dependencies.idleMs ?? DEFAULT_IDLE_MS;
+    const clock = dependencies.now ?? (() => new Date());
+    const schedule = dependencies.setTimeout ?? setTimeout;
+    const cancel = dependencies.clearTimeout ?? clearTimeout;
+    const releaseSource = dependencies.releaseSource ?? (async (source) => {
+        const releasable = source;
+        await releasable.release?.();
+    });
+    const states = new Map();
+    const cleanupJobs = new Set();
+    let stopping = false;
+    const reportCleanup = async (record) => {
+        if (record.state === 'cleanup_pending')
+            await dependencies.onCleanupPending?.(record);
+    };
+    const cleanup = (state) => {
+        if (state.cleanup)
+            return state.cleanup;
+        const job = (async () => {
+            if (state.idleTimer) {
+                cancel(state.idleTimer);
+                state.idleTimer = undefined;
+            }
+            try {
+                await state.acquisition;
+            }
+            catch {
+                return;
+            }
+            try {
+                await releaseSource(state.source);
+            }
+            finally {
+                const record = await state.lease.release();
+                await reportCleanup(record);
+                states.delete(exactKey(state.key));
+            }
+        })();
+        state.cleanup = job;
+        cleanupJobs.add(job);
+        void job.finally(() => cleanupJobs.delete(job));
+        return job;
+    };
+    const scheduleIdle = (state) => {
+        if (state.refs !== 0 || state.cleanup || state.idleTimer)
+            return;
+        if (state.retired || stopping) {
+            void cleanup(state);
+            return;
+        }
+        state.idleTimer = schedule(() => {
+            state.idleTimer = undefined;
+            if (state.refs === 0)
+                void cleanup(state);
+        }, idleMs);
+        if (typeof state.idleTimer === 'object' && state.idleTimer !== null && 'unref' in state.idleTimer) {
+            state.idleTimer.unref();
+        }
+    };
+    const retire = async (state) => {
+        state.retired = true;
+        if (state.acquiring)
+            state.controller.abort();
+        if (state.refs === 0)
+            await cleanup(state);
+    };
+    const waitForAcquisition = async (state, signal) => {
+        if (!signal)
+            return state.acquisition;
+        if (signal.aborted)
+            throw signal.reason ?? new Error('The operation was aborted');
+        return new Promise((resolve, reject) => {
+            const removeAbortListener = () => signal.removeEventListener('abort', onAbort);
+            const onAbort = () => {
+                removeAbortListener();
+                reject(signal.reason ?? new Error('The operation was aborted'));
+            };
+            signal.addEventListener('abort', onAbort, { once: true });
+            void state.acquisition.then((source) => { removeAbortListener(); resolve(source); }, (error) => { removeAbortListener(); reject(error); });
+        });
+    };
+    return {
+        async acquire(key, acquire, signal) {
+            if (stopping)
+                throw new Error('source_lease_lost');
+            const identity = exactKey(key);
+            for (const state of states.values()) {
+                if (state.key.assignmentId === key.assignmentId && exactKey(state.key) !== identity)
+                    await retire(state);
+            }
+            let state = states.get(identity);
+            if (!state) {
+                const created = {
+                    key: { ...key }, refs: 0, retired: false,
+                    controller: new AbortController(), acquiring: true,
+                    acquisition: Promise.resolve(undefined),
+                };
+                state = created;
+                states.set(identity, state);
+                state.acquisition = (async () => {
+                    let lease;
+                    try {
+                        lease = await acquireLease({
+                            workspaceId: key.workspaceId,
+                            buildId: key.buildId,
+                            attemptId: `shared-${key.assignmentId}-${key.assignmentRevision}-${key.snapshotSha}`,
+                            hostId: key.hostId,
+                            leaseExpiresAt: new Date(clock().getTime() + LEASE_EXTENSION_MS).toISOString(),
+                        });
+                        state.lease = lease;
+                        const source = await acquire(lease, state.controller.signal);
+                        state.source = source;
+                        return source;
+                    }
+                    catch (error) {
+                        try {
+                            if (lease) {
+                                const record = await lease.release();
+                                await reportCleanup(record);
+                            }
+                        }
+                        finally {
+                            states.delete(identity);
+                        }
+                        throw error;
+                    }
+                    finally {
+                        state.acquiring = false;
+                    }
+                })();
+            }
+            if (state.idleTimer) {
+                cancel(state.idleTimer);
+                state.idleTimer = undefined;
+            }
+            state.refs++;
+            let source;
+            try {
+                source = await waitForAcquisition(state, signal);
+            }
+            catch (error) {
+                state.refs--;
+                scheduleIdle(state);
+                throw error;
+            }
+            const renewed = new Date(clock().getTime() + LEASE_EXTENSION_MS).toISOString();
+            try {
+                if (Date.parse(renewed) > Date.parse(state.lease.owner.leaseExpiresAt)) {
+                    const renewal = state.renewal ?? state.lease.renew(renewed);
+                    state.renewal = renewal;
+                    try {
+                        await renewal;
+                    }
+                    finally {
+                        if (state.renewal === renewal)
+                            state.renewal = undefined;
+                    }
+                }
+            }
+            catch (error) {
+                state.refs--;
+                scheduleIdle(state);
+                throw error;
+            }
+            let released = false;
+            return { source, async release() {
+                    if (released)
+                        return;
+                    released = true;
+                    state.refs--;
+                    scheduleIdle(state);
+                } };
+        },
+        async reconcile(active) {
+            const identities = new Set(active.map(exactKey));
+            await Promise.all([...states.values()]
+                .filter((state) => !identities.has(exactKey(state.key))).map(retire));
+        },
+        async settled() { await Promise.allSettled([...cleanupJobs]); },
+        async shutdown() {
+            stopping = true;
+            await Promise.all([...states.values()].map(retire));
+            await Promise.allSettled([...cleanupJobs]);
+        },
+    };
+}

package/dist/whole-read-temp.js

@@ -0,0 +1,479 @@
+import { randomUUID } from 'node:crypto';
+import { lstat, mkdir, readdir, readFile, realpath, rename, rm, writeFile, } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import { sanitizeBuildMetadata } from './whole-read/sanitize.js';
+const SWEEP_INTERVAL_MS = 10 * 60_000;
+const MAX_DELETE_ATTEMPTS = 5;
+const MARKER_FILE = '.whole-read-owner.json';
+const RECORDS_DIR = 'records';
+const LOCATION_ID = /^[A-Za-z0-9_-]+$/;
+export class AttemptSourceError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = 'AttemptSourceError';
+    }
+}
+export class AttemptSourceCleanupError extends Error {
+    cleanup;
+    code = 'cleanup_pending';
+    constructor(cleanup) {
+        super('cleanup_pending');
+        this.cleanup = cleanup;
+        this.name = 'AttemptSourceCleanupError';
+    }
+}
+class CleanupSafetyError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+    }
+}
+const nonBlank = (value) => typeof value === 'string' && value.trim().length > 0;
+function normalizedTime(value) {
+    const milliseconds = Date.parse(value);
+    if (!Number.isFinite(milliseconds))
+        throw new AttemptSourceError('source_owner_invalid');
+    return new Date(milliseconds).toISOString();
+}
+function normalizeOwner(owner, now) {
+    if (![owner.workspaceId, owner.buildId, owner.attemptId, owner.hostId].every(nonBlank)) {
+        throw new AttemptSourceError('source_owner_invalid');
+    }
+    const leaseExpiresAt = normalizedTime(owner.leaseExpiresAt);
+    if (leaseExpiresAt <= now)
+        throw new AttemptSourceError('source_owner_invalid');
+    return { ...owner, leaseExpiresAt };
+}
+function markerFor(owner, locationId) {
+    return { ...owner, locationId };
+}
+function parseMarker(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const candidate = value;
+    const keys = Object.keys(candidate).sort();
+    const expected = ['attemptId', 'buildId', 'hostId', 'leaseExpiresAt', 'locationId', 'workspaceId'];
+    if (keys.length !== expected.length || keys.some((key, index) => key !== expected[index]))
+        return null;
+    if (![candidate.workspaceId, candidate.buildId, candidate.attemptId, candidate.hostId].every(nonBlank)
+        || typeof candidate.locationId !== 'string' || !LOCATION_ID.test(candidate.locationId)
+        || typeof candidate.leaseExpiresAt !== 'string'
+        || !Number.isFinite(Date.parse(candidate.leaseExpiresAt)))
+        return null;
+    return candidate;
+}
+function parseRecord(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const candidate = value;
+    const keys = Object.keys(candidate).sort();
+    const expected = [
+        'attemptId', 'buildId', 'cleanupAttempts', 'deletedAt', 'errorCode', 'hostId',
+        'leaseExpiresAt', 'locationId', 'path', 'state', 'workspaceId',
+    ];
+    if (keys.length !== expected.length || keys.some((key, index) => key !== expected[index]))
+        return null;
+    const marker = parseMarker(Object.fromEntries(['workspaceId', 'buildId', 'attemptId', 'hostId', 'leaseExpiresAt', 'locationId']
+        .map((key) => [key, candidate[key]])));
+    if (!marker || typeof candidate.path !== 'string'
+        || !['live', 'deleted', 'cleanup_pending'].includes(String(candidate.state))
+        || !Number.isSafeInteger(candidate.cleanupAttempts) || candidate.cleanupAttempts < 0
+        || !(candidate.errorCode === null || [
+            'cleanup_delete_failed',
+            'cleanup_reader_cancel_failed',
+            'cleanup_path_outside_root',
+            'cleanup_unsafe_link',
+            'cleanup_marker_invalid',
+        ].includes(String(candidate.errorCode)))
+        || !(candidate.deletedAt === null || (typeof candidate.deletedAt === 'string'
+            && Number.isFinite(Date.parse(candidate.deletedAt)))))
+        return null;
+    return candidate;
+}
+function cleanupRecord(record) {
+    if (record.state === 'live')
+        throw new Error('live cleanup record');
+    return {
+        workspaceId: record.workspaceId,
+        buildId: record.buildId,
+        attemptId: record.attemptId,
+        hostId: record.hostId,
+        leaseExpiresAt: record.leaseExpiresAt,
+        locationId: record.locationId,
+        path: record.path,
+        state: record.state,
+        cleanupAttempts: record.cleanupAttempts,
+        errorCode: record.errorCode,
+        deletedAt: record.deletedAt,
+    };
+}
+async function missing(path) {
+    try {
+        await lstat(path);
+        return false;
+    }
+    catch (error) {
+        return error.code === 'ENOENT';
+    }
+}
+async function assertTreeHasNoLinks(path) {
+    for (const entry of await readdir(path, { withFileTypes: true })) {
+        const child = join(path, entry.name);
+        const stats = await lstat(child);
+        if (stats.isSymbolicLink())
+            throw new CleanupSafetyError('cleanup_unsafe_link');
+        if (stats.isDirectory())
+            await assertTreeHasNoLinks(child);
+    }
+}
+async function validateDeleteTarget(root, record) {
+    const absoluteRoot = resolve(root);
+    const absoluteTarget = resolve(record.path);
+    const fromRoot = relative(absoluteRoot, absoluteTarget);
+    if (dirname(absoluteTarget) !== absoluteRoot || fromRoot === '..' || fromRoot.startsWith(`..${sep}`)) {
+        throw new CleanupSafetyError('cleanup_path_outside_root');
+    }
+    if (await missing(absoluteTarget))
+        return;
+    const [rootStats, targetStats] = await Promise.all([lstat(absoluteRoot), lstat(absoluteTarget)]);
+    if (rootStats.isSymbolicLink() || targetStats.isSymbolicLink() || !targetStats.isDirectory()) {
+        throw new CleanupSafetyError('cleanup_unsafe_link');
+    }
+    const [canonicalRoot, canonicalTarget] = await Promise.all([realpath(absoluteRoot), realpath(absoluteTarget)]);
+    if (dirname(canonicalTarget) !== canonicalRoot) {
+        throw new CleanupSafetyError('cleanup_path_outside_root');
+    }
+    let marker = null;
+    try {
+        marker = parseMarker(JSON.parse(await readFile(join(absoluteTarget, MARKER_FILE), 'utf8')));
+    }
+    catch {
+        // The fixed code below is all that may leave this host.
+    }
+    if (!marker || marker.workspaceId !== record.workspaceId || marker.buildId !== record.buildId
+        || marker.attemptId !== record.attemptId || marker.hostId !== record.hostId
+        || marker.locationId !== record.locationId
+        || Date.parse(marker.leaseExpiresAt) > Date.parse(record.leaseExpiresAt)) {
+        throw new CleanupSafetyError('cleanup_marker_invalid');
+    }
+    await assertTreeHasNoLinks(absoluteTarget);
+}
+export function createCompanionAttemptSourceManager(dependencies = {}) {
+    const root = resolve(dependencies.root ?? join(tmpdir(), 'fynch-product-console-companion', 'whole-read'));
+    const recordsRoot = join(root, RECORDS_DIR);
+    const clock = dependencies.now ?? (() => new Date());
+    const randomLocationId = dependencies.randomLocationId ?? randomUUID;
+    const wait = dependencies.wait
+        ?? ((delayMs) => new Promise((resolveWait) => setTimeout(resolveWait, delayMs)));
+    const retryDelaysMs = dependencies.retryDelaysMs ?? [25, 50, 100, 200];
+    const removeTree = dependencies.removeTree ?? ((path) => rm(path, { recursive: true, force: false }));
+    const reportCleanup = dependencies.reportCleanup ?? (async () => false);
+    const scheduleInterval = dependencies.setInterval ?? setInterval;
+    const cancelInterval = dependencies.clearInterval ?? clearInterval;
+    const buildsEnabled = dependencies.buildsEnabled ?? (() => process.env.WHOLE_READ_BUILDS === '1');
+    const readers = new Map();
+    const activeLocations = new Set();
+    const cleanupJobs = new Map();
+    let timer = null;
+    let starting = null;
+    let sweepRunning = false;
+    let lifecycleVersion = 0;
+    const recordPath = (locationId) => join(recordsRoot, `${locationId}.json`);
+    const ensureRoots = async () => {
+        await mkdir(root, { recursive: true });
+        const rootStats = await lstat(root);
+        if (rootStats.isSymbolicLink() || !rootStats.isDirectory()) {
+            throw new CleanupSafetyError('cleanup_unsafe_link');
+        }
+        await mkdir(recordsRoot, { recursive: true });
+        const recordsStats = await lstat(recordsRoot);
+        const [canonicalRoot, canonicalRecords] = await Promise.all([realpath(root), realpath(recordsRoot)]);
+        if (recordsStats.isSymbolicLink() || !recordsStats.isDirectory()
+            || dirname(canonicalRecords) !== canonicalRoot) {
+            throw new CleanupSafetyError('cleanup_unsafe_link');
+        }
+    };
+    const saveRecord = async (record) => {
+        await ensureRoots();
+        const temporary = join(recordsRoot, `.${record.locationId}.${randomUUID()}.tmp`);
+        try {
+            await writeFile(temporary, JSON.stringify(record), { encoding: 'utf8', flag: 'wx' });
+            await rename(temporary, recordPath(record.locationId));
+        }
+        finally {
+            await rm(temporary, { force: true }).catch(() => undefined);
+        }
+    };
+    const notify = async (record) => {
+        let acknowledged = false;
+        try {
+            const safe = sanitizeBuildMetadata(record, 'owner_scoped_cleanup');
+            if (!safe.ok)
+                return;
+            acknowledged = await reportCleanup(safe.value);
+        }
+        catch {
+            // Cleanup must remain local-first when the old Console is offline.
+        }
+        if (acknowledged && record.state === 'deleted') {
+            await rm(recordPath(record.locationId), { force: true }).catch(() => undefined);
+        }
+    };
+    const recoverUntrackedSources = async () => {
+        for (const entry of await readdir(root, { withFileTypes: true })) {
+            if (!entry.isDirectory() || !entry.name.startsWith('source-'))
+                continue;
+            const path = join(root, entry.name);
+            let marker = null;
+            try {
+                marker = parseMarker(JSON.parse(await readFile(join(path, MARKER_FILE), 'utf8')));
+            }
+            catch {
+                continue;
+            }
+            if (!marker || entry.name !== `source-${marker.locationId}`
+                || !(await missing(recordPath(marker.locationId))))
+                continue;
+            await saveRecord({
+                ...marker,
+                path,
+                state: 'live',
+                cleanupAttempts: 0,
+                errorCode: null,
+                deletedAt: null,
+            });
+        }
+    };
+    const readRecords = async () => {
+        await ensureRoots();
+        await recoverUntrackedSources();
+        const records = [];
+        for (const name of (await readdir(recordsRoot)).filter((entry) => entry.endsWith('.json')).sort()) {
+            try {
+                const parsed = parseRecord(JSON.parse(await readFile(join(recordsRoot, name), 'utf8')));
+                if (parsed && name === `${parsed.locationId}.json`)
+                    records.push(parsed);
+            }
+            catch {
+                // An invalid ledger entry is never enough authority to delete a path.
+            }
+        }
+        return records;
+    };
+    const cancelReaders = async (locationId) => {
+        for (const reader of [...(readers.get(locationId) ?? [])])
+            await reader.cancel();
+        readers.delete(locationId);
+    };
+    const performCleanup = async (initial, at) => {
+        const record = { ...initial, state: 'cleanup_pending', deletedAt: null };
+        await saveRecord(record);
+        try {
+            await cancelReaders(record.locationId);
+        }
+        catch {
+            record.cleanupAttempts += 1;
+            record.errorCode = 'cleanup_reader_cancel_failed';
+            await saveRecord(record);
+            const result = cleanupRecord(record);
+            await notify(result);
+            return result;
+        }
+        for (let attempt = 1; attempt <= MAX_DELETE_ATTEMPTS; attempt += 1) {
+            try {
+                await validateDeleteTarget(root, record);
+                if (!(await missing(record.path)))
+                    await removeTree(record.path);
+                if (!(await missing(record.path)))
+                    throw new Error('cleanup_delete_failed');
+                record.cleanupAttempts += attempt;
+                record.state = 'deleted';
+                record.errorCode = null;
+                record.deletedAt = normalizedTime(at);
+                activeLocations.delete(record.locationId);
+                await saveRecord(record);
+                const result = cleanupRecord(record);
+                await notify(result);
+                return result;
+            }
+            catch (error) {
+                if (error instanceof CleanupSafetyError) {
+                    record.cleanupAttempts += 1;
+                    record.errorCode = error.code;
+                    await saveRecord(record);
+                    const result = cleanupRecord(record);
+                    await notify(result);
+                    return result;
+                }
+                if (attempt < MAX_DELETE_ATTEMPTS) {
+                    await wait(retryDelaysMs[Math.min(attempt - 1, retryDelaysMs.length - 1)] ?? 0);
+                }
+            }
+        }
+        record.cleanupAttempts += MAX_DELETE_ATTEMPTS;
+        record.errorCode = 'cleanup_delete_failed';
+        await saveRecord(record);
+        const result = cleanupRecord(record);
+        await notify(result);
+        return result;
+    };
+    const cleanupLocation = (record, at) => {
+        const active = cleanupJobs.get(record.locationId);
+        if (active)
+            return active;
+        const cleanup = performCleanup(record, at).finally(() => cleanupJobs.delete(record.locationId));
+        cleanupJobs.set(record.locationId, cleanup);
+        return cleanup;
+    };
+    const sweepAttemptSources = async (at) => {
+        const now = normalizedTime(at);
+        const report = { deleted: [], cleanupPending: [], preservedLive: 0 };
+        for (const record of await readRecords()) {
+            if (record.state === 'deleted') {
+                const result = cleanupRecord(record);
+                report.deleted.push(result);
+                await notify(result);
+            }
+            else if (record.state === 'live' && activeLocations.has(record.locationId)
+                && Date.parse(record.leaseExpiresAt) > Date.parse(now)) {
+                report.preservedLive += 1;
+            }
+            else {
+                const result = await cleanupLocation(record, now);
+                (result.state === 'deleted' ? report.deleted : report.cleanupPending).push(result);
+            }
+        }
+        return report;
+    };
+    const acquireAttemptSource = async (suppliedOwner) => {
+        if (!buildsEnabled())
+            throw new AttemptSourceError('whole_read_disabled');
+        const owner = normalizeOwner(suppliedOwner, clock().toISOString());
+        await ensureRoots();
+        const locationId = randomLocationId();
+        if (!LOCATION_ID.test(locationId))
+            throw new AttemptSourceError('source_owner_invalid');
+        const path = join(root, `source-${locationId}`);
+        const record = {
+            ...owner,
+            locationId,
+            path,
+            state: 'live',
+            cleanupAttempts: 0,
+            errorCode: null,
+            deletedAt: null,
+        };
+        await mkdir(path, { recursive: false });
+        try {
+            await writeFile(join(path, MARKER_FILE), JSON.stringify(markerFor(owner, locationId)), {
+                encoding: 'utf8',
+                flag: 'wx',
+            });
+            await saveRecord(record);
+            activeLocations.add(locationId);
+        }
+        catch (error) {
+            await rm(path, { recursive: true, force: true });
+            throw error;
+        }
+        let releasePromise = null;
+        const release = () => {
+            releasePromise ??= cleanupLocation(record, clock().toISOString());
+            return releasePromise;
+        };
+        return {
+            locationId,
+            path,
+            bareRepositoryPath: join(path, 'repo.git'),
+            owner,
+            registerReader(reader) {
+                if (releasePromise !== null || !activeLocations.has(locationId)) {
+                    throw new AttemptSourceError('source_lease_lost');
+                }
+                const active = readers.get(locationId) ?? new Set();
+                active.add(reader);
+                readers.set(locationId, active);
+                return () => active.delete(reader);
+            },
+            async renew(leaseExpiresAt) {
+                if (releasePromise !== null || !activeLocations.has(locationId)) {
+                    throw new AttemptSourceError('source_lease_lost');
+                }
+                const renewed = normalizedTime(leaseExpiresAt);
+                if (renewed <= clock().toISOString() || renewed < record.leaseExpiresAt) {
+                    throw new AttemptSourceError('source_owner_invalid');
+                }
+                record.leaseExpiresAt = renewed;
+                owner.leaseExpiresAt = renewed;
+                await saveRecord(record);
+            },
+            release,
+        };
+    };
+    const withAttemptSource = async (suppliedOwner, action) => {
+        const lease = await acquireAttemptSource(suppliedOwner);
+        try {
+            return await action(lease);
+        }
+        finally {
+            const cleanup = await lease.release();
+            if (cleanup.state === 'cleanup_pending')
+                throw new AttemptSourceCleanupError(cleanup);
+        }
+    };
+    const startAttemptSourceSweeper = () => {
+        if (timer !== null)
+            return Promise.resolve();
+        if (starting !== null)
+            return starting;
+        const startVersion = ++lifecycleVersion;
+        starting = (async () => {
+            await sweepAttemptSources(clock().toISOString());
+            if (timer !== null || lifecycleVersion !== startVersion)
+                return;
+            timer = scheduleInterval(() => {
+                if (sweepRunning)
+                    return;
+                sweepRunning = true;
+                void sweepAttemptSources(clock().toISOString())
+                    .catch(() => undefined)
+                    .finally(() => { sweepRunning = false; });
+            }, SWEEP_INTERVAL_MS);
+            if (typeof timer === 'object' && timer !== null && 'unref' in timer)
+                timer.unref();
+        })().finally(() => { starting = null; });
+        return starting;
+    };
+    const stopAttemptSourceSweeper = () => {
+        lifecycleVersion += 1;
+        if (timer !== null)
+            cancelInterval(timer);
+        timer = null;
+    };
+    return {
+        acquireAttemptSource,
+        withAttemptSource,
+        sweepAttemptSources,
+        startAttemptSourceSweeper,
+        stopAttemptSourceSweeper,
+        sweeperActive: () => timer !== null,
+    };
+}
+let configuredReporter = async () => false;
+const companionAttemptSources = createCompanionAttemptSourceManager({
+    reportCleanup: (record) => configuredReporter(record),
+});
+/** B19 binds this owner-scoped delivery seam to the claimed build assignment transport. */
+export function configureCompanionCleanupReporter(reporter) {
+    configuredReporter = reporter;
+}
+export const withAttemptSource = companionAttemptSources.withAttemptSource;
+export const acquireAttemptSource = companionAttemptSources.acquireAttemptSource;
+export const sweepAttemptSources = companionAttemptSources.sweepAttemptSources;
+export const startAttemptSourceSweeper = companionAttemptSources.startAttemptSourceSweeper;
+export const stopAttemptSourceSweeper = companionAttemptSources.stopAttemptSourceSweeper;
+export const attemptSourceSweeperActive = companionAttemptSources.sweeperActive;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@withtruing/companion",
-  "version": "0.13.2",
+  "version": "0.14.0",
   "description": "The Truing companion: reads your code and runs AI on your own computer, for Truing.",
   "type": "module",
   "license": "MIT",
@@ -36,8 +36,14 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.111.0",
+    "@yarnpkg/lockfile": "1.1.0",
     "cross-spawn": "^7.0.6",
-    "typescript": "5.9.3"
+    "jsonc-parser": "3.3.1",
+    "smol-toml": "1.9.0",
+    "tar-stream": "2.2.0",
+    "typescript": "5.9.3",
+    "yaml": "2.8.2",
+    "yauzl": "3.2.0"
   },
   "devDependencies": {
     "@types/cross-spawn": "^6.0.6",