@raidiant/notifai 11.6.3-beta.2 → 11.7.0-beta.2

package/dist/hook-lifecycle.js

@@ -1,4 +1,6 @@
 import { randomBytes } from 'node:crypto';
+import { confirmNativeAnswerTarget, recordConfirmedNativeAnswerTarget } from './native-answer-operation.js';
+import { markCodexOrdinaryPresentation, mayRetireFromPrompt, reserveCurrentCodexQuestion } from './codex-question-bindings.js';
 import { ApiCallError, isRetryableReplyPollError } from './client.js';
 import { withFileLock } from './file-lock.js';
 import { HARNESS_CAPABILITIES } from './harnesses.js';
@@ -7,9 +9,9 @@ import { acknowledgementBlockContext, amendAcceptedAnswers, answersContext, clas
 import { clearMatchingProjectSession, writeProjectSession } from './hook-project-sessions.js';
 import { acquireClaimFile, releaseClaimFile, claimHandoffState, claimQuestionPush, releaseQuestionPush } from './hook-question-lock.js';
 import { closeQuietly, drainOrphanRetirements, drainRetirements, finalizeReplies, selectedForClaimedDelivery, orphanRetirements, pendingAnsweredByPrompt, retirePendings, retiringQuestion, } from './hook-question-retirement.js';
-import { admitQueuedQuestion, clearFrozenSubmission, dropPendingQuestion, isSamePending, pendingQuestions, questionSubmissionAttempted, queuedQuestionStillEligible, rememberQuestionState, sourceContextAtHookEvent, summarizeRequestIds, } from './hook-question-state.js';
-import { clearSessionState, markSessionEnded, pendingList, readSessionState, readSessionIncarnation, sessionHasEnded, sessionStatePath, updateSessionState, writeSessionState, writeSessionStateUnlocked, recordSessionNotified, } from './hook-session-state.js';
-import { currentProcessIdentity } from './process-identity.js';
+import { admitQueuedQuestion, replaceFrozenSubmission, dropPendingQuestion, isSamePending, pendingQuestions, questionSubmissionAttempted, queuedQuestionStillEligible, rememberQuestionState, sourceContextAtHookEvent, summarizeRequestIds, } from './hook-question-state.js';
+import { clearSessionStateUnlocked, markSessionEnded, pendingList, readSessionState, readSessionIncarnation, readSessionEndMarker, sessionHasEnded, sessionStatePath, updateSessionState, writeSessionStateUnlocked, recordSessionNotified, } from './hook-session-state.js';
+import { currentProcessIdentity, processIdentityLiveness } from './process-identity.js';
 import { userPromptContextOutput } from './session-activation.js';
 import { answersAlreadyWritten, beginHandOff, recordUnclaimedHandOffs, recoverDeliveryJournal, sweepDeliveryJournals, } from './session-delivery.js';
 import { WRITE_ABORTED_REASON } from './wake-support.js';
@@ -120,12 +122,13 @@ function submitQuestion(ctx, sessionId, entry, intent, notes) {
             if (receipt.request_id !== intent.request_id) {
                 throw new Error(`server replay returned ${receipt.request_id}, expected reserved ${intent.request_id}`);
             }
+            recordConfirmedNativeAnswerTarget(sessionId, ctx.env, { ...entry, request_id: receipt.request_id });
             // Wakes this session's dormant Session Attendant.
             recordSessionNotified(sessionId, ctx.env, ctx.now());
             return receipt;
-        });
+        }, ctx.service_identity);
         if (attempt === null)
