kiokuko-dsh 0.2.26 → 0.2.28

package/dist/dsh/task-state-host.js

@@ -1,31 +1,40 @@
-import { randomUUID } from 'node:crypto';
-import { realpathSync } from 'node:fs';
-import { z } from 'zod';
-import { TASK_TYPES } from '../akinator/types.js';
-import { KiokukoError } from '../errors.js';
-import { withImmediateTransaction } from '../db/transaction.js';
-import { executeIdempotentInTransaction } from './intake-idempotency.js';
-import { LedgerStore } from '../ledger/store.js';
-import { resolveProjectWorkspaceReadOnly } from '../memory/workspaces.js';
-import { canonicalContentHash } from '../serialization/validate.js';
-import { resolveGroundedIntakeProfile } from './intake-profile-resolver.js';
-import { DshRunIntakeService } from './run-intake-service.js';
-import { stableLispCapabilities } from './lisp-service-key.js';
-import { observedTaskCompletionEvidence } from './owned-completion-evidence.js';
-import { assessTaskCompletion } from './task-completion.js';
-import { stopTaskNativeChildren } from './native-task-authority.js';
-import { stopTaskOwnedExecutions } from './owned-execution.js';
-import { isNativeSubagent } from './native-subagent.js';
-import { bindTaskRepository, findSessionTask, readTaskSnapshot, recordTaskEvidence, transitionTask, requestTaskStop, confirmTaskStop, transferTaskOwner, TASK_OPERATIONS, TaskSnapshotSchema } from './task-state.js';
-export const TASK_WORKFLOW_SERVICE = 'kiokukoTaskWorkflow';
-export const TASK_STATE_EVENT = 'kiokuko/task-state';
-export const TASK_OPERATION_TOOL = 'task_operation';
+import { randomUUID } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { z } from "zod";
+import { TASK_TYPES } from "../akinator/types.js";
+import { KiokukoError } from "../errors.js";
+import { withImmediateTransaction } from "../db/transaction.js";
+import { executeIdempotentInTransaction } from "./intake-idempotency.js";
+import { LedgerStore } from "../ledger/store.js";
+import { resolveProjectWorkspaceReadOnly } from "../memory/workspaces.js";
+import { canonicalContentHash, } from "../serialization/validate.js";
+import { resolveGroundedIntakeProfile } from "./intake-profile-resolver.js";
+import { DshRunIntakeService } from "./run-intake-service.js";
+import { stableLispCapabilities } from "./lisp-service-key.js";
+import { observedTaskCompletionEvidence } from "./owned-completion-evidence.js";
+import { assessTaskCompletion } from "./task-completion.js";
+import { stopTaskNativeChildren } from "./native-task-authority.js";
+import { stopTaskOwnedExecutions } from "./owned-execution.js";
+import { isNativeSubagent } from "./native-subagent.js";
+import { bindTaskRepository, findSessionTask, readTaskSnapshot, recordTaskEvidence, transitionTask, requestTaskStop, confirmTaskStop, transferTaskOwner, TASK_OPERATIONS, TaskSnapshotSchema, } from "./task-state.js";
+export const TASK_WORKFLOW_SERVICE = "kiokukoTaskWorkflow";
+export const TASK_STATE_EVENT = "kiokuko/task-state";
+export const TASK_OPERATION_TOOL = "task_operation";
 const text = z.string().trim().min(1).max(4096);
