@felan-ai/daemon 0.6.0 → 0.7.1

package/dist/daemon/registry.js

@@ -14,6 +14,8 @@ import { isConversationEntry, prepareTranscriptDeletion } from './session-files.
 import { canonicalProspectivePath, pathInside } from './target.js';
 import { sessionTip } from './session-cursor.js';
 import { shutdownStep } from './shutdown-error.js';
+import { HostWorkers } from './host-workers.js';
+import { assertStagedWorker } from './worker.js';
 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 {
 }
@@ -24,6 +26,7 @@ export class SessionRegistry {
     entries = new Map();
     executionManagers = new Map();
     runtimeOpening = new AsyncLocalStorage();
+    hostWorkers;
     bindingActivation = new AsyncLocalStorage();
     opening = new Map();
     pathClaims = new Set();
@@ -62,13 +65,25 @@ export class SessionRegistry {
         this.recovery = options.store.needsRecovery ? options.store.recover().value : undefined;
         this.processes = new RegistryProcesses({ ...(options.processAdapter ? { processAdapter: options.processAdapter } : {}), store: options.store, now: this.now, assertCurrent: () => options.owner.assertCurrent(),
             changed: (id, process, rev) => this.publish({ v: 1, session: id, rev, change: { type: 'process.updated', process } }) });
+        this.hostWorkers = new HostWorkers({ owner: options.owner, processes: this.processes, lifecycle: () => this.options.lifecycle,
+            assertNewWork: () => this.assertHostWork(), fail: error => this.fence(error),
+            claim: (id, path) => {
+                if (this.options.store.findSessionMetadata(id) || this.hostWorkers.owns(id))
+                    throw registryError('invalid_request', 'Worker transcript must have a fresh identity.');
+                if (this.pathClaims.has(path) || this.reservations.has(path) || this.copyClaims.has(path) || this.list().some(row => row.piPath === path))
+                    throw registryError('busy', 'Session transcript already has a writer.');
+                this.pathClaims.add(path);
+            },
+            release: path => this.pathClaims.delete(path),
+            openSession: request => this.runtimeOpening.run({ workerSession: request.worker.sessionManager.getSessionId() }, () => this.options.lifecycle.openSession(request)),
+        });
         this.lossUnsubscribe = options.owner.onLost(error => { this.fence(error); });
     }
     wrapOpeningRuntime(runtime, root) {
         const opening = this.runtimeOpening.getStore();
         if (!opening)
             throw new Error('Runtime factories must run inside lifecycle.openSession.');
-        const scope = { session: '', root };
+        const scope = { session: opening.workerSession ?? '', root };
         opening.scope = scope;
         return this.processes.wrap(runtime, scope);
     }
@@ -104,6 +119,16 @@ export class SessionRegistry {
         if (this.draining)
             throw registryError('busy', 'Daemon is draining.');
     }
+    assertHostWork() {
+        try {
+            this.assertNewWork();
+        }
+        catch (error) {
+            if (error instanceof Error && (this.failure || this.stopping || this.draining))
+                error.name = 'AbortError';
+            throw error;
+        }
+    }
     failExecution(error) { this.fence(error); }
     get fenced() { return this.failure !== undefined; }
     beginDrain() {
@@ -114,6 +139,7 @@ export class SessionRegistry {
         }
         this.assertAdmission();
         this.draining = true;
+        this.hostWorkers.interrupt();
     }
     /** Reopens admission after an abandoned drain; a registry that started shutting down cannot resume. */
     endDrain() {
@@ -128,6 +154,7 @@ export class SessionRegistry {
             signal?.throwIfAborted();
             await this.join([...this.entries.keys()].map(id => this.cancelViews(id)));
             await this.join([...this.opening.values(), ...this.closes.values(), ...this.lifecycleWriters], undefined, true);
+            await this.hostWorkers.settle();
             for (const entry of this.entries.values()) {
                 await entry.host?.settle();
                 await entry.cancelling;
@@ -175,20 +202,7 @@ export class SessionRegistry {
         const owner = this.options.store.sessionMetadata(parent);
         const root = this.require(owner.root).binding;
         const manager = worker.sessionManager;
-        const file = manager.getSessionFile();
-        if (!file || this.list().some(row => row.id === manager.getSessionId()))
-            throw registryError('invalid_request', 'Worker transcript must have a fresh identity.');
-        const path = this.options.owner.assertOwnsPath(file);
-        if (!pathInside(root.resources.sessionDir, path))
-            throw registryError('forbidden', 'Worker transcript is outside the root session directory.');
-        const workspace = this.options.owner.assertOwnsPath(worker.runtime.cwd);
-        if (!(root.resources.workerRoots ?? []).some(directory => pathInside(directory, workspace))) {
-            throw registryError('forbidden', 'Worker workspace is outside managed staging storage.');
-        }
-        const tools = new Set(['read', 'ls', 'grep', 'edit', 'write', ...(worker.customTools ?? []).map(tool => tool.name)]);
-        if (!worker.allowedTools.length || worker.allowedTools.some(name => !tools.has(name) || name === 'bash')) {
-            throw registryError('forbidden', 'Worker tools exceed the staged-artifact policy.');
-        }
+        const { path } = assertStagedWorker(this.options.owner, root.resources, worker, id => this.hostWorkers.owns(id) || this.list().some(row => row.id === id));
         const key = randomUUID();
         const opening = this.open({ cwd: manager.getCwd(), sessionDir: dirname(path), target: { kind: 'resume', sessionFile: path },
             parentSessionId: parent, rootSessionId: owner.root, policy: this.getPolicy(parent),
@@ -201,7 +215,12 @@ export class SessionRegistry {
             this.opening.delete(key);
         }
     }
+    openHostWorker(worker) { return this.hostWorkers.open(worker); }
+    hostWorkSignal() { this.assertHostWork(); return this.hostWorkers.signal; }
+    closeHostWorker(id) { return this.hostWorkers.close(id); }
     async runWorker(id, operation) {
+        if (this.hostWorkers.owns(id))
+            return this.hostWorkers.run(id, operation);
         this.assertNewWork();
         this.assertDispatch(id);
         const entry = this.require(id);
@@ -290,7 +309,7 @@ export class SessionRegistry {
         const current = this.options.store.sessionMetadatas();
         const ids = new Set(current.map(session => session.id));
         const paths = new Set(current.map(session => session.piPath));
-        return rows.filter(row => !ids.has(row.id) && !paths.has(row.path) && (cwd === undefined || row.cwd === cwd));
+        return rows.filter(row => !ids.has(row.id) && !this.hostWorkers.owns(row.id) && !paths.has(row.path) && (cwd === undefined || row.cwd === cwd));
     }
     legacySummary(row) { return this.legacy.summary(row); }
     /** Reads the titles of listed pre-daemon transcripts, newest first, so the first listing rarely waits for them. */
@@ -1002,6 +1021,8 @@ export class SessionRegistry {
     }
     close(id) {
         this.options.owner.assertCurrent();
+        if (this.hostWorkers.owns(id))
+            return this.closeHostWorker(id);
         const stored = this.options.store.sessionMetadata(id);
         const pending = this.closes.get(id);
         if (pending)
@@ -1060,6 +1081,7 @@ export class SessionRegistry {
         }
     }
     async shutdown(options = {}) {
+        this.options.onShutdown?.();
         if (options.interrupt)
             for (const row of this.list()) {
                 if (row.state === 'open' && ['running', 'waiting', 'cancelling'].includes(row.run.state) && row.run.id)
@@ -1069,6 +1091,7 @@ export class SessionRegistry {
         if (this.failure) {
             await shutdownStep('registry-fenced', async () => { await this.failureSettlement; throw new Error('Registry is fenced; verify settlement before releasing ownership.'); });
         }
+        const hostWorkers = shutdownStep('session-dispose', () => this.hostWorkers.shutdown());
         const cancellations = [...this.entries].map(([id, entry]) => {
             if (!options.interrupt)
                 return shutdownStep('session-cancel-views', () => this.cancelViews(id), id);
@@ -1086,7 +1109,7 @@ export class SessionRegistry {
             if (!options.interrupt || this.failure)
                 throw error;
         });
-        await this.join([...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], undefined, true))]);
         if (this.failure)
             await shutdownStep('registry-fenced', async () => { await this.failureSettlement; throw this.failure; });
         if (options.interrupt) {
@@ -1239,7 +1262,7 @@ export class SessionRegistry {
             } };
         try {
             const { execution = restored?.execution, ...sessionRequest } = request;
-            binding = await this.runtimeOpening.run({}, () => this.options.lifecycle.openSession({ ...sessionRequest, resources, ownership, policy: initialPolicy, services,
+            binding = await this.runtimeOpening.run(request.worker ? { workerSession: request.worker.sessionManager.getSessionId() } : {}, () => this.options.lifecycle.openSession({ ...sessionRequest, resources, ownership, policy: initialPolicy, services,
                 ...(execution ? { execution: { ...(execution.request.label === undefined ? {} : { label: execution.request.label }) } } : {}),
             }));
             this.assertAdmission();
@@ -1292,7 +1315,7 @@ export class SessionRegistry {
             const path = this.options.owner.assertOwnsPath(actualPath);
             if (restored && (binding.sessionId !== restored.id || path !== restored.piPath || binding.rootSessionId !== restored.root))
                 throw new Error('Restored session identity changed.');
-            if (this.entries.has(binding.sessionId) || (this.pathClaims.has(path) && claim !== path))
+            if (this.entries.has(binding.sessionId) || this.hostWorkers.owns(binding.sessionId) || (this.pathClaims.has(path) && claim !== path))
                 throw new Error('Session already has a live writer.');
             if (claim && claim !== path)
                 this.pathClaims.delete(claim);
@@ -1686,6 +1709,7 @@ export class SessionRegistry {
         this.diagnostic({ scope: 'registry', error });
         this.failure = error;
         this.processes.sealAll();
+        this.hostWorkers.interrupt();
         for (const entry of this.entries.values()) {
             entry.runAbort?.abort();
             entry.projection.dispose();
@@ -1698,6 +1722,7 @@ export class SessionRegistry {
             await this.failureSettlement;
         else {
             const failures = [];
+            await this.join([this.hostWorkers.settle()], failures);
             do {
                 await this.join(this.pendingWriters(), failures);
             } while (this.hasPendingWriters());
@@ -1710,8 +1735,8 @@ export class SessionRegistry {
     }
     async settleAfterLoss() {
         const failures = [];
-        const roots = new Set([...this.entries.values()].map(entry => entry.binding.rootSessionId).concat([...this.processes.liveRoots()]));
-        const pending = [...this.opening.values(), ...this.closes.values(), ...[...roots].map(root => this.processes.settle(root, true))];
+        const roots = new Set([...this.entries.values()].map(entry => entry.binding.rootSessionId).concat(this.hostWorkers.roots(), [...this.processes.liveRoots()]));
+        const pending = [this.hostWorkers.settle(), ...this.opening.values(), ...this.closes.values(), ...[...roots].map(root => this.processes.settle(root, true))];
         for (const entry of this.entries.values()) {
             pending.push(entry.binding.runtime.session.abort(), ...(entry.disposing ? [entry.disposing] : []), ...(entry.cancelling ? [entry.cancelling] : []), ...(entry.projectionCancellation ? [entry.projectionCancellation] : []));
             if (entry.host)