@felan-ai/daemon 0.7.1 → 0.7.3

package/dist/daemon/registry.js

@@ -16,6 +16,7 @@ import { sessionTip } from './session-cursor.js';
 import { shutdownStep } from './shutdown-error.js';
 import { HostWorkers } from './host-workers.js';
 import { assertStagedWorker } from './worker.js';
+export const PROJECTION_CLEANUP_LIMIT_MS = 30_000;
 const nonRunMutations = new Set(['set_model', 'set_thinking', 'session.rename', 'session.entry.label', 'session.branch.select', 'session.export', 'command.invoke', 'shell.execute', 'processes.write', 'processes.stop', 'steer', 'follow_up', 'queue.clear', 'executions.steer', 'executions.cancel', 'ui.action']);
 class RegistryOpeningCancelled extends Error {
 }
@@ -33,6 +34,7 @@ export class SessionRegistry {
     copyClaims = new Set();
     reservations = new Map();
     lifecycleWriters = new Set();
+    lateWriters = new Map();
     reloadAttachments = new Map();
     invalidationListeners = new Set();
     observers = new Map();
@@ -108,7 +110,7 @@ export class SessionRegistry {
         if (session.deletedAt !== undefined)
             throw registryError('not_found', 'Session was deleted.');
         if (this.entries.get(id)?.projectionFailed)
-            throw registryError('unavailable', 'Session projection failed; further work is disabled.');
+            throw registryError('unavailable', 'Session projection failed; it reopens once cleanup finishes, try again shortly.');
         if (this.reservations.has(session.piPath) && !activatingBinding)
             throw registryError('busy', 'Session has a lifecycle operation in progress.');
         if (session.state !== 'open' || this.entries.get(id)?.disposing || this.entries.get(id)?.cancelling || this.closing.has(id) || this.closing.has(session.root) || this.copyClaims.has(session.piPath))
@@ -175,9 +177,9 @@ export class SessionRegistry {
     async activeWork() {
         this.options.owner.assertCurrent();
         const interruptible = await this.processes.interruptibleCount();
-        const busy = [...this.entries.values()].filter(entry => !entry.binding.runtime.session.isIdle || entry.dispatches.size || entry.writers.size
+        const busy = [...this.entries].filter(([id, entry]) => this.lateWriters.has(id) || !entry.binding.runtime.session.isIdle || entry.dispatches.size || entry.writers.size
             || entry.host?.hasPendingWork() || entry.host?.hasActiveJobs() || [...entry.services].some(service => service.busy())).length;
-        return busy + interruptible;
+        return busy + [...this.lateWriters.keys()].filter(id => !this.entries.has(id)).length + interruptible;
     }
     create(request) {
         this.assertNewWork();
@@ -270,6 +272,8 @@ export class SessionRegistry {
             throw registryError('not_found', 'Session is not registered.');
         if (stored.deletedAt !== undefined)
             throw registryError('not_found', 'Session was deleted.');
+        if (this.lateWriters.has(id))
+            throw registryError('busy', 'Session transcript already has a writer.');
         if (this.reloadAttachments.has(id) && this.opening.has(id))
             return this.opening.get(id);
         if (this.closing.has(id))
@@ -282,6 +286,8 @@ export class SessionRegistry {
         const pending = this.opening.get(id);
         if (pending)
             return pending;
+        if (this.pathClaims.has(stored.piPath))
+            throw registryError('busy', 'Session transcript already has a writer.');
         const reopening = stored.state === 'closed';
         if (reopening)
             this.options.store.updateSession(id, { state: 'open' });
@@ -411,7 +417,7 @@ export class SessionRegistry {
         const entry = this.require(id);
         const attachment = randomUUID();
         if (entry.projectionFailed)
-            throw registryError('unavailable', 'Session projection failed; close and reopen the session before attaching.');
+            throw registryError('unavailable', 'Session projection failed; cleanup is still in progress.');
         const snapshot = entry.projection.snapshot();
         entry.attachments.set(attachment, { ...metadata });
         return { attachment, snapshot };
@@ -761,6 +767,8 @@ export class SessionRegistry {
             throw registryError('busy', 'Wait for the current run to finish before reloading.');
         if (this.opening.has(id) || entry?.disposing || entry?.cancelling || entry?.writers.size)
             throw registryError('busy', 'Session has a lifecycle operation in progress.');
+        if (!entry && this.pathClaims.has(stored.piPath))
+            throw registryError('busy', 'Session transcript already has a writer.');
         const token = Symbol('reload');
         this.reservations.set(stored.piPath, { token, id });
         const attachments = entry?.attachments ?? new Map();
@@ -1057,23 +1065,27 @@ export class SessionRegistry {
         // Host shutdown cancels its full descendant tree and waits beyond terminal status records.
         const entry = this.entries.get(id);
         this.settleInteractions(id, 'close');
-        if (entry)
+        if (entry && !entry.projectionFailed)
             await this.cancelViews(id);
-        await entry?.host?.shutdown();
+        if (!entry?.projectionFailed)
+            await entry?.host?.shutdown();
         for (const child of descendants)
             await this.close(child.id);
         if (entry) {
-            entry.runAbort?.abort();
-            await entry.cancelling;
+            if (!entry.projectionFailed) {
+                entry.runAbort?.abort();
+                await entry.cancelling;
+            }
             await entry.projectionCancellation;
-            await entry.binding.runtime.session.abort();
-            await this.processes.cancelForeground(id);
-            await Promise.all(entry.writers);
-            if (!entry.projectionFailed)
+            if (!entry.projectionFailed) {
+                await entry.binding.runtime.session.abort();
+                await this.processes.cancelForeground(id);
+                await Promise.all(entry.writers);
                 entry.projection.settleRun(this.options.store.sessionMetadata(id).run.id);
-            await this.processes.settle(stored.root, false, id === stored.root ? undefined : new Set([id]));
-            for (const service of entry.services)
-                await this.processes.withCleanup(id, () => service.settle());
+                await this.processes.settle(stored.root, false, id === stored.root ? undefined : new Set([id]));
+                for (const service of entry.services)
+                    await this.processes.withCleanup(id, () => service.settle());
+            }
             await this.disposeEntry(id, true);
         }
         else {
@@ -1109,7 +1121,7 @@ export class SessionRegistry {
             if (!options.interrupt || this.failure)
                 throw error;
         });
-        await this.join([hostWorkers, ...cancellations, shutdownStep('registry-pending', () => this.join([...this.opening.values(), closing, ...this.lifecycleWriters], undefined, true))]);
+        await this.join([hostWorkers, ...cancellations, shutdownStep('registry-pending', () => this.join([...this.opening.values(), closing, ...this.lifecycleWriters, ...this.lateWriters.values()], undefined, true))]);
         if (this.failure)
             await shutdownStep('registry-fenced', async () => { await this.failureSettlement; throw this.failure; });
         if (options.interrupt) {
@@ -1160,6 +1172,7 @@ export class SessionRegistry {
                 this.options.store.interruptSessionRun(id, run); }, id);
             this.shutdownInterruptions.delete(id);
         }
+        await shutdownStep('registry-pending', () => this.join([...this.lateWriters.values()]));
         this.retainedServices.clear();
         this.lossUnsubscribe();
         this.listeners.clear();
@@ -1607,15 +1620,21 @@ export class SessionRegistry {
             this.options.owner.assertCurrent();
             const stored = this.options.store.sessionMetadata(id);
             const closed = close || this.closes.has(id);
-            if (entry.projectionFailed)
-                this.options.store.transitionSessionForSafety(id, closed ? 'closed' : 'evicted');
+            if (entry.projectionFailed) {
+                this.interruptRun(id);
+                const commit = this.options.store.transitionSessionForSafety(id, closed ? 'closed' : 'evicted');
+                if (commit.revisions[id] !== undefined)
+                    this.publish({ v: 1, session: id, rev: commit.value.revision,
+                        change: { type: 'metadata.updated', title: commit.value.title, state: commit.value.state, residency: commit.value.residency } });
+            }
             else
                 entry.projection.transitionForSafety(closed ? 'closed' : 'evicted');
             entry.projection.dispose();
             this.entries.delete(id);
             if (!preserveView)
                 this.listeners.delete(id);
-            this.pathClaims.delete(stored.piPath);
+            if (!this.lateWriters.has(id))
+                this.pathClaims.delete(stored.piPath);
             if (!close && entry.services.size)
                 this.retainedServices.set(id, entry.services);
         })();
@@ -1628,6 +1647,14 @@ export class SessionRegistry {
             throw error;
         }
     }
+    interruptRun(id) {
+        const run = this.options.store.sessionMetadata(id).run;
+        if (!run.id || !['running', 'waiting', 'cancelling'].includes(run.state))
+            return;
+        const commit = this.options.store.interruptSessionRun(id, run.id);
+        if (commit.revisions[id] !== undefined)
+            this.publish({ v: 1, session: id, rev: commit.value.revision, change: { type: 'run.updated', run: commit.value.run } });
+    }
     projectionFailed(session, error) {
         this.diagnostic({ scope: 'projection', session, error });
         if (!this.projectionIntegrityIntact(error))
@@ -1635,19 +1662,29 @@ export class SessionRegistry {
         const entry = this.entries.get(session);
         if (!entry || entry.projectionFailed)
             return;
+        const path = this.options.store.sessionMetadata(session).piPath;
         entry.projectionFailed = true;
         this.processes.seal(session);
+        let expired = false;
+        const failed = (cleanup) => {
+            this.diagnostic({ scope: 'registry', session, error: cleanup });
+            this.cancellationFailures.add(cleanup);
+            this.projectionIntegrityIntact(cleanup);
+        };
         const attempt = async (operation) => {
+            if (expired || this.entries.get(session) !== entry)
+                return;
             try {
                 await operation();
             }
             catch (cleanup) {
-                this.diagnostic({ scope: 'registry', session, error: cleanup });
-                this.cancellationFailures.add(cleanup);
-                this.projectionIntegrityIntact(cleanup);
+                try {
+                    failed(cleanup);
+                }
+                catch { }
             }
         };
-        entry.projectionCancellation = Promise.resolve().then(async () => {
+        const cancellation = Promise.resolve().then(async () => {
             await attempt(() => entry.projection.dispose());
             await attempt(() => entry.runAbort?.abort());
             for (const controller of entry.viewActions ?? [])
@@ -1677,7 +1714,59 @@ export class SessionRegistry {
                     throw new Error('Projection-failed session has not settled.');
                 transitionRun('idle');
             });
-        }).finally(() => { delete entry.projectionCancellation; });
+        }).catch(cleanup => { try {
+            failed(cleanup);
+        }
+        catch { } });
+        let timer;
+        const timeout = new Error(`Projection-failure cleanup timed out after ${PROJECTION_CLEANUP_LIMIT_MS} milliseconds.`);
+        const deadline = new Promise(resolve => {
+            timer = setTimeout(() => {
+                expired = true;
+                const failures = [];
+                const late = this.join([cancellation, ...(entry.cancelling ? [entry.cancelling] : [])], failures).then(async () => {
+                    do {
+                        await this.join([...entry.writers], failures);
+                    } while (entry.writers.size);
+                    await this.join([eviction, ...(this.closes.has(session) ? [this.closes.get(session)] : []), ...(entry.disposing ? [entry.disposing] : [])], failures);
+                    for (const failure of failures) {
+                        try {
+                            failed(failure);
+                        }
+                        catch { }
+                    }
+                }).finally(() => {
+                    this.lateWriters.delete(session);
+                    this.cancellationFailures.delete(timeout);
+                    if (!this.entries.has(session))
+                        this.pathClaims.delete(path);
+                });
+                this.lateWriters.set(session, late);
+                try {
+                    failed(timeout);
+                }
+                catch { }
+                finally {
+                    resolve();
+                }
+            }, PROJECTION_CLEANUP_LIMIT_MS);
+        });
+        entry.projectionCancellation = Promise.race([cancellation, deadline]).then(() => {
+            if (!this.failure)
+                try {
+                    this.interruptRun(session);
+                }
+                catch (cleanup) {
+                    this.fence(cleanup);
+                    throw cleanup;
+                }
+        }).finally(() => { clearTimeout(timer); delete entry.projectionCancellation; });
+        const eviction = entry.projectionCancellation.then(async () => {
+            if (!this.failure && !this.stopping && !this.closing.has(session) && this.entries.get(session) === entry)
+                await this.disposeEntry(session, false);
+        });
+        this.lifecycleWriters.add(eviction);
+        void eviction.catch(cleanup => this.diagnostic({ scope: 'registry', session, error: cleanup })).finally(() => this.lifecycleWriters.delete(eviction));
     }
     projectionIntegrityIntact(error) {
         if (error instanceof AggregateError) {
@@ -1765,10 +1854,10 @@ export class SessionRegistry {
             throw new AggregateError(failures, 'Registry writers did not settle cleanly; ownership must remain held.');
     }
     pendingWriters() {
-        return [...this.opening.values(), ...this.lifecycleWriters, ...[...this.entries.values()].flatMap(entry => [...entry.writers, ...(entry.cancelling ? [entry.cancelling] : []), ...(entry.projectionCancellation ? [entry.projectionCancellation] : [])])];
+        return [...this.opening.values(), ...this.lifecycleWriters, ...this.lateWriters.values(), ...[...this.entries.values()].flatMap(entry => [...entry.writers, ...(entry.cancelling ? [entry.cancelling] : []), ...(entry.projectionCancellation ? [entry.projectionCancellation] : [])])];
     }
     hasPendingWriters() {
-        return this.opening.size > 0 || this.lifecycleWriters.size > 0 || [...this.entries.values()].some(entry => entry.writers.size > 0 || entry.cancelling !== undefined || entry.projectionCancellation !== undefined);
+        return this.opening.size > 0 || this.lifecycleWriters.size > 0 || this.lateWriters.size > 0 || [...this.entries.values()].some(entry => entry.writers.size > 0 || entry.cancelling !== undefined || entry.projectionCancellation !== undefined);
     }
     async join(operations, failures, allowCancelled = false) {
         const errors = failures ?? [];