kiokuko-dsh 0.1.21 → 0.1.23

package/dist/dsh/host-adapter.js

@@ -31,11 +31,13 @@ import { curateMemoryCandidates } from '../memory/curator.js';
 import { checkpointDshMemory } from '../memory/scoped-memory.js';
 import { LedgerStore } from '../ledger/store.js';
 import { ENNO_APPLICABLE_TASK_TYPES } from '../enno-oduno/types.js';
-import { commitExpectedFailure, ennoReceiptOperation, isExpectedTurnFailure, phaseForOperation, prepareTurnIntent, readPendingOutbox, readTurnSeal, markOutboxObservedInTransaction, appliedTurnOutcome, replacePendingOutboxMessageInTransaction, supersedeOutboxAtOrBeforeRevisionInTransaction, } from './turn-process.js';
+import { commitExpectedFailure, ennoReceiptOperation, enqueueUnsubmittedTurn, isExpectedTurnFailure, phaseForOperation, prepareTurnIntent, readPendingOutbox, readTurnSeal, markOutboxObservedInTransaction, appliedTurnOutcome, replacePendingOutboxMessageInTransaction, supersedeBoundaryJobsAtOrBeforeRevisionInTransaction, supersedeOutboxAtOrBeforeRevisionInTransaction, } from './turn-process.js';
 import { backupInputClaimInTransaction, markClaimProgressInTransaction, settleInputClaimInTransaction, takeRecoverableInputClaimInTransaction, } from './input-claim.js';
 import { DshSessionLogMirror } from './session-log-mirror.js';
-import { DshBoundaryWorker } from './boundary-worker.js';
+import { abortable, DshBoundaryWorker } from './boundary-worker.js';
 import { DshSessionLogExportService } from './session-log-export.js';