-export const TaskModelOperationSchema = z.discriminatedUnion('operation', [
-    z.object({ operation: z.literal('create'), taskType: z.enum(TASK_TYPES) }).strict(),
-    ...TASK_OPERATIONS.map(operation => z.object({ operation: z.literal(operation), taskId: text,
-        expectedRevision: z.number().int().positive(), expectedGeneration: z.number().int().positive(),
-        reason: text, evidence: z.array(text.max(512)).max(32).default([]) }).strict()),
+export const TaskModelOperationSchema = z.discriminatedUnion("operation", [
+    z
+        .object({ operation: z.literal("create"), taskType: z.enum(TASK_TYPES) })
+        .strict(),
+    ...TASK_OPERATIONS.map((operation) => z
+        .object({
+        operation: z.literal(operation),
+        taskId: text,
+        expectedRevision: z.number().int().positive(),
+        expectedGeneration: z.number().int().positive(),
+        reason: text,
+        evidence: z.array(text.max(512)).max(32).default([]),
+    })
+        .strict()),
 ]);
 /** Public adapter over SQLite. It keeps no authoritative task state in memory. */
 export class DshTaskWorkflow {
@@ -38,21 +47,29 @@ export class DshTaskWorkflow {
         this.options = options;
     }
     current(agent) {
-        if (this.#closed || !agent?.session || this.options.agents.get(agent.id) !== agent
-            || this.options.sessions.get(agent.session.id) !== agent.session || isNativeSubagent(agent)) {
-            throw new KiokukoError('CONFLICT', 'Task operation requires the exact current primary native agent and session');
+        if (this.#closed ||
+            !agent?.session ||
+            this.options.agents.get(agent.id) !== agent ||
+            this.options.sessions.get(agent.session.id) !== agent.session ||
+            isNativeSubagent(agent)) {
+            throw new KiokukoError("CONFLICT", "Task operation requires the exact current primary native agent and session");
         }
     }
     async owner(agent) {
         this.current(agent);
         if (!agent.session.header?.cwd)
-            throw new KiokukoError('CONFLICT', 'Current native workspace is unavailable');
+            throw new KiokukoError("CONFLICT", "Current native workspace is unavailable");
         const cwd = realpathSync(agent.session.header.cwd);
         const owner = await this.options.runtime.withDatabase(async (db) => {
-            const project = await resolveProjectWorkspaceReadOnly(db, cwd, { allowDirectory: true });
+            const project = await resolveProjectWorkspaceReadOnly(db, cwd, {
+                allowDirectory: true,
+            });
             if (!project)
-                throw new KiokukoError('CONFLICT', 'Current native workspace is not registered');
-            return { sessionId: agent.session.id, repositoryRoot: project.repositoryRoot };
+                throw new KiokukoError("CONFLICT", "Current native workspace is not registered");
+            return {
+                sessionId: agent.session.id,
+                repositoryRoot: project.repositoryRoot,
+            };
         });
         this.current(agent);
         return owner;
@@ -60,17 +77,24 @@ export class DshTaskWorkflow {
     async snapshot(agent) {
         this.current(agent);
         if (!agent.session.header?.cwd)
-            throw new KiokukoError('CONFLICT', 'Current native workspace is unavailable');
+            throw new KiokukoError("CONFLICT", "Current native workspace is unavailable");
         const cwd = realpathSync(agent.session.header.cwd);
         const task = await this.options.runtime.withDatabase(async (db) => {
-            const project = await resolveProjectWorkspaceReadOnly(db, cwd, { allowDirectory: true });
-            return project ? findSessionTask(db, { sessionId: agent.session.id, repositoryRoot: project.repositoryRoot }, { includeLatestTerminal: true }) : undefined;
+            const project = await resolveProjectWorkspaceReadOnly(db, cwd, {
+                allowDirectory: true,
+            });
+            return project
+                ? findSessionTask(db, {
+                    sessionId: agent.session.id,
+                    repositoryRoot: project.repositoryRoot,
+                }, { includeLatestTerminal: true })
+                : undefined;
         });
         this.current(agent);
         return { sessionId: agent.session.id, task: task ?? null };
     }
     isControl(execution) {
-        if (!execution || typeof execution !== 'object')
+        if (!execution || typeof execution !== "object")
             return false;
         try {
             this.current(execution.agent);
@@ -80,27 +104,35 @@ export class DshTaskWorkflow {
         }
         return this.options.demand?.isControl(execution) === true;
     }
-    publish(task) { if (!this.#closed) {
-        this.options.demand?.taskStateChanged(task);
-        try {
-            this.options.emit(task);
+    publish(task) {
+        if (!this.#closed) {
+            this.options.demand?.taskStateChanged(task);
+            try {
+                this.options.emit(task);
+            }
+            catch {
+                /* A UI observer cannot roll back a committed operation. */
+            }
         }
-        catch { /* A UI observer cannot roll back a committed operation. */ }
-    } return task; }
+        return task;
+    }
     /** Durable public-call receipts share the mutation's transaction. Reading a
      * receipt still requires the exact current native owner and repository, but
      * never re-publishes an old snapshot or restarts its lifecycle side effects. */
     modelReceipt(db, owner, replay, operation) {
         if (!replay)
             return operation?.();
-        if (owner.sessionId !== replay.owner.sessionId || owner.repositoryRoot !== replay.owner.repositoryRoot)
-            throw new KiokukoError('CONFLICT', 'Task owner or repository changed');
-        const absent = Symbol('no-model-operation-receipt');
+        if (owner.sessionId !== replay.owner.sessionId ||
+            owner.repositoryRoot !== replay.owner.repositoryRoot)
+            throw new KiokukoError("CONFLICT", "Task owner or repository changed");
+        const absent = Symbol("no-model-operation-receipt");
         let executed = false;
         try {
             return withImmediateTransaction(db, () => {
                 const result = TaskSnapshotSchema.parse(executeIdempotentInTransaction(db, {
-                    scope: replay.scope, key: replay.key, request: replay.request,
+                    scope: replay.scope,
+                    key: replay.key,
+                    request: replay.request,
                 }, () => {
                     if (!operation)
                         throw absent;
@@ -121,32 +153,76 @@ export class DshTaskWorkflow {
     async create(agent, task, type, operationId, signal, replay) {
         const owner = await this.owner(agent);
         const request = text.max(16384).parse(task), taskType = z.enum(TASK_TYPES).parse(type);
-        const grounded = resolveGroundedIntakeProfile({ task: request, cwd: owner.repositoryRoot, deferTaskTypeInference: true, profileHints: { taskType } });
-        const skills = await this.options.skills.snapshot({ scope: agent, cwd: owner.repositoryRoot, signal });
+        const grounded = resolveGroundedIntakeProfile({
+            task: request,
+            cwd: owner.repositoryRoot,
+            deferTaskTypeInference: true,
+            profileHints: { taskType },
+        });
+        const skills = await this.options.skills.snapshot({
+            scope: agent,
+            cwd: owner.repositoryRoot,
+            signal,
+        });
         if (!skills.complete)
-            throw new KiokukoError('CONFLICT', 'Native capability inventory is incomplete');
-        const schemas = stableLispCapabilities(await this.options.tools.schemas(agent), agent);
-        const capabilities = [...skills.skills.filter((skill) => skill.invocation?.modelInvocable !== false)
-                .map((skill) => ({ kind: 'skill', name: skill.name, ...(skill.description ? { description: skill.description } : {}) })),
-            ...schemas.map((tool) => ({ kind: 'tool', name: tool.name, ...(tool.description ? { description: tool.description } : {}) }))];
+            throw new KiokukoError("CONFLICT", "Native capability inventory is incomplete");
+        const schemas = stableLispCapabilities((await this.options.tools.schemas(agent)), agent);
+        const capabilities = [
+            ...skills.skills
+                .filter((skill) => skill.invocation?.modelInvocable !== false)
+                .map((skill) => ({
+                kind: "skill",
+                name: skill.name,
+                ...(skill.description ? { description: skill.description } : {}),
+            })),
+            ...schemas.map((tool) => ({
+                kind: "tool",
+                name: tool.name,
+                ...(tool.description ? { description: tool.description } : {}),
+            })),
+        ];
         signal.throwIfAborted();
         this.current(agent);
         const result = await this.options.runtime.withDatabase(async (db) => {
             const project = await resolveProjectWorkspaceReadOnly(db, owner.repositoryRoot, { allowDirectory: true });
             if (!project)
-                throw new KiokukoError('CONFLICT', 'Task workspace changed');
+                throw new KiokukoError("CONFLICT", "Task workspace changed");
             this.current(agent);
             signal.throwIfAborted();
             return this.modelReceipt(db, owner, replay, () => {
                 const current = findSessionTask(db, owner);
-                if (current && new LedgerStore(db).readRun(current.runId)?.metadata.requestId !== operationId)
-                    throw new KiokukoError('CONFLICT', 'A current task already exists; use an allowed operation or finish it before creating another');
-                const opened = new DshRunIntakeService(db, { deferTaskTypeInference: true }).openRun({
-                    idempotencyKey: operationId, dshSessionId: owner.sessionId,
-                    request: { apiVersion: '1', workspace: project.workspace,
-                        task: { title: request, query: request, profileHints: grounded.profileHints },
-                        captureProfile: 'minimal', coverage: { run: 'unavailable', tool: 'unavailable', command: 'unavailable', file: 'unavailable', approval: 'unavailable' },
-                        capabilities, metadata: { taskStateExplicit: true, requestId: operationId, repositoryRoot: owner.repositoryRoot } }
+                if (current &&
+                    new LedgerStore(db).readRun(current.runId)?.metadata.requestId !==
+                        operationId)
+                    throw new KiokukoError("CONFLICT", "A current task already exists; use an allowed operation or finish it before creating another");
+                const opened = new DshRunIntakeService(db, {
+                    deferTaskTypeInference: true,
+                }).openRun({
+                    idempotencyKey: operationId,
+                    dshSessionId: owner.sessionId,
+                    request: {
+                        apiVersion: "1",
+                        workspace: project.workspace,
+                        task: {
+                            title: request,
+                            query: request,
+                            profileHints: grounded.profileHints,
+                        },
+                        captureProfile: "minimal",
+                        coverage: {
+                            run: "unavailable",
+                            tool: "unavailable",
+                            command: "unavailable",
+                            file: "unavailable",
+                            approval: "unavailable",
+                        },
+                        capabilities,
+                        metadata: {
+                            taskStateExplicit: true,
+                            requestId: operationId,
+                            repositoryRoot: owner.repositoryRoot,
+                        },
+                    },
                 });
                 return bindTaskRepository(db, { ...owner, taskId: opened.runId });
             });
@@ -154,33 +230,57 @@ export class DshTaskWorkflow {
         return replay?.replayed ? result : this.publish(result);
     }
     async operate(agent, operation, signal) {
-        return this.apply(agent, operation, signal, { explicit: true, operationId: `task-ui:${randomUUID()}` });
+        return this.apply(agent, operation, signal, {
+            explicit: true,
+            operationId: `task-ui:${randomUUID()}`,
+        });
     }
     async modelOperation(agent, raw, execution) {
         const input = TaskModelOperationSchema.parse(raw);
-        const operation = input.operation === 'create'
-            ? { operation: 'create', taskType: input.taskType, request: this.options.demand?.controlTask(execution) ?? '' }
-            : { operation: input.operation, reason: input.reason, evidence: input.evidence,
-                expected: { taskId: input.taskId, revision: input.expectedRevision, generation: input.expectedGeneration } };
+        const operation = input.operation === "create"
+            ? {
+                operation: "create",
+                taskType: input.taskType,
+                request: this.options.demand?.controlTask(execution) ?? "",
+            }
+            : {
+                operation: input.operation,
+                reason: input.reason,
+                evidence: input.evidence,
+                expected: {
+                    taskId: input.taskId,
+                    revision: input.expectedRevision,
+                    generation: input.expectedGeneration,
+                },
+            };
         execution.signal.throwIfAborted();
         const owner = await this.owner(agent);
-        const replay = { scope: `task-model:${canonicalContentHash(owner.sessionId)}`,
-            key: `task-tool:${execution.callId}`, owner, request: { owner, operation }, replayed: false };
-        const previous = await this.options.runtime.withDatabase(db => this.modelReceipt(db, owner, replay));
+        const replay = {
+            scope: `task-model:${canonicalContentHash(owner.sessionId)}`,
+            key: `task-tool:${execution.callId}`,
+            owner,
+            request: { owner, operation },
+            replayed: false,
+        };
+        const previous = await this.options.runtime.withDatabase((db) => this.modelReceipt(db, owner, replay));
         this.current(agent);
         execution.signal.throwIfAborted();
         if (previous)
             return previous;
         let result;
         try {
-            result = await this.apply(agent, operation, execution.signal, { explicit: false, operationId: replay.key, replay });
+            result = await this.apply(agent, operation, execution.signal, {
+                explicit: false,
+                operationId: replay.key,
+                replay,
+            });
         }
         catch (error) {
             // A concurrent identical call can commit between our receipt lookup and
             // the ordinary CAS check. Recover only its exact durable receipt.
             execution.signal.throwIfAborted();
             const currentOwner = await this.owner(agent);
-            const committed = await this.options.runtime.withDatabase(db => this.modelReceipt(db, currentOwner, replay));
+            const committed = await this.options.runtime.withDatabase((db) => this.modelReceipt(db, currentOwner, replay));
             this.current(agent);
             execution.signal.throwIfAborted();
             if (!committed)
@@ -193,78 +293,117 @@ export class DshTaskWorkflow {
     }
     async apply(agent, operation, signal, source) {
         signal.throwIfAborted();
-        if (operation.operation === 'ignore' && !operation.reason?.trim())
-            throw new KiokukoError('VALIDATION_ERROR', 'Ignore requires an explicit reason');
-        if (operation.operation === 'create')
+        if (operation.operation === "ignore" && !operation.reason?.trim())
+            throw new KiokukoError("VALIDATION_ERROR", "Ignore requires an explicit reason");
+        if (operation.operation === "create")
             return this.create(agent, operation.request, operation.taskType, source.operationId, signal, source.replay);
         const owner = await this.owner(agent);
-        const task = await this.options.runtime.withDatabase(db => operation.expected || operation.taskId
-            ? readTaskSnapshot(db, { ...owner, taskId: operation.expected?.taskId ?? operation.taskId })
+        const task = await this.options.runtime.withDatabase((db) => operation.expected || operation.taskId
+            ? readTaskSnapshot(db, {
+                ...owner,
+                taskId: operation.expected?.taskId ?? operation.taskId,
+            })
             : findSessionTask(db, owner, { includeLatestTerminal: true }));
         if (!task)
-            throw new KiokukoError('CONFLICT', 'No task is selected for this session');
-        if (operation.expected && (operation.expected.revision !== task.revision
-            || operation.expected.generation !== undefined && operation.expected.generation !== task.generation))
-            throw new KiokukoError('CONFLICT', 'Task changed; read the current snapshot before operating');
+            throw new KiokukoError("CONFLICT", "No task is selected for this session");
+        if (operation.expected &&
+            (operation.expected.revision !== task.revision ||
+                (operation.expected.generation !== undefined &&
+                    operation.expected.generation !== task.generation)))
+            throw new KiokukoError("CONFLICT", "Task changed; read the current snapshot before operating");
         const identity = { ...owner, taskId: task.taskId };
-        const input = { operation: operation.operation, operationId: source.operationId, expectedRevision: task.revision,
-            expectedGeneration: task.generation, reason: operation.reason ?? `Explicit ${operation.operation} operation`,
-            evidence: [...(operation.evidence ?? [])], explicit: source.explicit };
-        if (input.operation === 'complete') {
+        const input = {
+            operation: operation.operation,
+            operationId: source.operationId,
+            expectedRevision: task.revision,
+            expectedGeneration: task.generation,
+            reason: operation.reason ?? `Explicit ${operation.operation} operation`,
+            evidence: [...(operation.evidence ?? [])],
+            explicit: source.explicit,
+        };
+        if (input.operation === "complete") {
             const lisp = this.options.lisp?.();
-            const idle = lisp?.taskJobsIdle ? await lisp.taskJobsIdle(agent)
-                : !await this.options.runtime.withDatabase(db => db.prepare('SELECT 1 FROM dsh_lisp_sessions WHERE session_id=? AND enabled=1').get(task.sessionId));
+            const idle = lisp?.taskJobsIdle
+                ? await lisp.taskJobsIdle(agent)
+                : !(await this.options.runtime.withDatabase((db) => db
+                    .prepare("SELECT 1 FROM dsh_lisp_sessions WHERE session_id=? AND enabled=1")
+                    .get(task.sessionId)));
             if (!idle)
-                throw new KiokukoError('CONFLICT', 'Task still has running or unconfirmed Lisp work');
+                throw new KiokukoError("CONFLICT", "Task still has running or unconfirmed Lisp work");
         }
         this.current(agent);
         signal.throwIfAborted();
-        const result = await this.options.runtime.withDatabase(db => withImmediateTransaction(db, () => {
+        const result = await this.options.runtime.withDatabase((db) => withImmediateTransaction(db, () => {
             this.current(agent);
             signal.throwIfAborted();
             return this.modelReceipt(db, owner, source.replay, () => {
-                if (input.operation === 'complete') {
+                if (input.operation === "complete") {
                     const lisp = this.options.lisp?.();
-                    if (lisp?.taskJobsIdleSync ? !lisp.taskJobsIdleSync(agent)
-                        : !!db.prepare('SELECT 1 FROM dsh_lisp_sessions WHERE session_id=? AND enabled=1').get(task.sessionId))
-                        throw new KiokukoError('CONFLICT', 'Task still has running or unconfirmed Lisp work');
-                    if (db.prepare("SELECT 1 FROM dsh_owned_operations WHERE run_id=? AND state='started' LIMIT 1").get(task.taskId))
-                        throw new KiokukoError('CONFLICT', 'Task still has running owned work; collect its terminal result before completion');
+                    if (lisp?.taskJobsIdleSync
+                        ? !lisp.taskJobsIdleSync(agent)
+                        : !!db
+                            .prepare("SELECT 1 FROM dsh_lisp_sessions WHERE session_id=? AND enabled=1")
+                            .get(task.sessionId))
+                        throw new KiokukoError("CONFLICT", "Task still has running or unconfirmed Lisp work");
+                    if (db
+                        .prepare("SELECT 1 FROM dsh_owned_operations WHERE run_id=? AND state='started' LIMIT 1")
+                        .get(task.taskId))
+                        throw new KiokukoError("CONFLICT", "Task still has running owned work; collect its terminal result before completion");
                     const assessment = assessTaskCompletion(db, task.runId);
                     if (assessment.verified) {
                         const ref = `verification:${canonicalContentHash({ taskId: task.taskId, generation: task.generation, assessment })}`;
-                        recordTaskEvidence(db, identity, { ref, kind: 'verification', generation: task.generation, verified: true });
+                        recordTaskEvidence(db, identity, {
+                            ref,
+                            kind: "verification",
+                            generation: task.generation,
+                            verified: true,
+                        });
                         input.evidence.push(ref);
                     }
                     else if (!assessment.coding && assessment.required === 0) {
                         const observed = observedTaskCompletionEvidence(db, task, input.evidence);
                         if (observed.length > 0) {
                             const ref = `verification:${canonicalContentHash({ taskId: task.taskId, generation: task.generation, observed })}`;
-                            recordTaskEvidence(db, identity, { ref, kind: 'verification', generation: task.generation, verified: true,
-                                details: { source: 'explicit-completion', observationRefs: observed } });
+                            recordTaskEvidence(db, identity, {
+                                ref,
+                                kind: "verification",
+                                generation: task.generation,
+                                verified: true,
+                                details: {
+                                    source: "explicit-completion",
+                                    observationRefs: observed,
+                                },
+                            });
                             input.evidence.push(ref);
                         }
                     }
                 }
-                return task.state === 'Working' && (input.operation === 'wait' || input.operation === 'ignore')
-                    ? requestTaskStop(db, identity, input) : transitionTask(db, identity, input, { ...(this.sourceEndSeq(agent) === undefined ? {} : { sourceEndSeq: this.sourceEndSeq(agent) }) });
+                return task.state === "Working" &&
+                    (input.operation === "wait" || input.operation === "ignore")
+                    ? requestTaskStop(db, identity, input)
+                    : transitionTask(db, identity, input, {
+                        ...(this.sourceEndSeq(agent) === undefined
+                            ? {}
+                            : { sourceEndSeq: this.sourceEndSeq(agent) }),
+                    });
             });
         }));
         if (source.replay?.replayed)
             return result;
         this.publish(result);
         if (result.pendingStop) {
-            if (source.explicit && agent.status !== 'idle')
-                agent.cancel?.({ kind: 'hook', reason: 'Explicit Kiokuko task stop' });
+            if (source.explicit && agent.status !== "idle")
+                agent.cancel?.({ kind: "hook", reason: "Explicit Kiokuko task stop" });
             this.finishStop(agent, result);
         }
-        if (result.state === 'Done')
+        if (result.state === "Done")
             this.finishCompletion(agent, result);
         return result;
     }
     sourceEndSeq(agent) {
         const seq = Number.isSafeInteger(agent.session.seq) && agent.session.seq > 0
-            ? agent.session.seq - 1 : agent.session.snapshotEvents?.().at(-1)?.seq;
+            ? agent.session.seq - 1
+            : agent.session.snapshotEvents?.().at(-1)?.seq;
         return Number.isSafeInteger(seq) && seq >= 0 ? seq : undefined;
     }
     async stopWork(agent, task, signal) {
@@ -274,10 +413,11 @@ export class DshTaskWorkflow {
         const assertCurrent = async () => {
             signal.throwIfAborted();
             this.current(agent);
-            await this.options.runtime.withDatabase(db => {
+            await this.options.runtime.withDatabase((db) => {
                 const current = readTaskSnapshot(db, task);
-                if (current.revision !== task.revision || current.generation !== task.generation)
-                    throw new KiokukoError('CONFLICT', 'Task changed before stopping its work');
+                if (current.revision !== task.revision ||
+                    current.generation !== task.generation)
+                    throw new KiokukoError("CONFLICT", "Task changed before stopping its work");
             });
             signal.throwIfAborted();
             this.current(agent);
@@ -289,12 +429,14 @@ export class DshTaskWorkflow {
         else {
             // During unload the service may already be unavailable while workers drain.
             // A persisted enabled session cannot be assumed stopped from service absence.
-            const enabled = await this.options.runtime.withDatabase(db => db.prepare('SELECT 1 FROM dsh_lisp_sessions WHERE session_id=? AND enabled=1').get(task.sessionId));
+            const enabled = await this.options.runtime.withDatabase((db) => db
+                .prepare("SELECT 1 FROM dsh_lisp_sessions WHERE session_id=? AND enabled=1")
+                .get(task.sessionId));
             if (enabled)
                 return false;
         }
         await assertCurrent();
-        if (!await stopTaskNativeChildren(this.options.runtime, task, signal))
+        if (!(await stopTaskNativeChildren(this.options.runtime, task, signal)))
             return false;
         await assertCurrent();
         return stopTaskOwnedExecutions(this.options.runtime, task, signal);
@@ -309,95 +451,145 @@ export class DshTaskWorkflow {
             if (!stopped || !agent.whenIdle)
                 return;
             await agent.whenIdle();
-            if (agent.status !== 'idle')
+            if (agent.status !== "idle")
                 return;
             this.current(agent);
             await this.options.checkpointSource?.(agent);
             this.current(agent);
-            const result = await this.options.runtime.withDatabase(db => withImmediateTransaction(db, () => {
+            const result = await this.options.runtime.withDatabase((db) => withImmediateTransaction(db, () => {
                 this.current(agent);
-                if (agent.status !== 'idle')
+                if (agent.status !== "idle")
                     return undefined;
                 const current = readTaskSnapshot(db, task);
                 if (current.pendingStop?.operationId !== operationId)
                     return undefined;
                 const ref = `stopped:${operationId}:${current.generation}`;
-                recordTaskEvidence(db, task, { ref, kind: 'stopped', generation: current.generation, verified: true });
-                const confirmed = confirmTaskStop(db, task, { operationId, expectedRevision: current.revision, evidenceRef: ref });
+                recordTaskEvidence(db, task, {
+                    ref,
+                    kind: "stopped",
+                    generation: current.generation,
+                    verified: true,
+                });
+                const confirmed = confirmTaskStop(db, task, {
+                    operationId,
+                    expectedRevision: current.revision,
+                    evidenceRef: ref,
+                });
                 return confirmed;
             }));
             if (result)
                 this.publish(result);
-        })().catch(() => { }).finally(() => this.#stops.delete(task.taskId));
+        })()
+            .catch(() => {
+            /* Preserve the durable unresolved stop and its denied authority. */
+        })
+            .finally(() => this.#stops.delete(task.taskId));
         this.#stops.set(task.taskId, promise);
     }
     /** Wait for the final native answer, then seal only this exact Done generation. */
     finishCompletion(agent, task) {
         const key = `${task.taskId}:${task.revision}:${task.generation}`;
-        if (task.state !== 'Done' || this.#closed || this.#completions.has(key) || !agent.whenIdle)
+        if (task.state !== "Done" ||
+            this.#closed ||
+            this.#completions.has(key) ||
+            !agent.whenIdle)
             return;
         const promise = (async () => {
             await agent.whenIdle();
             this.current(agent);
-            if (agent.status !== 'idle')
+            if (agent.status !== "idle")
                 return;
             await this.options.checkpointSource?.(agent);
             this.current(agent);
-            const completed = await this.options.runtime.withDatabase(db => withImmediateTransaction(db, () => {
+            const completed = await this.options.runtime.withDatabase((db) => withImmediateTransaction(db, () => {
                 this.current(agent);
-                if (agent.status !== 'idle')
+                if (agent.status !== "idle")
                     return false;
                 const current = readTaskSnapshot(db, task);
-                if (current.state !== 'Done' || current.revision !== task.revision || current.generation !== task.generation)
+                if (current.state !== "Done" ||
+                    current.revision !== task.revision ||
+                    current.generation !== task.generation)
                     return false;
                 return true;
             }));
             if (completed)
                 try {
-                    this.options.onCompleted?.(task);
+                    await this.options.onCompleted?.(task);
                 }
-                catch { /* Optional local memory cannot undo completion. */ }
-        })().catch(() => { })
+                catch {
+                    /* A later idle callback can retry the exact Done generation. */
+                }
+        })()
+            .catch(() => {
+            /* A later native idle/reload retries the same canonical Done state. */
+        })
             .finally(() => this.#completions.delete(key));
         this.#completions.set(key, promise);
     }
     async handoff(source, target, expected, signal) {
         const sourceOwner = await this.owner(source), targetOwner = await this.owner(target);
-        if (sourceOwner.repositoryRoot !== targetOwner.repositoryRoot || target.session.header?.parentSession !== source.session.id)
-            throw new KiokukoError('CONFLICT', 'Task handoff requires a primary continuation in the same repository');
-        const selected = await this.options.runtime.withDatabase(db => {
+        if (sourceOwner.repositoryRoot !== targetOwner.repositoryRoot ||
+            target.session.header?.parentSession !== source.session.id)
+            throw new KiokukoError("CONFLICT", "Task handoff requires a primary continuation in the same repository");
+        const selected = await this.options.runtime.withDatabase((db) => {
             signal.throwIfAborted();
             this.current(source);
             this.current(target);
-            const task = readTaskSnapshot(db, { ...sourceOwner, taskId: expected.taskId });
-            if (task.revision !== expected.revision || expected.generation !== undefined && task.generation !== expected.generation
-                || task.pendingStop)
-                throw new KiokukoError('CONFLICT', 'Task changed before handoff or its stop is unresolved');
+            const task = readTaskSnapshot(db, {
+                ...sourceOwner,
+                taskId: expected.taskId,
+            });
+            if (task.revision !== expected.revision ||
+                (expected.generation !== undefined &&
+                    task.generation !== expected.generation) ||
+                task.pendingStop)
+                throw new KiokukoError("CONFLICT", "Task changed before handoff or its stop is unresolved");
             return task;
         });
         const stopped = await this.stopWork(source, selected, signal);
-        if (!stopped || source.status !== 'idle')
-            throw new KiokukoError('CONFLICT', 'Task source has not confirmed its stop');
+        if (!stopped || source.status !== "idle")
+            throw new KiokukoError("CONFLICT", "Task source has not confirmed its stop");
         signal.throwIfAborted();
         this.current(source);
         this.current(target);
-        const result = await this.options.runtime.withDatabase(db => withImmediateTransaction(db, () => {
+        const result = await this.options.runtime.withDatabase((db) => withImmediateTransaction(db, () => {
             signal.throwIfAborted();
             this.current(source);
             this.current(target);
-            if (source.status !== 'idle')
-                throw new KiokukoError('CONFLICT', 'Task source resumed before handoff');
-            const task = readTaskSnapshot(db, { ...sourceOwner, taskId: expected.taskId });
-            if (task.revision !== expected.revision || expected.generation !== undefined && task.generation !== expected.generation)
-                throw new KiokukoError('CONFLICT', 'Task changed before handoff');
+            if (source.status !== "idle")
+                throw new KiokukoError("CONFLICT", "Task source resumed before handoff");
+            const task = readTaskSnapshot(db, {
+                ...sourceOwner,
+                taskId: expected.taskId,
+            });
+            if (task.revision !== expected.revision ||
+                (expected.generation !== undefined &&
+                    task.generation !== expected.generation))
+                throw new KiokukoError("CONFLICT", "Task changed before handoff");
             const ref = `handoff-stop:${randomUUID()}`;
-            recordTaskEvidence(db, task, { ref, kind: 'stopped', generation: task.generation, verified: true });
-            return transferTaskOwner(db, task, { sessionId: targetOwner.sessionId, operationId: `handoff:${randomUUID()}`,
-                expectedRevision: task.revision, expectedGeneration: task.generation, evidence: [ref], reason: 'Trusted native primary continuation handoff',
-                ...(this.sourceEndSeq(source) === undefined ? {} : { sourceEndSeq: this.sourceEndSeq(source) }) });
+            recordTaskEvidence(db, task, {
+                ref,
+                kind: "stopped",
+                generation: task.generation,
+                verified: true,
+            });
+            return transferTaskOwner(db, task, {
+                sessionId: targetOwner.sessionId,
+                operationId: `handoff:${randomUUID()}`,
+                expectedRevision: task.revision,
+                expectedGeneration: task.generation,
+                evidence: [ref],
+                reason: "Trusted native primary continuation handoff",
+                ...(this.sourceEndSeq(source) === undefined
+                    ? {}
+                    : { sourceEndSeq: this.sourceEndSeq(source) }),
+            });
         }));
         return this.publish(result);
     }
-    dispose() { this.#closed = true; this.#lifecycle.abort(new Error('Task workflow disposed')); }
+    dispose() {
+        this.#closed = true;
+        this.#lifecycle.abort(new Error("Task workflow disposed"));
+    }
 }
 //# sourceMappingURL=task-state-host.js.map