kiokuko-dsh 0.1.21 → 0.1.22

package/dist/dsh/host-adapter.js

@@ -31,11 +31,12 @@ 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, 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 { DshSessionLogExportService } from './session-log-export.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 +95,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)
@@ -640,10 +678,20 @@ export function createDshHostAdapter(ctx, options = {}) {
             if (humanPresent) {
                 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 +800,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');
@@ -1113,6 +1164,83 @@ 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);
+        if (userQuestions === undefined || agent === undefined)
+            return undefined;
+        try {
+            const result = await userQuestions.ask({
+                questions: [{
+                        id: input.questionId,
+                        header: 'Kiokuko stopped',
+                        question: input.title,
+                        detail: input.detail,
+                    }],
+                agent,
+            });
+            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 {
+            // 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)
@@ -1212,6 +1340,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)
@@ -1249,7 +1394,43 @@ export function createDshHostAdapter(ctx, options = {}) {
             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') {
@@ -1316,6 +1497,59 @@ export function createDshHostAdapter(ctx, options = {}) {
             }
             catch { /* non-vetoing cache */ }
         },
+        beforeDelivery: async (job, outbox) => {
+            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,6 +1558,42 @@ export function createDshHostAdapter(ctx, options = {}) {
             }
             nativeAgent.steer(outbox.message);
         },
+        onWaitingUser: async (job, error) => {
+            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 rehydrateBoundarySession = async (nativeAgent) => {
         const nativeSession = nativeAgent.session ?? sessions?.get(nativeAgent.id);