+import { DshCompletionReporter } from './completion-report.js';
+import { claimAutomaticContinuationInTransaction, claimBoundaryEffectInTransaction, claimLoopRecoveryQuestionInTransaction, ennoInstructionDigest, resetBoundaryEffectGuardInTransaction, resetLoopGuardForUserInTransaction, } from './loop-guard.js';
 function sessionEventSource(value) {
     const source = value;
     if (typeof source?.snapshotEvents !== 'function') {
@@ -94,12 +96,49 @@ function isHumanMessage(value) {
 function pluginContinuationId(value) {
     const message = objectRecord(value);
     const source = objectRecord(message?.source);
-    if (source?.kind !== 'plugin' || source.plugin !== 'kiokuko-dsh' || source.form !== 'continuation')
+    if (source?.kind !== 'plugin' || source.plugin !== 'kiokuko-dsh'
+        || (source.form !== 'continuation' && source.form !== 'loop-recovery'))
         return undefined;
     return typeof source.deliveryId === 'string' && /^[0-9a-f]{64}$/u.test(source.deliveryId)
         ? source.deliveryId
         : undefined;
 }
+function isLoopRecoveryMessage(value) {
+    const source = objectRecord(objectRecord(value)?.source);
+    return source?.kind === 'plugin' && source.plugin === 'kiokuko-dsh' && source.form === 'loop-recovery';
+}
+function recoveryMessage(continuationId, answer) {
+    return Object.freeze({
+        id: continuationId,
+        role: 'user',
+        content: [{
+                type: 'text',
+                text: `The user reviewed the stopped Kiokuko loop and supplied this recovery instruction:\n\n${answer}`,
+            }],
+        source: { kind: 'plugin', plugin: 'kiokuko-dsh', form: 'loop-recovery', deliveryId: continuationId },
+    });
+}
+function boundedMessageText(value) {
+    const content = objectRecord(value)?.content;
+    if (!Array.isArray(content))
+        return undefined;
+    const block = content.map(objectRecord).find((candidate) => candidate?.type === 'text' && typeof candidate.text === 'string');
+    return typeof block?.text === 'string' ? block.text.slice(0, 2_000) : undefined;
+}
+function boundedUtf8Text(value, maximumBytes) {
+    if (Buffer.byteLength(value, 'utf8') <= maximumBytes)
+        return value;
+    let result = '';
+    let bytes = 0;
+    for (const point of value) {
+        const size = Buffer.byteLength(point, 'utf8');
+        if (bytes + size > maximumBytes)
+            break;
+        result += point;
+        bytes += size;
+    }
+    return result;
+}
 function eventContinuationId(data) {
     const direct = pluginContinuationId(data);
     if (direct !== undefined)
@@ -638,12 +677,23 @@ export function createDshHostAdapter(ctx, options = {}) {
                 }),
             };
             if (humanPresent) {
+                boundaryWorker.cancelSession(event.sessionId);
                 const previous = currentSession(event.sessionId);
                 const state = previous === undefined ? undefined : states.get(previous.runId);
-                if (state !== undefined) {
+                if (previous !== undefined) {
                     try {
                         await runtime.withDatabase((database) => withImmediateTransaction(database, () => {
-                            supersedeOutboxAtOrBeforeRevisionInTransaction(database, event.sessionId, state.revision);
+                            if (state !== undefined) {
+                                const now = options.now?.() ?? new Date().toISOString();
+                                supersedeOutboxAtOrBeforeRevisionInTransaction(database, event.sessionId, state.revision, now);
+                                supersedeBoundaryJobsAtOrBeforeRevisionInTransaction(database, event.sessionId, state.revision, now);
+                            }
+                            resetLoopGuardForUserInTransaction(database, {
+                                runId: previous.runId,
+                                dshSessionId: event.sessionId,
+                                resolution: 'manual_user',
+                                ...(options.now === undefined ? {} : { now: options.now() }),
+                            });
                         }));
                     }
                     catch {
@@ -752,9 +802,12 @@ export function createDshHostAdapter(ctx, options = {}) {
             terminalizeLedgerRunInTransaction(database, runId, 'cancelled');
             return undefined;
         }
+        const automaticMessage = event.nativeMessages?.find((message) => pluginContinuationId(message) !== undefined && !isLoopRecoveryMessage(message));
+        const automaticClaimId = automaticMessage === undefined ? undefined : pluginContinuationId(automaticMessage);
         const decision = decideDshContinuation(database, {
             dshSessionId: event.sessionId,
             cwd: event.cwd,
+            ...(automaticClaimId === undefined ? {} : { claimId: automaticClaimId }),
         }, runId);
         if (!decision.continue || decision.runId !== runId) {
             throw new KiokukoError('CONFLICT', decision.warning ?? 'The active Enno-Oduno run cannot be resumed by this DSH session');
@@ -969,12 +1022,18 @@ export function createDshHostAdapter(ctx, options = {}) {
                 workUnitId: binding.workUnitId ?? null,
             });
             if (phase !== undefined && receiptOperation !== undefined) {
+                const executionAttempt = operation === 'enno_work_report'
+                    ? await runtime.withDatabase(database => readEnnoSnapshot(database, {
+                        runId: run.runId, workspace: run.workspace, orchestrationId: run.orchestrationId,
+                    }).workUnits.find(unit => unit.workUnit.id === binding.workUnitId)?.attemptCount ?? 0)
+                    : 0;
                 await runtime.withDatabase((database) => prepareTurnIntent(database, {
                     runId: run.runId,
                     dshSessionId: run.sessionId,
                     nativeTurn: run.turn,
                     phase,
                     contractRevision: binding.revision,
+                    executionAttempt,
                     ...(binding.workUnitId === undefined ? {} : { workUnitId: binding.workUnitId }),
                     inputDigest,
                     operation: receiptOperation,
@@ -1101,7 +1160,8 @@ export function createDshHostAdapter(ctx, options = {}) {
         return response.ennoOduno;
     };
     const boundaryAgents = new Map();
-    const boundaryEvent = (item, signal = new AbortController().signal) => ({
+    const boundarySignals = new Map();
+    const boundaryEvent = (item, signal = boundarySignals.get(item.sessionId) ?? new AbortController().signal) => ({
         agent: {
             id: item.agentId,
             sessionId: item.sessionId,
@@ -1113,6 +1173,87 @@ export function createDshHostAdapter(ctx, options = {}) {
         signal,
     });
     const readBoundaryState = async (item) => (runtime.withDatabase((database) => stateForRun(database, item)));
+    const askForRecoveryInstruction = async (input) => {
+        const agent = input.item.nativeAgent ?? agents?.get(input.item.agentId);
+        const signal = boundarySignals.get(input.item.sessionId) ?? new AbortController().signal;
+        if (userQuestions === undefined || agent === undefined)
+            return undefined;
+        try {
+            const result = await abortable(userQuestions.ask({
+                questions: [{
+                        id: input.questionId,
+                        header: 'Kiokuko stopped',
+                        question: input.title,
+                        detail: input.detail,
+                    }],
+                agent,
+                signal,
+            }), signal);
+            signal.throwIfAborted();
+            const answer = result.answers[0];
+            if (answer === undefined || answer.id !== input.questionId)
+                return undefined;
+            const value = answer.custom?.trim() || answer.selected[0]?.trim();
+            return value === undefined || value.length === 0 ? undefined : boundedUtf8Text(value, 8 * 1024);
+        }
+        catch {
+            signal.throwIfAborted();
+            // A broken/dismissed question surface must never become another retry
+            // loop. The durable waiting_user state remains the recovery boundary.
+            return undefined;
+        }
+    };
+    const loopRecoveryDetail = (snapshot, state, reason) => {
+        const workUnitId = state.directive?.workUnit?.id ?? null;
+        const workUnit = workUnitId === null
+            ? null
+            : snapshot.workUnits.find((candidate) => candidate.workUnit.id === workUnitId) ?? null;
+        const latestVerifier = snapshot.finalEvidence.at(-1);
+        return [
+            `Host status: phase=${snapshot.status}; nextAction=${state.nextAction}; role=${state.currentRole ?? 'none'}.`,
+            `Revision=${snapshot.revision}; mutationRevision=${snapshot.mutationRevision}; attempts=${snapshot.attempts}/${snapshot.contract.maxAttempts}.`,
+            workUnit === null
+                ? 'WorkUnit: none.'
+                : `WorkUnit ${workUnit.workUnit.id}: ${workUnit.workUnit.objective} (status=${workUnit.status}, attempts=${workUnit.attemptCount}).`,
+            latestVerifier === undefined
+                ? 'Latest verifier: none.'
+                : `Latest verifier ${latestVerifier.verifier.id}: ${latestVerifier.status}.`,
+            reason,
+            'Enter the actual current handling status and the concrete instruction to execute next. If work should stop, say so explicitly.',
+        ].join('\n');
+    };
+    const guardBoundaryEffect = async (item, job) => {
+        const guarded = await runtime.withDatabase((database) => withImmediateTransaction(database, () => {
+            const snapshot = readEnnoSnapshot(database, {
+                runId: item.runId, workspace: item.workspace, orchestrationId: item.orchestrationId,
+            });
+            const state = stateForSnapshot(snapshot);
+            const claim = claimBoundaryEffectInTransaction(database, job, ennoInstructionDigest(snapshot, state.directive), options.now?.() ?? new Date().toISOString());
+            return { snapshot, state, claim };
+        }));
+        if (guarded.claim.decision === 'deliver')
+            return true;
+        const answer = await askForRecoveryInstruction({
+            item,
+            questionId: `effect-${job.jobId.slice(0, 16)}`,
+            title: 'Kiokuko stopped before a fourth stateful boundary operation without progress.',
+            detail: loopRecoveryDetail(guarded.snapshot, guarded.state, `${job.kind} completed or was re-entered three times without authoritative Enno progress.`),
+        });
+        if (answer === undefined) {
+            await sessionMirror.markWaitingUser(item.sessionId);
+            return false;
+        }
+        await runtime.withDatabase((database) => withImmediateTransaction(database, () => {
+            resetBoundaryEffectGuardInTransaction(database, job, options.now?.() ?? new Date().toISOString());
+            resetLoopGuardForUserInTransaction(database, {
+                runId: item.runId,
+                dshSessionId: item.sessionId,
+                resolution: 'manual_user',
+                ...(options.now === undefined ? {} : { now: options.now() }),
+            });
+        }));
+        return true;
+    };
     const confirmBoundary = async (item, state) => {
         const confirmation = state.directive?.userFacingConfirmation;
         if (confirmation === undefined || state.contractRevision === null)
@@ -1128,6 +1269,7 @@ export function createDshHostAdapter(ctx, options = {}) {
                 }).revision);
             },
             submit: async (answer) => {
+                event.signal.throwIfAborted();
                 response = await runtime.withDatabase((database) => answerEnno(database, {
                     runId: item.runId,
                     workspace: item.workspace,
@@ -1180,6 +1322,7 @@ export function createDshHostAdapter(ctx, options = {}) {
             ...(advisoryEvidence === undefined ? {} : { advisoryEvidence }),
             runtime,
         });
+        event.signal.throwIfAborted();
         for (const message of messages) {
             agent.inject({ id: randomUUID(), role: 'user', content: [{ type: 'text', text: message.content }], source: { kind: 'plugin', plugin: 'kiokuko-dsh', form: 'instructions' } });
         }
@@ -1212,6 +1355,23 @@ export function createDshHostAdapter(ctx, options = {}) {
             return readBoundaryState(item);
         },
         validateBoundary: async ({ event }) => { await assertTurnBoundary(event); },
+        requestLoopRecovery: async ({ event, state, automaticCount }) => {
+            const item = currentForAgentEvent(event.agent.id, event.agent.sessionId, event.turn, event.agent.nativeSession, event.agent.nativeAgent);
+            if (item === undefined)
+                return undefined;
+            const snapshot = await runtime.withDatabase((database) => readEnnoSnapshot(database, {
+                runId: item.runId, workspace: item.workspace, orchestrationId: item.orchestrationId,
+            }));
+            const answer = await askForRecoveryInstruction({
+                item,
+                questionId: `legacy-loop-${item.runId.slice(0, 12)}`,
+                title: 'Kiokuko stopped before a fourth identical automatic continuation.',
+                detail: loopRecoveryDetail(snapshot, state, `The legacy turn controller continued the same instruction ${automaticCount} times without authoritative Enno progress.`),
+            });
+            if (answer === undefined)
+                await sessionMirror.markWaitingUser(item.sessionId);
+            return answer;
+        },
         confirmUser: async ({ event, state }) => {
             const item = currentForAgentEvent(event.agent.id, event.agent.sessionId, event.turn, event.agent.nativeSession, event.agent.nativeAgent);
             if (item === undefined)
@@ -1244,12 +1404,49 @@ export function createDshHostAdapter(ctx, options = {}) {
             }
             boundaryAgents.set(sessionId, nativeAgent);
         },
-        process: async (job) => {
+        process: async (job, signal) => {
+            boundarySignals.set(job.dshSessionId, signal);
             const item = currentSession(job.dshSessionId);
             if (item === undefined || item.closed || item.runId !== job.runId || item.turn < job.nativeTurn) {
                 throw new Error('kiokuko-dsh boundary job has no exact live run binding');
             }
-            if (job.kind.startsWith('retry_') || job.kind === 'ask_akinator') {
+            if ((job.kind === 'confirmation' || job.kind === 'final_verification' || job.kind === 'advisory')
+                && !await guardBoundaryEffect(item, job)) {
+                return { kind: 'waiting_user' };
+            }
+            if (job.kind.startsWith('retry_')) {
+                return { kind: 'completed', nextKind: 'delivery' };
+            }
+            if (job.kind === 'ask_akinator') {
+                const snapshot = await runtime.withDatabase((database) => readEnnoSnapshot(database, {
+                    runId: item.runId, workspace: item.workspace, orchestrationId: item.orchestrationId,
+                }));
+                const state = stateForSnapshot(snapshot);
+                const pending = await runtime.withDatabase((database) => readPendingOutbox(database, item.sessionId)
+                    .find((candidate) => candidate.receiptId === job.receiptId));
+                const validationFact = boundedMessageText(pending?.message);
+                const answer = await askForRecoveryInstruction({
+                    item,
+                    questionId: `validation-${job.receiptId.slice(0, 16)}`,
+                    title: 'Kiokuko validation repeatedly failed and needs your instruction.',
+                    detail: loopRecoveryDetail(snapshot, state, validationFact ?? 'The same validation constraint was rejected repeatedly.'),
+                });
+                if (answer === undefined) {
+                    await sessionMirror.markWaitingUser(item.sessionId);
+                    return { kind: 'waiting_user' };
+                }
+                await runtime.withDatabase((database) => withImmediateTransaction(database, () => {
+                    resetLoopGuardForUserInTransaction(database, {
+                        runId: item.runId,
+                        dshSessionId: item.sessionId,
+                        resolution: 'manual_user',
+                        ...(options.now === undefined ? {} : { now: options.now() }),
+                    });
+                    const outbox = readPendingOutbox(database, item.sessionId).find((candidate) => candidate.receiptId === job.receiptId);
+                    if (outbox !== undefined) {
+                        replacePendingOutboxMessageInTransaction(database, job.receiptId, recoveryMessage(outbox.continuationId, answer), options.now?.() ?? new Date().toISOString());
+                    }
+                }));
                 return { kind: 'completed', nextKind: 'delivery' };
             }
             if (job.kind === 'classify_boundary') {
@@ -1288,7 +1485,8 @@ export function createDshHostAdapter(ctx, options = {}) {
                 const directive = state.directive?.advisoryRound;
                 if (directive === undefined)
                     return { kind: 'completed', nextKind: 'classify_boundary' };
-                const result = await advisoryRunner.run({ directive, signal: new AbortController().signal });
+                const result = await advisoryRunner.run({ directive, signal });
+                signal.throwIfAborted();
                 await submitAdvisory(result, { event: boundaryEvent(item), state });
                 return { kind: 'completed', nextKind: 'classify_boundary' };
             }
@@ -1316,6 +1514,60 @@ export function createDshHostAdapter(ctx, options = {}) {
             }
             catch { /* non-vetoing cache */ }
         },
+        beforeDelivery: async (job, outbox, signal) => {
+            boundarySignals.set(job.dshSessionId, signal);
+            if (isLoopRecoveryMessage(outbox.message))
+                return 'deliver';
+            const item = currentSession(job.dshSessionId);
+            if (item === undefined || item.closed || item.runId !== job.runId)
+                return 'superseded';
+            const guarded = await runtime.withDatabase((database) => withImmediateTransaction(database, () => {
+                const snapshot = readEnnoSnapshot(database, {
+                    runId: item.runId, workspace: item.workspace, orchestrationId: item.orchestrationId,
+                });
+                const state = stateForSnapshot(snapshot);
+                const claim = claimAutomaticContinuationInTransaction(database, {
+                    claimId: outbox.continuationId,
+                    runId: item.runId,
+                    dshSessionId: item.sessionId,
+                    instructionDigest: ennoInstructionDigest(snapshot, state.directive),
+                    ...(options.now === undefined ? {} : { now: options.now() }),
+                });
+                const shouldAsk = claim.decision === 'wait_user'
+                    && claimLoopRecoveryQuestionInTransaction(database, claim.claimId, options.now?.() ?? new Date().toISOString());
+                return { snapshot, state, claim, shouldAsk };
+            }));
+            if (guarded.claim.decision === 'deliver')
+                return 'deliver';
+            if (!guarded.shouldAsk) {
+                await sessionMirror.markWaitingUser(item.sessionId);
+                return 'waiting_user';
+            }
+            const answer = await askForRecoveryInstruction({
+                item,
+                questionId: `loop-${guarded.claim.claimId.slice(0, 16)}`,
+                title: 'Kiokuko stopped before a fourth identical automatic continuation.',
+                detail: loopRecoveryDetail(guarded.snapshot, guarded.state, [
+                    `The same instruction was automatically continued ${guarded.claim.ordinal - 1} times without authoritative Enno progress.`,
+                    boundedMessageText(outbox.message),
+                ].filter((value) => value !== undefined).join('\n')),
+            });
+            if (answer === undefined) {
+                await sessionMirror.markWaitingUser(item.sessionId);
+                return 'waiting_user';
+            }
+            await runtime.withDatabase((database) => withImmediateTransaction(database, () => {
+                resetLoopGuardForUserInTransaction(database, {
+                    runId: item.runId,
+                    dshSessionId: item.sessionId,
+                    resolution: 'user_answer',
+                    claimId: guarded.claim.claimId,
+                    ...(options.now === undefined ? {} : { now: options.now() }),
+                });
+                replacePendingOutboxMessageInTransaction(database, job.receiptId, recoveryMessage(outbox.continuationId, answer), options.now?.() ?? new Date().toISOString());
+            }));
+            return 'deliver';
+        },
         dispatch: async (job, outbox) => {
             const item = currentSession(job.dshSessionId);
             const nativeAgent = (boundaryAgents.get(job.dshSessionId) ?? agents?.get(job.dshSessionId));
@@ -1324,13 +1576,81 @@ export function createDshHostAdapter(ctx, options = {}) {
             }
             nativeAgent.steer(outbox.message);
         },
+        onWaitingUser: async (job, error, signal) => {
+            boundarySignals.set(job.dshSessionId, signal);
+            const item = currentSession(job.dshSessionId);
+            if (item === undefined || item.closed || item.runId !== job.runId)
+                return false;
+            await sessionMirror.markWaitingUser(item.sessionId);
+            const snapshot = await runtime.withDatabase((database) => readEnnoSnapshot(database, {
+                runId: item.runId, workspace: item.workspace, orchestrationId: item.orchestrationId,
+            }));
+            const answer = await askForRecoveryInstruction({
+                item,
+                questionId: `boundary-${job.jobId.slice(0, 16)}`,
+                title: 'Kiokuko stopped after three boundary-processing failures.',
+                detail: loopRecoveryDetail(snapshot, stateForSnapshot(snapshot), `Last boundary error: ${(error instanceof Error ? error.message : String(error)).slice(0, 2_000)}`),
+            });
+            if (answer === undefined)
+                return false;
+            await runtime.withDatabase((database) => withImmediateTransaction(database, () => {
+                resetLoopGuardForUserInTransaction(database, {
+                    runId: item.runId,
+                    dshSessionId: item.sessionId,
+                    resolution: 'manual_user',
+                    ...(options.now === undefined ? {} : { now: options.now() }),
+                });
+                const outbox = readPendingOutbox(database, item.sessionId).find((candidate) => candidate.receiptId === job.receiptId);
+                if (outbox !== undefined) {
+                    replacePendingOutboxMessageInTransaction(database, job.receiptId, recoveryMessage(outbox.continuationId, answer), options.now?.() ?? new Date().toISOString());
+                }
+                database.prepare(`
+          UPDATE dsh_boundary_jobs
+             SET status = 'pending', attempt_count = 0, available_at = ?,
+                 last_error_code = NULL, last_error_message = NULL, updated_at = ?
+           WHERE job_id = ? AND status = 'waiting_user'
+        `).run(options.now?.() ?? new Date().toISOString(), options.now?.() ?? new Date().toISOString(), job.jobId);
+            }));
+            return true;
+        },
+    });
+    const completionReporter = new DshCompletionReporter(runtime, async (session) => {
+        if (sessions?.flush === undefined)
+            throw new Error('Native report flush is unavailable');
+        await sessions.flush(session);
     });
+    const deliverCompletionReport = async (session) => {
+        if (session !== undefined && typeof session.append === 'function') {
+            await completionReporter.deliver(session);
+        }
+    };
     const rehydrateBoundarySession = async (nativeAgent) => {
         const nativeSession = nativeAgent.session ?? sessions?.get(nativeAgent.id);
         const sessionId = nativeSession?.id;
         const cwd = nativeSession?.header?.cwd;
         if (sessionId === undefined || cwd === undefined || typeof nativeSession?.snapshotEvents !== 'function')
             return;
+        if (nativeAgent.status === 'running')
+            return;
+        await deliverCompletionReport(nativeSession);
+        const terminal = await runtime.withDatabase(database => database.prepare(`
+      SELECT report.run_id AS runId, report.native_turn AS nativeTurn, contract.status
+      FROM dsh_completion_reports AS report JOIN ledger_runs AS run ON run.run_id = report.run_id
+      JOIN enno_contracts AS contract ON contract.run_id = report.run_id
+      WHERE report.dsh_session_id = ? AND report.status = 'delivered' AND run.status = 'active'
+        AND contract.status IN ('completed', 'blocked', 'cancelled')
+    `).all(sessionId));
+        for (const restored of terminal) {
+            if (currentSession(sessionId)?.runId === restored.runId)
+                continue;
+            const end = dshTurnBoundarySeq(nativeSession, restored.nativeTurn, 'end');
+            if (end === undefined)
+                continue;
+            await runLifecycle.closeTurn({ runId: restored.runId,
+                status: restored.status === 'completed' ? 'completed' : restored.status === 'cancelled' ? 'cancelled' : 'failed',
+                sourceEndSeq: end,
+            });
+        }
         const pending = await runtime.withDatabase((database) => database.prepare(`
       SELECT receipt.run_id AS runId, receipt.native_turn AS nativeTurn,
              intake.task_text AS task
@@ -1371,6 +1691,7 @@ export function createDshHostAdapter(ctx, options = {}) {
         void rehydrateBoundarySession(nativeAgent).catch(() => undefined);
     }
     const resolveIdleClose = async (agentId, sessionId, nativeSession, nativeAgent) => {
+        await deliverCompletionReport(nativeSession);
         const item = currentForAgentEvent(agentId, sessionId, undefined, nativeSession, nativeAgent);
         if (item === undefined || item.closed)
             return undefined;
@@ -1385,9 +1706,9 @@ export function createDshHostAdapter(ctx, options = {}) {
         if (item.prepared.intake.profile.taskType === 'chat')
             return undefined;
         if (state.status === 'completed' || state.nextAction === 'complete') {
-            return item.failed
-                ? { runId: item.runId, status: 'failed' }
-                : { runId: item.runId, status: 'completed', terminalTurn: item.turn };
+            // A provider failure while wording the final response cannot undo
+            // already verified completion. The durable host report covers it.
+            return { runId: item.runId, status: 'completed', terminalTurn: item.turn };
         }
         // Idle means the driver has no active work, not that Enno reached a
         // terminal state. Keep only genuinely resumable active states open.
@@ -1403,14 +1724,18 @@ export function createDshHostAdapter(ctx, options = {}) {
         const item = currentSession(sessionId);
         if (item === undefined || item.closed || item.nativeSession !== nativeSession)
             return undefined;
+        const state = await runtime.withDatabase((database) => stateForRun(database, item));
+        if (state.status === 'completed') {
+            await deliverCompletionReport(nativeSession);
+            return { runId: item.runId, status: 'completed', terminalTurn: item.turn };
+        }
         if (item.failed)
             return { runId: item.runId, status: 'failed' };
-        const state = await runtime.withDatabase((database) => stateForRun(database, item));
         if (state.status === 'cancelled')
             return { runId: item.runId, status: 'cancelled' };
         if (state.status === 'blocked' || state.nextAction === 'report_blocker')
             return { runId: item.runId, status: 'failed' };
-        if (item.prepared.intake.profile.taskType === 'chat' || state.status === 'completed' || state.nextAction === 'complete') {
+        if (item.prepared.intake.profile.taskType === 'chat' || state.nextAction === 'complete') {
             return { runId: item.runId, status: 'completed', terminalTurn: item.turn };
         }
         return { runId: item.runId, status: 'cancelled' };
@@ -1578,6 +1903,27 @@ export function createDshHostAdapter(ctx, options = {}) {
             }
             if (!turnEndedWithError || (!durableRecoverable && !locallyRecoverable))
                 inMemoryClaims.delete(claimKey);
+            if (reason?.kind === 'completed' && item.prepared.ennoOduno.applicable) {
+                await runtime.withDatabase(database => {
+                    const state = stateForRun(database, item);
+                    if (state.nextAction === 'complete' || state.nextAction === 'report_blocker'
+                        || state.status === 'cancelled' || state.contractRevision === null)
+                        return;
+                    const phase = state.nextAction === 'submit_ideal' ? 'ideal'
+                        : state.nextAction === 'submit_plan' || state.nextAction === 'ask_user_confirmation' ? 'planning'
+                            : state.nextAction === 'execute_work_unit' ? 'work_unit'
+                                : state.nextAction === 'submit_meditation' ? 'meditation' : 'final_review';
+                    const operation = phase === 'ideal' ? 'ideal_submit' : phase === 'planning' ? 'plan_submit'
+                        : phase === 'work_unit' ? 'work_report' : phase === 'meditation' ? 'meditation_submit' : 'finish';
+                    enqueueUnsubmittedTurn(database, {
+                        runId: item.runId, dshSessionId: item.sessionId, nativeTurn: item.turn,
+                        phase, operation, contractRevision: state.contractRevision,
+                        ...(state.directive?.workUnit?.id === undefined ? {} : { workUnitId: state.directive.workUnit.id }),
+                        inputDigest: canonicalContentHash({ nextAction: state.nextAction, source: 'unsubmitted_turn' }),
+                        idempotencyKey: `dsh-unsubmitted:${item.turn}`, nextAction: state.nextAction,
+                    });
+                });
+            }
             boundaryWorker.kick(item.sessionId, item.nativeAgent);
         })().catch(() => {
             // Observe-only DSH listeners must never veto the native event.
@@ -1680,19 +2026,18 @@ export function createDshHostAdapter(ctx, options = {}) {
             for (const item of remainingRuns) {
                 try {
                     let status;
-                    if (item.failed)
-                        status = 'failed';
-                    else if (item.prepared.intake.profile.taskType === 'chat')
-                        status = 'cancelled';
+                    if (item.prepared.intake.profile.taskType === 'chat')
+                        status = item.failed ? 'failed' : 'cancelled';
                     else {
                         const state = await runtime.withDatabase((database) => stateForRun(database, item));
                         status = state.status === 'completed' || state.nextAction === 'complete'
                             ? 'completed'
-                            : state.status === 'blocked' || state.nextAction === 'report_blocker'
+                            : item.failed || state.status === 'blocked' || state.nextAction === 'report_blocker'
                                 ? 'failed'
                                 : 'cancelled';
                     }
                     if (status === 'completed') {
+                        await deliverCompletionReport(item.nativeSession);
                         if (item.nativeSession === undefined || sessions?.flush === undefined) {
                             throw new KiokukoError('CONFLICT', 'Completed DSH run requires its exact native session checkpoint');
                         }
@@ -1741,6 +2086,7 @@ export function createDshHostAdapter(ctx, options = {}) {
             activeModeRequests.clear();
             advisoryRounds.clear();
             boundaryAgents.clear();
+            boundarySignals.clear();
             resumedTurns.clear();
             resumedLeases.clear();
             inMemoryClaims.clear();