kiokuko-dsh 0.2.21 → 0.2.23

package/dist/dsh/owned-execution.js

@@ -1,3 +1,5 @@
+import { ManagedOperationJournal } from './managed-operation-journal.js';
+import { runManagedOperation, currentManagedOperation, observeManagedResult, mirrorManagedParent, managedAdmissionDenied, ManagedDispatchDenied } from './managed-operation-runner.js';
 import { renameSync, openSync, closeSync, writeFileSync, fsyncSync, fchmodSync, rmSync, statSync } from 'node:fs';
 import { assertProtocolRoute, reserveProtocolFile, applyProtocolFile, withProtocolEffect, reserveProtocolTest, authorizeProtocolTest, finishProtocolTest } from './guardrail/service.js';
 import { runProtocolTests } from './guardrail/engine.js';
@@ -64,6 +66,7 @@ export class OwnedExecutionService {
     host;
     #operations = new Map();
     #legacyRuns = new Set();
+    #managedCalls = new Map();
     constructor(host) {
         this.host = host;
         const services = runtimeServices.get(host.runtime) ?? new Set();
@@ -272,7 +275,7 @@ export class OwnedExecutionService {
     }
     async approve(identity, detail, signal) {
         if (!await this.host.confirm?.(identity, detail, signal))
-            throw new Error('Destructive operation was not approved');
+            throw new ManagedDispatchDenied('Destructive operation was not approved');
         signal.throwIfAborted();
     }
     async reply(receipt, value = {}, replayed = false) {
@@ -284,6 +287,47 @@ export class OwnedExecutionService {
         return { ...value, receipt, ...(replayed ? { replayed: true } : {}), status: { work: receipt.state, verification: receipt.verification ?? 'unknown', receiptPersistence: receipt.persistence, memoryStorage } };
     }
     async execute(name, raw, execution) {
+        if (!['kioku_exec', 'kioku_write', 'kioku_edit', 'kioku_remove'].includes(name))
+            return this.executeManaged(name, raw, execution);
+        const parentOperation = currentManagedOperation();
+        const identity = this.current(execution);
+        const database = (fn) => this.host.runtime.withDatabase(fn);
+        const originalRef = canonicalContentHash({ session: identity.sessionId, call: execution.callId });
+        const request = { name, raw, cwd: identity.repositoryRoot, runId: identity.runId, generation: identity.generation, environment: { ...process.env }, runtime: process.version };
+        const digest = canonicalContentHash(request);
+        const pending = this.#managedCalls.get(originalRef);
+        if (pending) {
+            if (pending.digest !== digest)
+                throw new Error('Operation ID reused with changed input');
+            return pending.result;
+        }
+        const result = (async () => {
+            const previous = await database(db => new ManagedOperationJournal(db).lookupOriginalOperation(originalRef));
+            if (previous) {
+                await database(db => new ManagedOperationJournal(db).claim(previous.operationId, request));
+                const saved = await database(db => db.prepare('SELECT operation_id FROM dsh_owned_operations WHERE operation_id=?').get(originalRef));
+                if (saved)
+                    return { ...await this.result(identity, { operationId: originalRef, cancel: false }), replayed: true };
+                return { state: previous.state, operationId: previous.operationId, replayed: true, executed: false };
+            }
+            const scope = await database(db => new ManagedOperationJournal(db).createScope({ sessionId: identity.sessionId,
+                requestId: execution.callId, parentId: parentOperation?.operationId ?? execution.callId, runtimeIdentity: `owned:${identity.generation}` }));
+            try {
+                return await runManagedOperation({ database, scopeId: scope.scopeId, direct: true, nested: true, ...(parentOperation ? { parentOperation } : {}) }, { route: 'owned', kind: name === 'kioku_exec' ? 'process' : 'file', request, originalRef }, () => this.executeManaged(name, raw, execution));
+            }
+            finally {
+                await database(db => new ManagedOperationJournal(db).seal(scope.scopeId));
+            }
+        })();
+        this.#managedCalls.set(originalRef, { digest, result });
+        try {
+            return await result;
+        }
+        finally {
+            this.#managedCalls.delete(originalRef);
+        }
+    }
+    async executeManaged(name, raw, execution) {
         const identity = (name === 'kioku_read' || name === 'kioku_result') && this.host.resolveRead
             ? await this.host.resolveRead(execution).then(value => {
                 execution.signal.throwIfAborted();
@@ -304,7 +348,21 @@ export class OwnedExecutionService {
         if (name === 'kioku_result')
             return this.result(identity, resultInput.parse(raw));
         const input = name === 'kioku_exec' ? commandInput.parse(raw) : fileInput.parse(raw);
-        const lease = name === 'kioku_read' ? await this.captureAuthority(execution, identity).catch(() => undefined) : await this.captureAuthority(execution, identity);
+        const lease = name === 'kioku_read' ? await this.captureAuthority(execution, identity).catch(() => undefined) : await this.captureAuthority(execution, identity).catch(managedAdmissionDenied);
+        const journalOperation = currentManagedOperation();
+        if (lease && journalOperation)
+            await journalOperation.database(db => new ManagedOperationJournal(db).bindOperation(journalOperation.operationId, {
+                binding: { taskId: lease.taskId, workerGeneration: identity.generation, leaseAuthorityGeneration: lease.generation, leaseRevision: lease.revision },
+                runtimeIdentity: `owned:${identity.generation}`,
+            }));
+        if (lease && journalOperation?.parentOperation)
+            await journalOperation.parentOperation.database(db => {
+                const journal = new ManagedOperationJournal(db), parent = journal.readOperation(journalOperation.parentOperation.operationId);
+                journal.bindOperation(parent.operationId, {
+                    binding: { taskId: lease.taskId, workerGeneration: parent.binding?.workerGeneration ?? identity.generation, leaseAuthorityGeneration: lease.generation, leaseRevision: lease.revision },
+                    runtimeIdentity: parent.runtimeIdentity,
+                });
+            });
         if (name !== 'kioku_read') {
             try {
                 await this.host.runtime.withDatabase(db => {
@@ -324,11 +382,11 @@ export class OwnedExecutionService {
             }
             catch (error) {
                 if (error instanceof KiokukoError || !this.#legacyRuns.has(identity.runId))
-                    throw error;
+                    managedAdmissionDenied(error);
             }
         }
         if (name !== 'kioku_read' && this.host.planActive?.(identity.agent))
-            throw new Error('Plan is active. An explicit human implementation instruction or plan approval must exit it first.');
+            managedAdmissionDenied(new Error('Plan is active. An explicit human implementation instruction or plan approval must exit it first.'));
         // Native call identity survives a generation change. Rebinding a replay to
         // a new run/generation must conflict rather than repeat its side effects.
         const operationId = canonicalContentHash({ session: identity.sessionId, call: execution.callId });
@@ -374,6 +432,9 @@ export class OwnedExecutionService {
                 throw new Error('Operation ID reused with changed input');
             return concurrent.done ?? { receipt: concurrent.receipt };
         }
+        const managed = currentManagedOperation();
+        if (managed)
+            await managed.database(db => new ManagedOperationJournal(db).attachOriginalRef(managed.operationId, operationId));
         this.#operations.set(operationId, operation);
         const signal = AbortSignal.any([execution.signal, controller.signal]);
         const journal = this.journal(identity.repositoryRoot);
@@ -409,12 +470,28 @@ export class OwnedExecutionService {
                 receipt.state = 'completed';
             }
             catch (error) {
+                if (error instanceof ManagedDispatchDenied && managed) {
+                    await managed.database(db => {
+                        const journal = new ManagedOperationJournal(db), prior = journal.readOperation(managed.operationId);
+                        if (prior.state === 'unknown')
+                            journal.reconcile(managed.operationId, { state: 'denied', receiptRef: canonicalContentHash(receipt), cause: 'permission-denied' });
+                        else
+                            journal.transition(managed.operationId, { state: 'denied', cause: 'permission-denied' });
+                    });
+                    await mirrorManagedParent(managed);
+                }
+                ;
                 receipt.state = 'unknown';
                 receipt.error = safeText(error instanceof Error ? error.message : String(error));
                 operation.value = { error: receipt.error };
                 receipt.verification = 'unknown';
             }
             await this.persist(receipt, digest);
+            if (managed) {
+                await observeManagedResult(managed, { ...operation.value, receipt });
+                if (managed.direct)
+                    await managed.database(db => new ManagedOperationJournal(db).seal(managed.scopeId));
+            }
             if (name === 'kioku_exec') {
                 try {
                     await finishProtocolTest(action => this.host.runtime.withDatabase(action), receipt);
@@ -427,134 +504,152 @@ export class OwnedExecutionService {
                 }
             }
             await this.host.runtime.withDatabase(db => withImmediateTransaction(db, () => recordOwnedCompletionObservation(db, receipt))).catch(() => { });
-            return this.reply(receipt, operation.value);
+            const result = await this.reply(receipt, operation.value);
+            if (managed && name === 'kioku_exec' && input.background)
+                await observeManagedResult(managed, result);
+            return result;
         })();
         operation.done = done;
-        if (name === 'kioku_exec' && input.background)
-            return this.reply(receipt);
+        if (name === 'kioku_exec' && input.background) {
+            const value = await this.reply(receipt);
+            if (managed)
+                await observeManagedResult(managed, value);
+            return value;
+        }
         return done;
     }
     async file(identity, receipt, name, input, signal, lease) {
-        const target = path.resolve(identity.repositoryRoot, input.path);
-        // Resolve the parent as well as existing target to identify symlink exits.
-        let actual;
+        let effectAttempted = false;
         try {
-            actual = await realpath(target);
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT')
-                throw error;
-            let parent = path.dirname(target), suffix = path.basename(target);
-            for (;;) {
-                try {
-                    actual = path.join(await realpath(parent), suffix);
-                    break;
-                }
-                catch (cause) {
-                    if (cause.code !== 'ENOENT')
-                        throw cause;
-                    suffix = path.join(path.basename(parent), suffix);
-                    parent = path.dirname(parent);
-                }
+            const target = path.resolve(identity.repositoryRoot, input.path);
+            // Resolve the parent as well as existing target to identify symlink exits.
+            let actual;
+            try {
+                actual = await realpath(target);
             }
-        }
-        const before = await this.snapshot(actual);
-        receipt.targets = [{ path: actual, before, after: before }];
-        await this.persist(receipt, this.#operations.get(receipt.operationId).digest);
-        if (input.expectedHash !== undefined && input.expectedHash !== before)
-            throw new Error('File changed before the operation');
-        if (name === 'kioku_read') {
-            const content = await readFile(actual, 'utf8'), observedHash = hash(content);
-            if (lease && observedHash === before) {
-                try {
-                    await this.checkAuthority(identity, lease);
-                    receipt.authority = 'current';
-                    receipt.verification = 'passed';
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+                let parent = path.dirname(target), suffix = path.basename(target);
+                for (;;) {
+                    try {
+                        actual = path.join(await realpath(parent), suffix);
+                        break;
+                    }
+                    catch (cause) {
+                        if (cause.code !== 'ENOENT')
+                            throw cause;
+                        suffix = path.join(path.basename(parent), suffix);
+                        parent = path.dirname(parent);
+                    }
                 }
-                catch {
-                    receipt.authority = 'stale';
+            }
+            const before = await this.snapshot(actual);
+            receipt.targets = [{ path: actual, before, after: before }];
+            await this.persist(receipt, this.#operations.get(receipt.operationId).digest);
+            if (input.expectedHash !== undefined && input.expectedHash !== before)
+                throw new Error('File changed before the operation');
+            if (name === 'kioku_read') {
+                const content = await readFile(actual, 'utf8'), observedHash = hash(content);
+                if (lease && observedHash === before) {
+                    try {
+                        await this.checkAuthority(identity, lease);
+                        receipt.authority = 'current';
+                        receipt.verification = 'passed';
+                    }
+                    catch {
+                        receipt.authority = 'stale';
+                    }
                 }
+                return { content, hash: observedHash };
             }
-            return { content, hash: observedHash };
-        }
-        const disposable = await this.disposable(identity, actual);
-        const database = before !== null && (/\.(?:db|sqlite3?)(?:-(?:wal|shm|journal))?$/iu.test(actual) || (await readFile(actual)).subarray(0, 16).equals(Buffer.from('SQLite format 3\0')));
-        if (!disposable && (!within(identity.repositoryRoot, actual) || name === 'kioku_remove' || database))
-            await this.approve(identity, `Operation: ${name}\nTarget: ${actual}\nCurrent SHA256: ${before}`, signal);
-        signal.throwIfAborted();
-        if (await this.snapshot(actual) !== before)
-            throw new Error('File changed during operation approval');
-        const protocol = await this.host.runtime.withDatabase(db => reserveProtocolFile(db, lease, receipt.operationId, name, actual, this.#operations.get(receipt.operationId).digest));
-        if (name === 'kioku_remove') {
-            await this.checkAuthority(identity, lease);
-            await rm(actual, { recursive: false, force: false });
-        }
-        else {
-            const existing = before === null ? '' : await readFile(actual, 'utf8');
-            let content = input.content;
-            if (name === 'kioku_edit') {
-                if (!input.oldText || input.newText === undefined || existing.split(input.oldText).length !== 2)
-                    throw new Error('Edit requires exactly one matching oldText');
-                content = existing.replace(input.oldText, input.newText);
+            const disposable = await this.disposable(identity, actual);
+            const database = before !== null && (/\.(?:db|sqlite3?)(?:-(?:wal|shm|journal))?$/iu.test(actual) || (await readFile(actual)).subarray(0, 16).equals(Buffer.from('SQLite format 3\0')));
+            if (!disposable && (!within(identity.repositoryRoot, actual) || name === 'kioku_remove' || database))
+                await this.approve(identity, `Operation: ${name}\nTarget: ${actual}\nCurrent SHA256: ${before}`, signal);
+            signal.throwIfAborted();
+            if (await this.snapshot(actual) !== before)
+                throw new Error('File changed during operation approval');
+            const protocol = await this.host.runtime.withDatabase(db => reserveProtocolFile(db, lease, receipt.operationId, name, actual, this.#operations.get(receipt.operationId).digest));
+            if (name === 'kioku_remove') {
+                await this.checkAuthority(identity, lease);
+                effectAttempted = true;
+                await rm(actual, { recursive: false, force: false });
             }
-            if (content === undefined)
-                throw new Error('Write content is required');
-            if (protocol && Buffer.byteLength(content) > 8 * 1024 * 1024)
-                throw new Error('Protocol file byte limit');
-            if (protocol) {
-                // Existing parents were bound at enrollment. Stage and commit inside the same final
-                // synchronous authority boundary; cancellation committed before it prevents all writes.
-                await this.host.runtime.withDatabase(db => applyProtocolFile(db, lease, receipt.operationId, signal, () => {
-                    const mode = before === null ? 0o644 : statSync(actual).mode & 0o7777;
+            else {
+                const existing = before === null ? '' : await readFile(actual, 'utf8');
+                let content = input.content;
+                if (name === 'kioku_edit') {
+                    if (!input.oldText || input.newText === undefined || existing.split(input.oldText).length !== 2)
+                        throw new Error('Edit requires exactly one matching oldText');
+                    content = existing.replace(input.oldText, input.newText);
+                }
+                if (content === undefined)
+                    throw new Error('Write content is required');
+                if (protocol && Buffer.byteLength(content) > 8 * 1024 * 1024)
+                    throw new Error('Protocol file byte limit');
+                if (protocol) {
+                    // Existing parents were bound at enrollment. Stage and commit inside the same final
+                    // synchronous authority boundary; cancellation committed before it prevents all writes.
+                    await this.host.runtime.withDatabase(db => applyProtocolFile(db, lease, receipt.operationId, signal, () => {
+                        effectAttempted = true;
+                        const mode = before === null ? 0o644 : statSync(actual).mode & 0o7777;
+                        const temporary = path.join(path.dirname(actual), `.kioku-${randomUUID()}.tmp`);
+                        try {
+                            const file = openSync(temporary, 'wx', mode);
+                            try {
+                                fchmodSync(file, mode);
+                                writeFileSync(file, content);
+                                fsyncSync(file);
+                            }
+                            finally {
+                                closeSync(file);
+                            }
+                            renameSync(temporary, actual);
+                        }
+                        finally {
+                            rmSync(temporary, { force: true });
+                        }
+                    }));
+                }
+                else {
+                    await this.checkAuthority(identity, lease);
+                    effectAttempted = true;
+                    await mkdir(path.dirname(actual), { recursive: true });
+                    const mode = before === null ? 0o644 : (await stat(actual)).mode;
                     const temporary = path.join(path.dirname(actual), `.kioku-${randomUUID()}.tmp`);
                     try {
-                        const file = openSync(temporary, 'wx', mode);
+                        const file = await open(temporary, 'wx', mode);
                         try {
-                            fchmodSync(file, mode);
-                            writeFileSync(file, content);
-                            fsyncSync(file);
+                            await file.chmod(mode & 0o7777);
+                            await file.writeFile(content);
+                            await file.sync();
                         }
                         finally {
-                            closeSync(file);
+                            await file.close();
                         }
-                        renameSync(temporary, actual);
+                        signal.throwIfAborted();
+                        await this.checkAuthority(identity, lease);
+                        await rename(temporary, actual);
                     }
                     finally {
-                        rmSync(temporary, { force: true });
+                        await rm(temporary, { force: true });
                     }
-                }));
-            }
-            else {
-                await this.checkAuthority(identity, lease);
-                await mkdir(path.dirname(actual), { recursive: true });
-                const mode = before === null ? 0o644 : (await stat(actual)).mode;
-                const temporary = path.join(path.dirname(actual), `.kioku-${randomUUID()}.tmp`);
-                try {
-                    const file = await open(temporary, 'wx', mode);
-                    try {
-                        await file.chmod(mode & 0o7777);
-                        await file.writeFile(content);
-                        await file.sync();
-                    }
-                    finally {
-                        await file.close();
-                    }
-                    signal.throwIfAborted();
-                    await this.checkAuthority(identity, lease);
-                    await rename(temporary, actual);
-                }
-                finally {
-                    await rm(temporary, { force: true });
                 }
+                if (await this.snapshot(actual) !== hash(content))
+                    throw new Error('Written content differs from requested content');
             }
-            if (await this.snapshot(actual) !== hash(content))
-                throw new Error('Written content differs from requested content');
+            receipt.targets[0].after = await this.snapshot(actual);
+            await this.checkAuthority(identity, lease);
+            receipt.verification = 'passed';
+            receipt.authority = 'current';
+            return { applied: true };
+        }
+        catch (error) {
+            if (!effectAttempted)
+                throw new ManagedDispatchDenied(error instanceof Error ? error.message : 'File admission denied');
+            throw error;
         }
-        receipt.targets[0].after = await this.snapshot(actual);
-        await this.checkAuthority(identity, lease);
-        receipt.verification = 'passed';
-        receipt.authority = 'current';
-        return { applied: true };
     }
     async disposable(identity, target) {
         if (within(identity.repositoryRoot, target))
@@ -589,6 +684,16 @@ export class OwnedExecutionService {
             if (input.destructiveTargets?.length || durableSql || removals?.length && !disposableRemoval || !disposableRemoval && /(?:^|[;&|]\s*)(?:rm\s|git\s+(?:reset\s+--hard|clean\s+-[a-z]*f)|(?:drop\s+(?:table|database)|truncate\s+table)\b)/iu.test(input.command))
                 await this.approve(identity, `Command: ${safeText(input.command)}\nCwd: ${receipt.cwd}\nTargets: ${input.destructiveTargets?.join(', ') ?? 'see command'}`, signal);
             const protocol = await this.host.runtime.withDatabase(db => reserveProtocolTest(db, lease, receipt.operationId, input.command, receipt.cwd));
+            const managed = currentManagedOperation();
+            if (protocol && managed) {
+                if (!managed.direct)
+                    throw new Error('Protocol proof requires its direct owned operation scope');
+                await managed.database(db => new ManagedOperationJournal(db).bindOperation(managed.operationId, {
+                    binding: { taskId: lease.taskId, unitId: protocol.recipe.unitId, workerGeneration: identity.generation,
+                        protocolBindGeneration: protocol.generation, leaseAuthorityGeneration: lease.generation, leaseRevision: lease.revision },
+                    runtimeIdentity: protocol.runtimeDigest, bindScope: true,
+                }));
+            }
             return await this.evidence(identity, receipt, input.command, lease, async () => {
                 signal.throwIfAborted();
                 await this.checkAuthority(identity, lease);
@@ -622,8 +727,10 @@ export class OwnedExecutionService {
         catch (error) {
             // Before the only launch boundary, cancellation proves that no child ran.
             // Once launch was attempted, preserve unknown outcomes and reconcile them.
-            if (!signal.aborted || launchAttempted)
+            if (launchAttempted)
                 throw error;
+            if (!signal.aborted)
+                throw new ManagedDispatchDenied(error instanceof Error ? error.message : 'Process admission denied');
             receipt.processStarted = false;
             receipt.processStopped = true;
             receipt.cancelled = true;
@@ -634,6 +741,29 @@ export class OwnedExecutionService {
             return { exitCode: null, output: '' };
         }
     }
+    async reconcileManagedReceipt(receipt) {
+        if (receipt.state !== 'completed' || receipt.kind === 'kioku_exec' && receipt.processStopped !== true)
+            return;
+        const database = (fn) => this.host.runtime.withDatabase(fn);
+        const context = await database(db => {
+            const journal = new ManagedOperationJournal(db), operation = journal.lookupOriginalOperation(receipt.operationId);
+            if (!operation)
+                return undefined; // Legacy owned originals remain readable.
+            const saved = db.prepare('SELECT receipt_json FROM dsh_owned_operations WHERE operation_id=? AND run_id=? AND session_id=?')
+                .get(receipt.operationId, receipt.runId, receipt.sessionId);
+            if (!saved || canonicalContentHash(JSON.parse(saved.receipt_json)) !== canonicalContentHash(receipt))
+                throw new Error('Owned original is not durably verified');
+            const scope = journal.readScope(operation.scopeId);
+            if (scope.sessionId !== receipt.sessionId || operation.binding?.taskId !== receipt.runId)
+                throw new Error('Managed original owner mismatch');
+            const parentRow = db.prepare('SELECT operation_json FROM dsh_managed_operations WHERE operation_id=?').get(scope.parentId);
+            const parent = parentRow ? JSON.parse(parentRow.operation_json) : undefined;
+            return { database, scopeId: operation.scopeId, operationId: operation.operationId, kind: operation.kind,
+                ...(parent ? { parentOperation: { database, scopeId: parent.scopeId, operationId: parent.operationId, kind: parent.kind } } : {}) };
+        });
+        if (context)
+            await observeManagedResult(context, { receipt, exitCode: receipt.exitCode });
+    }
     async result(identity, input) {
         const operation = this.#operations.get(input.operationId);
         if (operation) {
@@ -644,6 +774,7 @@ export class OwnedExecutionService {
             if (operation.receipt.state === 'started')
                 return this.reply(operation.receipt);
             await this.persist(operation.receipt, operation.digest);
+            await this.reconcileManagedReceipt(operation.receipt);
             return this.reply(operation.receipt, operation.value);
         }
         const saved = await this.host.runtime.withDatabase(db => db.prepare('SELECT receipt_json FROM dsh_owned_operations WHERE operation_id=? AND run_id=? AND session_id=?')
@@ -654,6 +785,7 @@ export class OwnedExecutionService {
             throw new Error('No result for this run/session');
         if (journal)
             await this.persist(receipt, journal.digest);
+        await this.reconcileManagedReceipt(receipt);
         return this.reply(receipt.state === 'started' ? { ...receipt, state: 'unknown', error: 'Host restarted before final process result was saved; effects will not be replayed.' } : receipt);
     }
     async stopTask(identity, signal) {