-            notes.push('the question was retired before submission; not uploading it');
+            notes.push('the question was retired or its Approved Machine changed before submission; not uploading it');
         return attempt;
     }
     catch (err) {
@@ -326,9 +329,12 @@ function claimMarker(response) {
     return selectedForClaimedDelivery(response) ? { delivery_claim: true } : {};
 }
 /** Close several windows concurrently without confusing failure with silence. */
-async function finalizePendings(ctx, pending, disposition) {
+async function finalizePendings(ctx, sessionId, pending, disposition) {
     return Promise.all(pending.map(async (entry) => {
         const response = await finalizeReplies(ctx, entry.request_id, disposition);
+        if (response !== null && response.request_id === entry.request_id) {
+            recordConfirmedNativeAnswerTarget(sessionId, ctx.env, entry);
+        }
         ctx.log?.info('hook.retirement', {
             request_id: entry.request_id,
             attempted: true,
@@ -500,7 +506,7 @@ async function answerPrompt(ctx, envelope, sessionId, reminder) {
         if (envelope.cwd !== undefined && ctx.harness !== undefined) {
             writeProjectSession(envelope.cwd, ctx.env, sessionId, ctx.now(), ctx.harness);
         }
-        const stdout = userPromptContextOutput(ctx.harness, withReminder(reminder, answersContext(answers, state.accepted.remaining)));
+        const stdout = userPromptContextOutput(ctx.harness, withReminder(reminder, prepareOrdinaryAnswersContext(ctx, sessionId, answers, state.accepted.remaining)));
         if (stdout !== undefined) {
             notes.push('the journaled device answer was added to the user\'s new turn');
             const selected = unclaimedSelectedAnswers(sessionId, ctx.env, answers);
@@ -525,7 +531,7 @@ async function answerPrompt(ctx, envelope, sessionId, reminder) {
     let lateAnswers = [];
     if (live.length > 0) {
         const { answered, transientTrouble, permanentFailures } = await pollPendingReplies(ctx, live, LATE_PROMPT_POLL_SECONDS);
-        const finalized = await finalizePendings(ctx, answered.map((entry) => entry.pending));
+        const finalized = await finalizePendings(ctx, sessionId, answered.map((entry) => entry.pending));
         lateAnswers = answered.map((entry) => {
             const response = finalized.find((candidate) => isSamePending(candidate.pending, entry.pending))?.response;
             const replies = response?.replies.length ? response.replies : entry.replies;
@@ -554,7 +560,7 @@ async function answerPrompt(ctx, envelope, sessionId, reminder) {
         if (permanentFailure !== null)
             notes.push(permanentFailure);
     }
-    const matched = pendingAnsweredByPrompt(envelope.prompt, pendingList(state));
+    const matched = pendingAnsweredByPrompt(envelope.prompt, pendingList(state)).filter(entry => mayRetireFromPrompt(state, entry));
     for (const entry of matched) {
         ctx.log?.info('hook.retirement', {
             request_id: entry.request_id,
@@ -569,7 +575,7 @@ async function answerPrompt(ctx, envelope, sessionId, reminder) {
     // the gap after erasing the only request/collapse/device identifiers.
     const updated = updateSessionState(sessionId, ctx.env, (current) => {
         const retiring = [...(current.retiring ?? [])];
-        const matchedNow = pendingAnsweredByPrompt(envelope.prompt, pendingList(current));
+        const matchedNow = pendingAnsweredByPrompt(envelope.prompt, pendingList(current)).filter(entry => mayRetireFromPrompt(current, entry));
         const unmatched = pendingList(current).filter((entry) => !matchedNow.some((item) => isSamePending(item, entry)));
         for (const entry of matchedNow.filter(questionSubmissionAttempted)) {
             const retirement = retiringQuestion(entry, 'answered_elsewhere', envelope.cwd);
@@ -616,7 +622,7 @@ async function answerPrompt(ctx, envelope, sessionId, reminder) {
         // UserPromptSubmit can add context to the turn already beginning. Keep the
         // accepted-answer journal until the agent acknowledges: if this process or
         // host dies around stdout, a later prompt or Stop safely replays it.
-        const stdout = userPromptContextOutput(ctx.harness, withReminder(reminder, answersContext([...(readSessionState(sessionId, ctx.env).delivered_answers ?? []), ...lateAnswers], pendingList(updated).length)));
+        const stdout = userPromptContextOutput(ctx.harness, withReminder(reminder, prepareOrdinaryAnswersContext(ctx, sessionId, [...(readSessionState(sessionId, ctx.env).delivered_answers ?? []), ...lateAnswers], pendingList(updated).length)));
         if (stdout !== undefined)
             notes.push('the late device answer was added to the user\'s new turn');
         else
@@ -646,7 +652,7 @@ async function answerPrompt(ctx, envelope, sessionId, reminder) {
     }
     const delivered = readSessionState(sessionId, ctx.env).delivered_answers ?? [];
     const stdout = delivered.length > 0
-        ? userPromptContextOutput(ctx.harness, withReminder(reminder, answersContext(delivered, pendingList(updated).length)))
+        ? userPromptContextOutput(ctx.harness, withReminder(reminder, prepareOrdinaryAnswersContext(ctx, sessionId, delivered, pendingList(updated).length)))
         : undefined;
     return {
         notes,
@@ -657,6 +663,16 @@ async function answerPrompt(ctx, envelope, sessionId, reminder) {
         settlementRequired: needsQuestionSettlement(updated, ctx.harness),
     };
 }
+/** Legacy prompt/Stop context routes bypass the common drain. Select ordinary
+ * presentation durably before returning any answer bytes to those writers.
+ */
+function prepareOrdinaryAnswersContext(ctx, sessionId, answers, remaining) {
+    if (ctx.harness === 'codex') {
+        const ids = new Set(answers.flatMap(answer => answer.pending.question_id === undefined ? [] : [answer.pending.question_id]));
+        updateSessionState(sessionId, ctx.env, state => markCodexOrdinaryPresentation(state, ids));
+    }
+    return answersContext(answers, remaining);
+}
 function needsQuestionSettlement(state, harness) {
     return pendingList(state).some((entry) => entry.request_id === undefined || harness === 'codex');
 }
@@ -952,13 +968,16 @@ async function deliverAcceptedAnswers(ctx, sessionId, route, accepted, notes, cw
         return withFileLock(`${file}.lock`, () => {
             if (sessionHasEnded(sessionId, ctx.env))
                 return false;
-            const current = readSessionState(sessionId, ctx.env);
+            let current = readSessionState(sessionId, ctx.env);
             if (current.accepted === undefined)
                 return false;
+            const acceptedBeforeCommit = current.accepted;
             deliveryCommitted = true;
+            if (ctx.harness === 'codex')
+                current = markCodexOrdinaryPresentation(current, new Set(answered.flatMap(answer => answer.pending.question_id === undefined ? [] : [answer.pending.question_id])));
             writeSessionStateUnlocked(file, sessionId, {
                 ...current,
-                accepted: { ...current.accepted, delivery_committed_at: ctx.now() },
+                accepted: { ...acceptedBeforeCommit, delivery_committed_at: ctx.now() },
             });
             return true;
         });
@@ -1234,7 +1253,7 @@ async function handleClaimedStop(ctx, envelope, sessionId, pending, notes, hardD
             await retirePendings(ctx, envelope, sessionId, permanentlyRejected, 'expired');
         }
         if (answered.length > 0) {
-            const finalized = await finalizePendings(ctx, answered.map((entry) => entry.pending), answerCloseDisposition(ctx, route));
+            const finalized = await finalizePendings(ctx, sessionId, answered.map((entry) => entry.pending), answerCloseDisposition(ctx, route));
             const authoritative = answered.map((entry) => {
                 const response = finalized.find((candidate) => isSamePending(candidate.pending, entry.pending))?.response;
                 const replies = response?.replies.length ? response.replies : entry.replies;
@@ -1329,6 +1348,11 @@ export async function submitSessionQuestions(ctx, envelope, hardDeadlineAt = ctx
         // its own notification — one ask never stands in for another.
         const submitted = [];
         for (const entry of pendingList(readSessionState(sessionId, ctx.env)).filter((entry) => entry.request_id === undefined)) {
+            if (entry.service_identity !== undefined && (entry.service_identity.machine_id !== ctx.service_identity?.machine_id ||
+                entry.service_identity.base_url !== ctx.service_identity?.base_url)) {
+                notes.push('the registered question belongs to a different Approved Machine; preserving it without uploading');
+                continue;
+            }
             if (!queuedQuestionStillEligible(sessionId, ctx.env, entry)) {
                 notes.push('the question was retired before submission; not uploading it');
                 continue;
@@ -1362,6 +1386,8 @@ export async function submitSessionQuestions(ctx, envelope, hardDeadlineAt = ctx
                     notes.push(prepared.error);
                     continue;
                 }
+                if (entry.service_identity !== undefined)
+                    prepared.service_identity = entry.service_identity;
                 intent = prepared;
                 // Durable before submit. If the server commits and the response is lost,
                 // the reserved request id still lets this owner poll and finalize the
@@ -1424,8 +1450,11 @@ export async function submitSessionQuestions(ctx, envelope, hardDeadlineAt = ctx
                         message: err.message,
                     });
                     if (entry.submission !== undefined) {
+                        if (readSessionState(sessionId, ctx.env).native_answer_operations?.some(op => op.question_id === entry.question_id)) {
+                            notes.push('the original submission was rejected; preserving its native answer operation without minting a replacement question');
+                            continue;
+                        }
                         notes.push(`question submission was rejected (${err.code}, HTTP ${err.status}); reminting the draft in the current contract instead of replaying the frozen one`);
-                        clearFrozenSubmission(sessionId, ctx.env, entry);
                         const reminted = await prepareQuestionSubmission(ctx, {
                             summary: entry.summary,
                             ...(entry.body !== undefined ? { body: entry.body } : {}),
@@ -1437,20 +1466,18 @@ export async function submitSessionQuestions(ctx, envelope, hardDeadlineAt = ctx
                             ownerDeadlineAt,
                         });
                         if ('error' in reminted) {
-                            dropPendingQuestion(sessionId, ctx.env, entry);
+                            // Preserve the original intent; preparation can race an early
+                            // native answer and is not proof that its obligation disappeared.
                             notes.push(reminted.error);
                             continue;
                         }
+                        if (entry.service_identity !== undefined)
+                            reminted.service_identity = entry.service_identity;
+                        if (!replaceFrozenSubmission(sessionId, ctx.env, entry, intent, reminted)) {
+                            notes.push('the original submission changed or has a native answer obligation; no replacement was admitted');
+                            continue;
+                        }
                         intent = reminted;
-                        updateSessionState(sessionId, ctx.env, (current) => {
-                            const list = pendingList(current);
-                            const index = list.findIndex((candidate) => isSamePending(candidate, entry));
-                            if (index < 0)
-                                return current;
-                            const next = [...list];
-                            next[index] = { ...next[index], submission: reminted };
-                            return { ...current, pending: next };
-                        });
                         try {
                             if (!canSubmitCompleteWindow(ctx, intent, replyWindowSeconds)) {
                                 notes.push('draft recovery consumed the admission allowance; preserving the frozen intent for a successor owner');
@@ -1540,8 +1567,11 @@ export async function submitSessionQuestions(ctx, envelope, hardDeadlineAt = ctx
             // nobody listening.
             if (admissionConfirmed) {
                 updateSessionState(sessionId, ctx.env, (current) => {
+                    current = confirmNativeAnswerTarget(current, live);
                     const list = pendingList(current);
-                    const index = list.findIndex((candidate) => isSamePending(candidate, entry) && candidate.request_id === undefined);
+                    const index = list.findIndex((candidate) => isSamePending(candidate, entry) && candidate.request_id === undefined &&
+                        (candidate.service_identity === undefined || (candidate.service_identity.machine_id === ctx.service_identity?.machine_id &&
+                            candidate.service_identity.base_url === ctx.service_identity?.base_url)));
                     if (index >= 0) {
                         const next = [...list];
                         next[index] = live;
@@ -1603,7 +1633,7 @@ async function escalate(ctx, envelope, sessionId, notes, hardDeadlineAt, route,
     if (anomalous.length > 0)
         notes.push('server committed an answer deadline beyond this process owner; reconciling the anomalous window');
     const staleLive = live.filter((entry) => entry.reply_deadline_at === undefined || entry.reply_deadline_at <= ctx.now() || anomalous.includes(entry));
-    const finalizedStale = await finalizePendings(ctx, staleLive, answerCloseDisposition(ctx, route));
+    const finalizedStale = await finalizePendings(ctx, sessionId, staleLive, answerCloseDisposition(ctx, route));
     const staleAnswers = finalizedStale
         .map(finalizedAnswer)
         .filter((entry) => entry !== null);
@@ -1705,7 +1735,7 @@ async function escalate(ctx, envelope, sessionId, notes, hardDeadlineAt, route,
             entry.reply_deadline_at <= waitDeadline ||
             waited.permanentFailures.has(entry.request_id));
         const stillAnswerable = activeWaiting.filter((entry) => !expired.includes(entry));
-        const finalized = await finalizePendings(ctx, expired, answerCloseDisposition(ctx, route));
+        const finalized = await finalizePendings(ctx, sessionId, expired, answerCloseDisposition(ctx, route));
         const finalAnswers = finalized
             .map(finalizedAnswer)
             .filter((entry) => entry !== null);
@@ -1750,7 +1780,7 @@ async function escalate(ctx, envelope, sessionId, notes, hardDeadlineAt, route,
         return { notes };
     }
     const polledAnswered = activeWaiting.filter((entry) => waited.byRequest.has(entry.request_id));
-    const finalizedAnswered = await finalizePendings(ctx, polledAnswered, answerCloseDisposition(ctx, route));
+    const finalizedAnswered = await finalizePendings(ctx, sessionId, polledAnswered, answerCloseDisposition(ctx, route));
     const answered = [];
     for (const finalized of finalizedAnswered) {
         const entry = finalized.pending;
@@ -1797,7 +1827,7 @@ export function handleSessionEnd(env, envelope, now = Date.now(), preserveAccept
         return { notes, log: { outcome: 'ignored', reason: 'missing-session-id' } };
     // Publish cancellation before reading or clearing anything. In-flight Stop
     // writers use the same session lock, so none can recreate state after this.
-    markSessionEnded(sessionId, env, now);
+    const ending = markSessionEnded(sessionId, env, now);
     if (envelope.cwd !== undefined)
         clearMatchingProjectSession(envelope.cwd, env, sessionId);
     const state = readSessionState(sessionId, env);
@@ -1840,47 +1870,60 @@ export function handleSessionEnd(env, envelope, now = Date.now(), preserveAccept
         orphanRetirements(env, orphans, now);
         notes.push(`queued ${orphans.length} question${orphans.length > 1 ? 's' : ''} for retirement on the next hook`);
     }
-    if ((preserveAccepted && state.accepted !== undefined) ||
-        (state.acknowledgement_due?.length ?? 0) > 0 ||
-        (state.message_acknowledgement_due?.length ?? 0) > 0) {
-        const preserved = { ...stateWithHistory };
-        if (!preserveAccepted)
-            delete preserved.accepted;
-        if (!preserveAccepted)
-            delete preserved.waiting_answers;
-        delete preserved.input_wake;
-        delete preserved.pending;
-        delete preserved.retiring;
-        delete preserved.acknowledgement_blocks;
-        if ((preserved.acknowledgement_due?.length ?? 0) === 0) {
-            delete preserved.acknowledgement_due;
+    return withFileLock(`${sessionStatePath(sessionId, env)}.lock`, () => {
+        const marker = readSessionEndMarker(sessionId, env);
+        if (marker?.stamp?.mono !== ending.stamp?.mono ||
+            (readSessionIncarnation(sessionId, env)?.key ?? null) !== ending.ends) {
+            return { notes, log: { outcome: 'preserved', reason: 'session-resumed-during-cleanup' } };
+        }
+        // A committed receipt can arrive after the end marker. Preserve the fresh
+        // obligation state rather than restoring the earlier cleanup snapshot.
+        const state = readSessionState(sessionId, env);
+        stateWithHistory = { ...state, ...(stateWithHistory.question_history === undefined ? {} : { question_history: stateWithHistory.question_history }) };
+        if ((preserveAccepted && state.accepted !== undefined) ||
+            (state.acknowledgement_due?.length ?? 0) > 0 ||
+            (state.message_acknowledgement_due?.length ?? 0) > 0 ||
+            (state.native_answer_operations?.length ?? 0) > 0 ||
+            (state.codex_question_bindings?.length ?? 0) > 0) {
+            const preserved = { ...stateWithHistory };
+            if (!preserveAccepted)
+                delete preserved.accepted;
+            if (!preserveAccepted)
+                delete preserved.waiting_answers;
+            delete preserved.input_wake;
+            delete preserved.pending;
+            delete preserved.retiring;
+            delete preserved.acknowledgement_blocks;
+            if ((preserved.acknowledgement_due?.length ?? 0) === 0) {
+                delete preserved.acknowledgement_due;
+            }
+            if ((preserved.message_acknowledgement_due?.length ?? 0) === 0) {
+                delete preserved.message_acknowledgement_due;
+            }
+            writeSessionStateUnlocked(sessionStatePath(sessionId, env), sessionId, preserved);
+            notes.push(preserveAccepted && state.accepted !== undefined
+                ? 'preserved an accepted device answer for this exact session to resume'
+                : 'preserved required Agent Acknowledgement obligations for this exact session');
+            return {
+                notes,
+                log: {
+                    outcome: preserveAccepted && state.accepted !== undefined ? 'answer-preserved' : 'acknowledgement-preserved',
+                    queued_retirements: orphans.length,
+                    accepted_answers: state.accepted?.answers.length ?? 0,
+                    acknowledgement_due: state.acknowledgement_due?.length ?? 0,
+                    ...(state.message_acknowledgement_due === undefined
+                        ? {}
+                        : { message_acknowledgement_due: state.message_acknowledgement_due.length }),
+                },
+            };
         }
-        if ((preserved.message_acknowledgement_due?.length ?? 0) === 0) {
-            delete preserved.message_acknowledgement_due;
+        const history = stateWithHistory.question_history;
+        clearSessionStateUnlocked(sessionId, env);
+        if ((history?.length ?? 0) > 0) {
+            writeSessionStateUnlocked(sessionStatePath(sessionId, env), sessionId, { question_history: history });
         }
-        writeSessionState(sessionId, env, preserved);
-        notes.push(preserveAccepted && state.accepted !== undefined
-            ? 'preserved an accepted device answer for this exact session to resume'
-            : 'preserved required Agent Acknowledgement obligations for this exact session');
-        return {
-            notes,
-            log: {
-                outcome: preserveAccepted && state.accepted !== undefined ? 'answer-preserved' : 'acknowledgement-preserved',
-                queued_retirements: orphans.length,
-                accepted_answers: state.accepted?.answers.length ?? 0,
-                acknowledgement_due: state.acknowledgement_due?.length ?? 0,
-                ...(state.message_acknowledgement_due === undefined
-                    ? {}
-                    : { message_acknowledgement_due: state.message_acknowledgement_due.length }),
-            },
-        };
-    }
-    const history = stateWithHistory.question_history;
-    clearSessionState(sessionId, env);
-    if ((history?.length ?? 0) > 0) {
-        writeSessionState(sessionId, env, { question_history: history });
-    }
-    return { notes, log: { outcome: 'cleaned', queued_retirements: orphans.length } };
+        return { notes, log: { outcome: 'cleaned', queued_retirements: orphans.length } };
+    });
 }
 // ---------------------------------------------------------------------------
 // ask — register a question for the turn's end
@@ -1901,6 +1944,15 @@ export const MAX_PENDING_QUESTIONS = 4;
  * the shared resource being protected here, not the agent's turn.
  */
 export const MAX_LIVE_QUESTIONS = 10;
+export class QuestionRegistrationChanged extends Error {
+    reason;
+    constructor(reason) {
+        super(reason === 'credential'
+            ? 'The Approved Machine changed before question registration completed.'
+            : 'The Agent Session ended or changed before question registration completed.');
+        this.reason = reason;
+    }
+}
 /**
  * A session may hold several registered questions at once: a new `ask` never
  * ends an earlier one. Each reaches the user as its own notification and is
@@ -1913,10 +1965,24 @@ export const MAX_LIVE_QUESTIONS = 10;
  * The queue is keyed on the session, not the project: several agents may be
  * running in one project at once, and their questions must never interfere.
  */
-export function registerQuestion(sessionId, env, question, now = Date.now()) {
+export function registerQuestion(sessionId, env, question, now = Date.now(), nativeAdmission, guard) {
     let full = null;
+    let stored = false;
     const questionId = question.question_id ?? `q_${randomBytes(12).toString('base64url')}`;
     updateSessionState(sessionId, env, (state) => {
+        // Revalidate after acquiring the lock: discovery and lock contention can
+        // outlive the owner or its Approved Machine. Neither may adopt this ask.
+        if (guard !== undefined) {
+            if (!guard.machineStillMatches())
+                throw new QuestionRegistrationChanged('credential');
+            if (guard.owner_key !== undefined) {
+                const owner = readSessionIncarnation(sessionId, env);
+                if (owner?.key !== guard.owner_key || sessionHasEnded(sessionId, env) ||
+                    owner.harness_process === undefined || processIdentityLiveness(owner.harness_process) !== 'alive') {
+                    throw new QuestionRegistrationChanged('owner');
+                }
+            }
+        }
         const pending = pendingList(state);
         const unasked = pending.filter((entry) => entry.request_id === undefined);
         if (unasked.length >= MAX_PENDING_QUESTIONS) {
@@ -1927,18 +1993,15 @@ export function registerQuestion(sessionId, env, question, now = Date.now()) {
             full = 'live';
             return state;
         }
-        return {
+        stored = true;
+        const registered = { asked_at: now, ...question, question_id: questionId, question: question.question.slice(0, MAX_STORED_QUESTION_CHARS) };
+        return reserveCurrentCodexQuestion({
             ...state,
             pending: [
                 ...pending,
-                {
-                    asked_at: now,
-                    ...question,
-                    question_id: questionId,
-                    question: question.question.slice(0, MAX_STORED_QUESTION_CHARS),
-                },
+                registered,
             ],
-        };
+        }, registered, sessionId, env, nativeAdmission);
     });
     if (full === 'unasked') {
         throw new Error(`${MAX_PENDING_QUESTIONS} questions are already waiting to be asked. ` +
@@ -1948,6 +2011,9 @@ export function registerQuestion(sessionId, env, question, now = Date.now()) {
         throw new Error(`${MAX_LIVE_QUESTIONS} questions from this session are already open. ` +
             'Retire the ones you no longer need with `notifai close <question_id>` or `notifai close --pending` before asking another.');
     }
+    // updateSessionState skips its callback when SessionEnd won the lock.
+    if (!stored)
+        throw new QuestionRegistrationChanged('owner');
     return questionId;
 }
 /** Parses hook JSON from stdin, tolerating an empty or malformed body. */