kiokuko-dsh 0.2.39 → 0.2.41

package/dist/dsh/lisp/manager.js

@@ -11,10 +11,8 @@ import { z } from 'zod';
 import { EvalInput, LispError, digest, fail, failure, identifier } from './contracts.js';
 import { LispStore } from './store.js';
 import { sessionCodingWorkflow } from '../coding-workflow/store.js';
-import { LispWorker } from './worker.js';
-import { prepareLayout } from './sandbox.js';
+import { LispSupervisor } from './supervision.js';
 import { verifyLispVendor } from './integrity.js';
-import { CompiledLispCache } from './compiled-cache.js';
 import { backupUsage, checkedBytes, snapshot, under } from './files.js';
 import { describeVerifiers } from './ci.js';
 import { PackageRequest } from './packages.js';
@@ -68,7 +66,7 @@ export class LispManager {
     #config;
     #store;
     #library;
-    #compiled;
+    #supervisor;
     #taskTools;
     #hot;
     #closed = false;
@@ -76,8 +74,8 @@ export class LispManager {
     #claims = new Set();
     #ownsSessions = false;
     #artifactReserved = 0;
-    #admissionQueue = Promise.resolve();
     #inflight = new Map();
+    #sessionWorkerAdmissions = new Map();
     constructor(options) {
         this.options = options;
         this.#config = options.config;
@@ -87,7 +85,7 @@ export class LispManager {
             authorizeEffect: async (owner) => { await this.taskAuthority.authorizeEffect(owner); },
             ...(options.config.executionMode === 'development' && options.toolCall ? { execute: async (owner, name, args, signal, callId) => options.toolCall(owner, name, args, signal, callId, await this.taskAuthority.authorizeEffect(owner, 'owned')) } : {}) });
         this.#library = options.library ?? fileURLToPath(new URL('../../../lisp/', import.meta.url));
-        this.#compiled = new CompiledLispCache(join(options.dataRoot, 'compiled'), this.#library, this.#config);
+        this.#supervisor = new LispSupervisor(this.#config, options.dataRoot, this.#library);
         this.#taskTools = new TaskToolCatalog(this.#store);
         this.#hot = new HotToolRuntime({ store: this.#store, ...(options.questions ? { questions: options.questions } : {}),
             authorizeEffect: async (owner) => { await this.taskAuthority.authorizeEffect(owner); },
@@ -189,9 +187,52 @@ export class LispManager {
         signal?.throwIfAborted();
         const state = this.entry(owner);
         state.hostBusy = hostBusy;
-        await this.startWorker(state);
+        await this.startWorker(state, signal);
         return this.status(owner);
     }
+    /** A routed session keeps its own heap. Project effects still cross the host
+     * boundary; its scratch runtime never takes the standalone repository lease. */
+    enableSessionWorker(owner, hostBusy = false, signal) {
+        const key = JSON.stringify([owner.sessionId, owner.agentId, owner.root]);
+        const pending = this.#sessionWorkerAdmissions.get(key);
+        if (pending)
+            return pending;
+        const admission = this.admitSessionWorker(owner, hostBusy, signal)
+            .finally(() => this.#sessionWorkerAdmissions.delete(key));
+        this.#sessionWorkerAdmissions.set(key, admission);
+        return admission;
+    }
+    async admitSessionWorker(owner, hostBusy, signal) {
+        await this.authorizeCodingTask(owner);
+        signal?.throwIfAborted();
+        if (!this.#config.enabled || this.#closed)
+            fail('LISP_DISABLED', 'Lisp is unavailable for this worker session.');
+        if (await realpath(owner.root) !== owner.root)
+            fail('SCOPE_CONFLICT', 'Worker workspace identity changed.');
+        if (!await this.isSessionWorker(owner)) {
+            if ([...this.#agents.values()].some(state => state.owner.sessionId === owner.sessionId
+                && (state.admission || state.active.size || state.worker && !state.worker.stopped))
+                || await this.#store.hasPending(owner.sessionId))
+                fail('WORKER_MODE_BUSY', 'Settle the current Lisp operations before admitting a session worker.');
+            await this.#store.enable(owner);
+            this.enabled.set(owner.sessionId, owner.root);
+            const epoch = (await this.#store.session(owner.sessionId)).epoch;
+            const modeOwner = { ...owner, agentId: '__session__' }, id = `session-worker-${epoch}`;
+            await this.#store.reserve(modeOwner, id, 'session_worker', digest({ root: owner.root, epoch }), 'host', { root: owner.root, epoch });
+            await this.#store.transition(modeOwner, id, ['RUNNING'], 'SUCCEEDED', { mode: 'session-worker' });
+        }
+        signal?.throwIfAborted();
+        this.setAgentBusy(owner, hostBusy);
+        return this.prepare(owner, signal);
+    }
+    async isSessionWorker(owner) {
+        const session = await this.#store.session(owner.sessionId);
+        if (!session?.enabled || session.root_path !== owner.root)
+            return false;
+        const record = await this.#store.get({ ...owner, agentId: '__session__' }, `session-worker-${session.epoch}`);
+        return record?.kind === 'session_worker' && record.state === 'SUCCEEDED'
+            && record.digest === digest({ root: owner.root, epoch: session.epoch });
+    }
     async enableTask(owner, signal) {
         await this.authorizeCodingTask(owner);
         signal?.throwIfAborted();
@@ -218,6 +259,8 @@ export class LispManager {
         return { ok: true, state: 'TASK_READY' };
     }
     async isTaskMode(owner) {
+        if (await this.isSessionWorker(owner))
+            return false;
         const epoch = (await this.#store.session(owner.sessionId))?.epoch;
         if (!epoch)
             return false;
@@ -232,7 +275,7 @@ export class LispManager {
             for (const abort of state.active)
                 abort.abort(new LispError('CANCELLED', '作業用 Lisp の処理を取り消しました。'));
             try {
-                await state.worker?.stop();
+                await this.#supervisor.stop(state.worker);
                 // A task can still be preparing its compiled runtime without a worker.
                 // Keep its admission visible until its own cleanup has settled.
                 await state.taskSettlement;
@@ -253,12 +296,11 @@ export class LispManager {
     }
     /** A managed call uses the same admission queue and OS sandbox as legacy Lisp. */
     async runTask(owner, code, input, signal, mode = 'call') {
-        await this.authorizeCodingTask(owner);
-        const repositoryRoot = detectRepositoryRoot({ cwd: owner.root, allowDirectory: true }).root;
-        const resident = [...this.#agents.values()].find(s => s.worker && !s.worker.stopped && s.worker.repositoryRoot === repositoryRoot);
-        if (resident) {
-            if (mode === 'eval' || resident !== this.#agents.get(JSON.stringify([owner.sessionId, owner.agentId])) || resident.owner.root !== owner.root)
-                fail('REPOSITORY_IN_USE', 'このリポジトリの Lisp は別の owner が使用中です。状態は保持し、別 SBCL を起動しません。');
+        await this.claimSession(owner);
+        const resident = this.#agents.get(JSON.stringify([owner.sessionId, owner.agentId]));
+        // Schemas do not make arbitrary Lisp pure. Only reuse this caller's already
+        // protected heap; other callers and development heaps get private scratch.
+        if (mode !== 'eval' && resident?.owner.root === owner.root && resident.worker?.layout.protected && resident.worker.config.executionMode === 'protected' && !resident.worker.stopped) {
             return this.runResidentTask(resident, code, input, signal, mode);
         }
         if ([...this.#agents.values()].some(s => s.owner.sessionId === owner.sessionId && s.state === 'STOP_UNCONFIRMED'))
@@ -278,37 +320,24 @@ export class LispManager {
         let worker;
         try {
             assertCurrent();
-            await this.reserveSlot(state);
-            const compiled = await this.#compiled.ensure(combined, () => { });
-            assertCurrent();
-            const base = await mkdtemp(join(this.options.dataRoot, 'w-'));
-            const layout = await prepareLayout(base, this.#library);
-            layout.compiled = compiled.path;
-            layout.workspace = owner.root;
-            layout.protected = this.#config.executionMode === 'protected';
-            worker = this.#config.executionMode === 'protected' ? new LispWorker(layout, this.#config, undefined, () => false) : new LispWorker(layout, this.#config, (method, args, context) => this.bridge(state, method, args, context));
-            state.worker = worker;
-            assertCurrent();
-            await worker.start();
-            assertCurrent();
-            if (this.#config.executionMode === 'protected') {
-                const canary = join(base, 'host-canary');
-                await writeFile(canary, 'protected', { mode: 0o600 });
-                const probe = await this.journalRequest(state, worker, 'eval', { inputs: [], code: `(let ((read-denied (handler-case (progn (with-open-file (s ${JSON.stringify(canary)}) (read-char s)) nil) (file-error () t))) (delete-denied (handler-case (progn (delete-file ${JSON.stringify(canary)}) nil) (file-error () t)))) (unless (and read-denied delete-denied) (error "ISOLATION_FAILED")) :protected)` }, this.#config.startupTimeoutMs, combined);
-                if (!probe.ok || await readFile(canary, 'utf8') !== 'protected')
-                    fail('ISOLATION_FAILED', 'OS によるファイル保護を確認できません。');
-            }
-            assertCurrent();
+            // Disposable computations share the master's admission and startup path,
+            // but receive neither a repository mount nor host RPC authority.
+            worker = await this.#supervisor.start(state, {
+                signal: combined, assertCurrent, executionMode: 'protected', rpcAllowed: () => false,
+                assigned: child => { state.worker = child; worker = child; },
+                inspect: (child, code) => this.journalRequest(state, child, 'eval', { inputs: [], code }, this.#config.startupTimeoutMs, combined, false),
+            });
+            const layout = worker.layout;
             state.state = 'EVALUATING';
             if (mode === 'compile') {
-                const checked = await this.journalRequest(state, worker, 'task-compile', { code }, this.#config.timeoutMs, combined);
+                const checked = await this.journalRequest(state, worker, 'task-compile', { code }, this.#config.timeoutMs, combined, false);
                 assertCurrent();
                 if (!checked.ok || checked.proposals.length)
                     fail('TASK_COMPILE_FAILED', String(checked.value).slice(0, 1000));
                 return { value: null, output: worker.output(), generation: worker.generation };
             }
             if (mode === 'eval') {
-                const evaluated = await this.journalRequest(state, worker, 'eval', { code, inputs: [] }, this.#config.timeoutMs, combined);
+                const evaluated = await this.journalRequest(state, worker, 'eval', { code, inputs: [] }, this.#config.timeoutMs, combined, false);
                 assertCurrent();
                 if (!evaluated.ok || evaluated.proposals.length)
                     fail('TASK_EVAL_FAILED', String(evaluated.value).slice(0, 1000));
@@ -322,7 +351,7 @@ export class LispManager {
             await writeFile(inputPath, encoded, { flag: 'wx', mode: 0o400 });
             assertCurrent();
             state.state = 'EVALUATING';
-            const response = await this.journalRequest(state, worker, 'task', { code, input: inputPath }, this.#config.timeoutMs, combined);
+            const response = await this.journalRequest(state, worker, 'task', { code, input: inputPath }, this.#config.timeoutMs, combined, false);
             if (!response.ok || response.proposals.length)
                 fail('TASK_EXECUTION_FAILED', String(response.value).slice(0, 1000));
             const result = await snapshot(layout.scratch, 'task-result.json', []);
@@ -336,7 +365,7 @@ export class LispManager {
             try {
                 if (worker) {
                     try {
-                        await worker.stop();
+                        await this.#supervisor.stop(worker);
                     }
                     catch (error) {
                         state.state = 'STOP_UNCONFIRMED';
@@ -413,7 +442,7 @@ export class LispManager {
                 state.state = 'READY';
         }
     }
-    async startWorker(state) {
+    async startWorker(state, signal) {
         await this.authorizeCodingTask(state.owner);
         if (state.admission)
             return state.admission;
@@ -424,48 +453,34 @@ export class LispManager {
         state.compilation = { state: 'checking' };
         const abort = new AbortController();
         state.active.add(abort);
+        const combined = signal ? AbortSignal.any([signal, abort.signal]) : abort.signal;
         const admission = (async () => {
             let worker;
             try {
-                await this.reserveSlot(state);
-                const compiled = await this.#compiled.ensure(abort.signal, status => { state.compilation = status; });
-                if (this.#closed || state.state !== 'PREFLIGHT' || abort.signal.aborted)
-                    fail('CANCELLED', '起動は取り消されています。');
-                const base = await mkdtemp(join(this.options.dataRoot, 'w-'));
-                const layout = await prepareLayout(base, this.#library);
-                layout.compiled = compiled.path;
-                layout.workspace = state.owner.root;
-                layout.protected = this.#config.executionMode === 'protected';
-                worker = new LispWorker(layout, this.#config, (method, args, context) => this.bridge(state, method, args, context), undefined, () => this.taskAuthority.bound(state.execution, async () => { await this.taskAuthority.authorizeEffect(state.owner, this.#config.executionMode === 'protected' ? 'protected' : 'direct'); }), (input, launch) => this.journalProtectedJob(state, input, launch));
-                state.worker = worker;
-                if (this.#closed || state.state !== 'PREFLIGHT' || abort.signal.aborted)
-                    fail('CANCELLED', '起動は取り消されています。');
-                await worker.start();
-                if (this.#config.executionMode === 'protected') {
-                    // Real runtime probe: private host file is outside every granted read/write root.
-                    const canary = join(base, 'host-canary');
-                    await writeFile(canary, 'protected', { mode: 0o600 });
-                    const quote = (value) => JSON.stringify(value);
-                    const probe = await this.journalRequest(state, worker, 'eval', { inputs: [], code: `(let ((read-denied (handler-case (progn (with-open-file (s ${quote(canary)}) (read-char s)) nil) (file-error () t))) (delete-denied (handler-case (progn (delete-file ${quote(canary)}) nil) (file-error () t)))) (unless (and read-denied delete-denied) (error "ISOLATION_FAILED")) (kioku.files:write-text (merge-pathnames "probe" (kioku.files:scratch)) "ok") :protected)` }, this.#config.startupTimeoutMs);
-                    if (!probe.ok || await readFile(canary, 'utf8') !== 'protected')
-                        fail('ISOLATION_FAILED', 'OS によるファイル保護を確認できません。');
-                }
-                if (this.#closed || state.state !== 'PREFLIGHT') {
-                    await worker.stop();
-                    fail('CANCELLED', '起動を取り消しました。');
-                }
+                const sessionWorker = await this.isSessionWorker(state.owner);
+                worker = await this.#supervisor.start(state, {
+                    signal: combined, ...(!sessionWorker ? { workspace: state.owner.root } : {}), executionMode: this.#config.executionMode,
+                    assertCurrent: () => { if (this.#closed || state.disposed || state.state !== 'PREFLIGHT' || combined.aborted)
+                        fail('CANCELLED', '起動は取り消されています。'); },
+                    compilation: status => { state.compilation = status; },
+                    assigned: child => { state.worker = child; },
+                    failed: (child, error) => {
+                        // Process events, not UI polling, report an idle child's failure.
+                        // Active operations settle through their journal-aware catch path.
+                        if (state.worker === child && state.state === 'READY')
+                            this.halted(state, error);
+                    },
+                    hostCall: (method, args, context) => this.bridge(state, method, args, context),
+                    beforeJob: () => this.taskAuthority.bound(state.execution, async () => { await this.taskAuthority.authorizeEffect(state.owner, this.#config.executionMode === 'protected' ? 'protected' : 'direct'); }),
+                    auditJob: (input, launch) => this.journalProtectedJob(state, input, launch),
+                    inspect: (child, code) => this.journalRequest(state, child, 'eval', { inputs: [], code }, this.#config.startupTimeoutMs, combined, false),
+                });
                 state.state = 'READY';
                 state.inputBytes = 0;
                 delete state.error;
                 return worker;
             }
             catch (error) {
-                try {
-                    await worker?.stop();
-                }
-                catch (stop) {
-                    error = stop;
-                }
                 if (error instanceof LispError && error.code === 'WORKER_LIMIT') {
                     state.state = 'SUSPENDED';
                     delete state.error;
@@ -481,26 +496,10 @@ export class LispManager {
         }
         finally {
             delete state.admission;
-            delete state.slotReserved;
             state.active.delete(abort);
             this.scheduleIdle(state);
         }
     }
-    /** Serialize only slot allocation/eviction; compilation remains concurrent. */
-    reserveSlot(state) {
-        const allocation = this.#admissionQueue.then(async () => {
-            if (this.#closed || state.disposed || state.state !== 'PREFLIGHT')
-                fail('CANCELLED', 'Lisp の起動を取り消しました。');
-            const occupied = () => [...this.#agents.values()].filter(a => a.slotReserved || (a.worker && !a.worker.stopped)).length;
-            if (occupied() >= this.#config.maxWorkers)
-                throw new LispError('WORKER_LIMIT', 'Lisp の起動枠はすべて使用中です。既存リポジトリの worker と状態は保持します。', '使い終わったセッションを明示的に disable するか、maxWorkers の設定を確認して再試行してください。');
-            if (this.#closed || state.disposed || state.state !== 'PREFLIGHT')
-                fail('CANCELLED', 'Lisp の起動を取り消しました。');
-            state.slotReserved = true;
-        });
-        this.#admissionQueue = allocation.catch(() => { });
-        return allocation;
-    }
     canSuspend(state) {
         return !this.#closed && !state.disposed && state.state === 'READY' && !state.hostBusy && !state.admission && state.active.size === 0
             && !state.ownedJobs?.size && !state.ownedCalls?.size && Boolean(state.worker?.healthy) && !state.worker?.hasRunningJobs;
@@ -533,7 +532,7 @@ export class LispManager {
                     state.state = 'READY';
                     return;
                 }
-                await state.worker.stop();
+                await this.#supervisor.stop(state.worker);
                 state.state = 'SUSPENDED';
                 delete state.error;
                 delete state.worker;
@@ -551,14 +550,43 @@ export class LispManager {
             delete state.suspension;
         }
     }
-    /** Normal suspension is resumable; crashes and explicit cancellation are not. */
-    async prepare(owner) {
+    /** Admit a fresh generation only after the master has reconciled its old child and journals. */
+    async prepare(owner, signal) {
         await this.authorizeCodingTask(owner);
         const state = this.entry(owner);
         if (state.suspension)
             await state.suspension;
+        if (state.state === 'READY' && !state.worker?.healthy)
+            this.halted(state, new LispError('WORKER_EXITED', 'Lisp の子プロセスが終了しています。'));
+        const cold = state.error?.code === 'WORKER_NOT_RESUMED' && !state.worker;
+        const exited = state.error?.code === 'WORKER_EXITED' && state.active.size === 0 && !state.admission;
+        if (cold || exited) {
+            const previous = state.worker;
+            if (exited) {
+                try {
+                    await this.#supervisor.stop(previous);
+                }
+                catch (error) {
+                    this.halted(state, error);
+                    return this.status(owner);
+                }
+            }
+            const pending = await this.#store.hasPending(owner.sessionId);
+            const managed = await this.managedUnresolved(owner);
+            // A cancel, another admission, or a late callback can win while we read.
+            if (!pending && managed.total === 0 && state.worker === previous &&
+                state.state === 'RECOVERY_REQUIRED' && state.error?.code === (cold ? 'WORKER_NOT_RESUMED' : 'WORKER_EXITED')) {
+                if (exited && !this.#supervisor.admitRestart(state)) {
+                    this.halted(state, new LispError('WORKER_RESTART_LIMIT', 'Lisp の異常終了が続いたため自動再起動を停止しました。', '停止理由を確認してから /kioku-lisp recover を実行してください。'));
+                    return this.status(owner);
+                }
+                state.state = 'SUSPENDED';
+                delete state.error;
+                delete state.worker;
+            }
+        }
         if (state.state === 'SUSPENDED') {
-            await this.startWorker(state);
+            await this.startWorker(state, signal);
             state.resumed = true;
         }
         else if (state.admission)
@@ -974,7 +1002,7 @@ export class LispManager {
             executionMode: this.#config.executionMode,
             compilation: state.compilation ?? null, resumed: state.resumed ?? false,
             limits: { timeoutMs: this.#config.timeoutMs, maxOutputBytes: this.#config.maxOutputBytes, maxWorkers: this.#config.maxWorkers, idleTimeoutMs: this.#config.idleTimeoutMs,
-                aggregateMemory: 'unavailable', aggregateCpu: 'unavailable', scratchQuota: 'unavailable', termination: 'supervised', fileBoundary: this.#config.executionMode === 'development' ? 'normal-user-environment' : process.platform === 'darwin' ? 'seatbelt' : 'bubblewrap' },
+                aggregateMemory: 'unavailable', aggregateCpu: 'unavailable', scratchQuota: 'unavailable', termination: 'supervised', fileBoundary: process.platform === 'darwin' ? 'seatbelt' : 'bubblewrap' },
             operations, operationCount: summary.count, pendingCount: Object.values(summary.pendingStates).reduce((a, b) => a + b, 0), pendingStates: summary.pendingStates,
             ...(taskSummary ? { task: taskSummary } : {}),
             hot: await this.#hot.status(owner),
@@ -1026,7 +1054,9 @@ export class LispManager {
             if (tool === 'lisp_status')
                 return await this.status(owner, z.number().int().nonnegative().parse(input.offset ?? 0));
             const state = this.entry(owner);
-            if (!['lisp_hot_status', 'lisp_inspect', 'lisp_cancel'].includes(tool))
+            if (['lisp_define', 'lisp_call', 'lisp_observe', 'lisp_hot_call'].includes(tool))
+                await this.claimSession(owner);
+            else if (!['lisp_hot_status', 'lisp_inspect', 'lisp_cancel'].includes(tool))
                 await this.authorizeCodingTask(owner);
             if (tool === 'lisp_cancel')
                 await this.claimSession(owner);
@@ -1068,7 +1098,7 @@ export class LispManager {
                         typesafe: '(kioku.typesafe:status); (kioku.typesafe:evaluate state questions :model "jev-latest" :timeout-ms 30000). Explicit semantic decisions via the host; consume answers with gethash. Strings/hash tables/vectors use JSON conventions. Catch kioku.typesafe:service-error; no retries or approval bypass. Configure with /kioku-typesafe-key.',
                         describe: 'symbol="kioku.files" lists bundled exports; symbol="kioku.user" lists your task functions; an exact function name returns arguments/docs.',
                         workflow: 'Define task-specific defun helpers once, compose them into one useful operation, and call that function in later evaluations. Batch known reads and checks; return a compact result. Definitions last for this worker generation. Stop before decisions requiring new evidence or approval.',
-                        hot: 'Use lisp_hot_contract, lisp_hot_install and lisp_hot_call for approved project-shared functions. The exact owner reuses this worker with a fresh package, private result scratch and no host RPC. Other owners cannot borrow it. This is not heap security isolation; write pure functions with explicit dependencies. No mode switch is needed. lisp_hot_status reads active versions.',
+                        hot: 'Use lisp_hot_contract, lisp_hot_install and lisp_hot_call for approved project-shared functions. Reuse only your own protected worker with a fresh package and no host RPC; otherwise use private protected scratch without a repository mount. Schemas do not establish purity. No mode switch is needed. lisp_hot_status reads active versions.',
                         run: '(kioku.process:run "node" (list "--test" "--experimental-test-isolation=none" "test/public.test.mjs") :directory "project") uses a project-relative directory in development mode (scratch-relative in protected mode). Check final receipts and result-code.',
                         inspect: 'lisp_inspect accepts ref, or resultOperationId with section/offset/limit (Unicode characters). Never rerun to retrieve output.',
                         reads: 'Use native read/glob/grep/skill for repository exploration; lisp_eval.inputs for read-only workspace or session-attachment copies.',
@@ -1123,8 +1153,6 @@ export class LispManager {
             if (tool.startsWith('lisp_hot_'))
                 return await this.#hot.execute(owner, tool, id, hash, Object.fromEntries(Object.entries(input).filter(([key]) => key !== 'operationId')), signal);
             if (tool === 'lisp_define' || tool === 'lisp_call' || tool === 'lisp_observe') {
-                if (!await this.isTaskMode(owner))
-                    fail('TASK_MODE_REQUIRED', '作業用ツールには /kioku-lisp enable-task を使用してください。');
                 if (tool === 'lisp_observe') {
                     const request = z.object({ paths: z.array(z.string().min(1).max(4096)).min(1).max(100), format: z.enum(['text', 'json']).default('text') }).strict()
                         .parse(Object.fromEntries(Object.entries(input).filter(([key]) => key !== 'operationId')));
@@ -1427,7 +1455,7 @@ export class LispManager {
                 const applied = await this.#proposals.apply(owner, id, worker.generation, response.proposals, combined, undefined, state.packageBase);
                 const uncertain = applied.some(change => change.state === 'UNKNOWN');
                 if (uncertain) {
-                    await worker.stop();
+                    await this.#supervisor.stop(worker);
                     this.halted(state, new LispError('RECONCILIATION_REQUIRED', '変更結果が未確定です。記録とバックアップを照合してください。'));
                 }
                 else if (state.state === 'EVALUATING')
@@ -1453,7 +1481,7 @@ export class LispManager {
                     // Close admission before attempting a potentially failing journal write.
                     state.state = 'STOPPING';
                     try {
-                        await worker.stop();
+                        await this.#supervisor.stop(worker);
                     }
                     catch (stop) {
                         outcome = { ...outcome, stopFailure: failure(stop) };
@@ -1472,7 +1500,7 @@ export class LispManager {
                 }
                 else if (!worker.healthy) {
                     try {
-                        await worker.stop();
+                        await this.#supervisor.stop(worker);
                     }
                     catch (stop) {
                         error = stop;
@@ -1528,7 +1556,7 @@ export class LispManager {
             catch (error) {
                 ownedStopFailure = new LispError('STOP_UNCONFIRMED', `管理中のプロセスの停止を確認できません。${failure(error).message}`);
             }
-            await state.worker?.stop();
+            await this.#supervisor.stop(state.worker);
             if (state.admission) {
                 try {
                     await state.admission;
@@ -1538,10 +1566,11 @@ export class LispManager {
                         throw error;
                 }
             }
-            this.#compiled.assertStopped();
+            this.#supervisor.assertCompilationStopped();
             if (ownedStopFailure)
                 throw ownedStopFailure;
             state.state = 'RECOVERY_REQUIRED';
+            state.error = failure(new LispError('CANCELLED', 'Lisp の処理を取り消しました。'));
         }
         catch (error) {
             this.halted(state, error);