@raidiant/notifai 10.1.0 → 10.1.2

package/dist/hooks.js

@@ -148,10 +148,11 @@ export function findOwningSession(id, env) {
         const sessionId = persisted.session_id;
         const state = persisted;
         const pendingMatch = pendingList(state).some((entry) => entry.question_id === id || entry.request_id === id);
-        const retiringMatch = (state.retiring ?? []).some((entry) => entry.request_id === id);
+        const retiringMatch = (state.retiring ?? []).some((entry) => entry.question_id === id || entry.request_id === id);
+        const historyMatch = (state.question_history ?? []).some((entry) => entry.question_id === id || entry.request_id === id);
         const acknowledgementMatch = (state.acknowledgement_due ?? []).some((entry) => entry.request_id === id);
         const acceptedMatch = state.accepted?.answers.some(({ pending }) => pending.question_id === id || pending.request_id === id) ?? false;
-        if (pendingMatch || retiringMatch || acknowledgementMatch || acceptedMatch) {
+        if (pendingMatch || retiringMatch || historyMatch || acknowledgementMatch || acceptedMatch) {
             matches.push(sessionId);
             if (matches.length > 1)
                 return { sessionId: null, ambiguous: true };
@@ -859,15 +860,16 @@ export function parkForRetirement(sessionId, env, pending, state) {
     updateSessionState(sessionId, env, (current) => {
         const already = current.retiring ?? [];
         const existing = already.findIndex((entry) => entry.request_id === retirement.request_id);
-        if (existing < 0)
-            return { ...current, retiring: [...already, retirement] };
+        if (existing < 0) {
+            return rememberQuestionState({ ...current, retiring: [...already, retirement] }, pending, state === 'answered' ? 'answered' : 'retired');
+        }
         const retiring = [...already];
         // An observed answer is final truth and upgrades an earlier supersession
         // parked while the submission callback was racing a newer question.
         if (retirement.state === 'answered' && retiring[existing].state !== 'answered') {
             retiring[existing] = retirement;
         }
-        return { ...current, retiring };
+        return rememberQuestionState({ ...current, retiring }, pending, state === 'answered' ? 'answered' : 'retired');
     });
 }
 /**
@@ -896,6 +898,7 @@ function retiringQuestion(pending, state, cwd) {
     }
     const source = sourceContextAtHookEvent(pending.source, cwd);
     return {
+        ...(pending.question_id !== undefined ? { question_id: pending.question_id } : {}),
         request_id: requestId,
         collapse_key: collapseKey,
         device_ids: [...deviceIds],
@@ -1133,6 +1136,122 @@ async function pollPendingReplies(ctx, live, timeoutSeconds) {
 function pendingList(state) {
     return Array.isArray(state.pending) ? state.pending : [];
 }
+const QUESTION_HISTORY_CAP = 50;
+/** Keep a bounded, content-free map from local identity to its terminal state. */
+function rememberQuestionState(current, question, state) {
+    if (question.question_id === undefined)
+        return current;
+    const existing = (current.question_history ?? []).find((entry) => entry.question_id === question.question_id);
+    const terminalState = existing?.state === 'withdrawn' || existing?.state === 'answered'
+        ? existing.state
+        : state === 'answered'
+            ? 'answered'
+            : state;
+    const requestId = question.request_id ?? existing?.request_id;
+    const frozenRequestId = requestId === undefined
+        ? question.submission?.request_id ?? existing?.frozen_request_id
+        : undefined;
+    const record = {
+        question_id: question.question_id,
+        state: terminalState,
+        ...(requestId === undefined ? {} : { request_id: requestId }),
+        ...(frozenRequestId === undefined ? {} : { frozen_request_id: frozenRequestId }),
+    };
+    const history = [
+        ...(current.question_history ?? []).filter((entry) => entry.question_id !== question.question_id),
+        record,
+    ].slice(-QUESTION_HISTORY_CAP);
+    return { ...current, question_history: history };
+}
+function pendingQuestionView(entry) {
+    if (entry.question_id === undefined)
+        return null;
+    if (entry.request_id !== undefined) {
+        return {
+            question_id: entry.question_id,
+            state: 'live',
+            submitted: true,
+            request_id: entry.request_id,
+            frozen_request_id: null,
+        };
+    }
+    if (entry.submission !== undefined) {
+        return {
+            question_id: entry.question_id,
+            state: 'frozen',
+            submitted: null,
+            request_id: null,
+            frozen_request_id: entry.submission.request_id,
+        };
+    }
+    return {
+        question_id: entry.question_id,
+        state: 'local',
+        submitted: false,
+        request_id: null,
+        frozen_request_id: null,
+    };
+}
+/** Read one stable local question identity without minting or submitting anything. */
+export function inspectQuestionState(questionId, env) {
+    const owner = findOwningSession(questionId, env);
+    if (owner.ambiguous || owner.sessionId === null) {
+        return { found: false, ambiguous: owner.ambiguous };
+    }
+    const state = readSessionState(owner.sessionId, env);
+    const pending = pendingList(state).find((entry) => entry.question_id === questionId);
+    const pendingView = pending === undefined ? null : pendingQuestionView(pending);
+    if (pendingView !== null) {
+        return { found: true, session_id: owner.sessionId, question: pendingView };
+    }
+    const accepted = state.accepted?.answers.find(({ pending: entry }) => entry.question_id === questionId)?.pending;
+    if (accepted?.question_id !== undefined) {
+        return {
+            found: true,
+            session_id: owner.sessionId,
+            question: {
+                question_id: accepted.question_id,
+                state: 'answered',
+                submitted: true,
+                request_id: accepted.request_id ?? null,
+                frozen_request_id: null,
+            },
+        };
+    }
+    const retiring = (state.retiring ?? []).find((entry) => entry.question_id === questionId);
+    if (retiring?.question_id !== undefined) {
+        return {
+            found: true,
+            session_id: owner.sessionId,
+            question: {
+                question_id: retiring.question_id,
+                state: retiring.state === 'answered' ? 'answered' : 'retired',
+                submitted: true,
+                request_id: retiring.request_id,
+                frozen_request_id: null,
+            },
+        };
+    }
+    const history = (state.question_history ?? []).find((entry) => entry.question_id === questionId);
+    if (history !== undefined) {
+        return {
+            found: true,
+            session_id: owner.sessionId,
+            question: {
+                question_id: history.question_id,
+                state: history.state,
+                submitted: history.request_id !== undefined
+                    ? true
+                    : history.frozen_request_id !== undefined
+                        ? null
+                        : false,
+                request_id: history.request_id ?? null,
+                frozen_request_id: history.frozen_request_id ?? null,
+            },
+        };
+    }
+    return { found: false, ambiguous: false };
+}
 /** Registration identity — the convention every racing writer compares by. */
 function isSamePending(a, b) {
     if (a.question_id !== undefined || b.question_id !== undefined) {
@@ -1148,7 +1267,7 @@ function isSamePending(a, b) {
 function isTerminalDraftRejection(err) {
     return err.status === 422 || (err.status === 400 && err.code === 'invalid_request');
 }
-export function dropPendingQuestion(sessionId, env, entry) {
+export function dropPendingQuestion(sessionId, env, entry, terminalState = 'retired') {
     updateSessionState(sessionId, env, (current) => {
         const pending = pendingList(current).filter((candidate) => !isSamePending(candidate, entry));
         const next = { ...current };
@@ -1156,7 +1275,7 @@ export function dropPendingQuestion(sessionId, env, entry) {
             next.pending = pending;
         else
             delete next.pending;
-        return next;
+        return rememberQuestionState(next, entry, terminalState);
     });
 }
 /**
@@ -1177,7 +1296,7 @@ export function withdrawUnpushedQuestions(sessionId, env) {
             next.pending = remaining;
         else
             delete next.pending;
-        return next;
+        return withdrawn.reduce((remembered, entry) => rememberQuestionState(remembered, entry, 'withdrawn'), next);
     });
     return withdrawn;
 }
@@ -1336,7 +1455,7 @@ function stageAcceptedAnswers(ctx, sessionId, answered, remaining) {
             next.acknowledgement_due = acknowledgementDue;
         else
             delete next.acknowledgement_due;
-        return next;
+        return answered.reduce((remembered, answer) => rememberQuestionState(remembered, answer.pending, 'answered'), next);
     });
     return accepted;
 }
@@ -1530,7 +1649,7 @@ async function retirePendings(ctx, envelope, sessionId, entries, state) {
             next.retiring = retiring;
         else
             delete next.retiring;
-        return next;
+        return entries.reduce((remembered, entry) => rememberQuestionState(remembered, entry, state === 'answered' ? 'answered' : 'retired'), next);
     });
     // Network retirement is deliberately deferred to a later no-question hook.
     // The state write above is the durable operation; blocking here creates a
@@ -1610,7 +1729,7 @@ export async function handleUserPromptSubmit(ctx, envelope) {
     // Park before dropping `pending`. If the process dies between these writes,
     // the next hook sees both copies and dedupes them; the old order could die in
     // the gap after erasing the only request/collapse/device identifiers.
-    updateSessionState(sessionId, ctx.env, (current) => {
+    const updated = updateSessionState(sessionId, ctx.env, (current) => {
         const retiring = [...(current.retiring ?? [])];
         const matchedNow = pendingAnsweredByPrompt(envelope.prompt, pendingList(current));
         const unmatched = pendingList(current).filter((entry) => !matchedNow.some((item) => isSamePending(item, entry)));
@@ -1647,7 +1766,7 @@ export async function handleUserPromptSubmit(ctx, envelope) {
         if (current.continuation !== undefined) {
             next.continuation = { ...current.continuation, count: 0 };
         }
-        return next;
+        return matchedNow.reduce((remembered, entry) => rememberQuestionState(remembered, entry, entry.request_id === undefined ? 'withdrawn' : 'retired'), next);
     });
     // The bridge that lets a plain `notifai ask` find the hook's canonical
     // session: an agent shell command gets no hook payload, and not every
@@ -1660,7 +1779,10 @@ export async function handleUserPromptSubmit(ctx, envelope) {
         // model. Keep the journal and let the next Stop use its acknowledged
         // continuation channel instead of recreating the crash-before-stdout gap.
         notes.push('the late device answer will continue the agent at this turn’s Stop');
-        return { notes };
+        return {
+            notes,
+            settlementRequired: pendingList(updated).some((entry) => entry.request_id === undefined),
+        };
     }
     const retired = await drainRetirements(ctx, sessionId, ctx.env);
     const orphaned = await drainOrphanRetirements(ctx, ctx.env, ctx.now());
@@ -1668,7 +1790,10 @@ export async function handleUserPromptSubmit(ctx, envelope) {
     if (swept.length > 0) {
         notes.push(`retired question${swept.length > 1 ? 's' : ''} ${swept.join(', ')}`);
     }
-    return { notes };
+    return {
+        notes,
+        settlementRequired: pendingList(updated).some((entry) => entry.request_id === undefined),
+    };
 }
 // ---------------------------------------------------------------------------
 // Stop — the turn ended; escalate a registered question
@@ -1678,7 +1803,7 @@ export async function handleUserPromptSubmit(ctx, envelope) {
  * `notifai ask`. Guessing from the last assistant message was the alternative
  * and it is not worth it: a false positive here hijacks the terminal.
  */
-export async function handleStop(ctx, envelope, processDeadlineAt = ctx.now() + QUESTION_WAITER_CEILING_SECONDS * 1000, route = hookContinuationRoute()) {
+export async function handleStop(ctx, envelope, processDeadlineAt = ctx.now() + QUESTION_WAITER_CEILING_SECONDS * 1000, route = hookContinuationRoute(), recordStop = true) {
     const sessionId = envelope.session_id;
     if (!sessionId) {
         gate(ctx, 'held', 'no-session', { stage: 'queued' });
@@ -1689,6 +1814,7 @@ export async function handleStop(ctx, envelope, processDeadlineAt = ctx.now() +
         envelope,
         route,
         processDeadlineAt,
+        recordStop,
     });
 }
 /**
@@ -1734,11 +1860,13 @@ export async function runEscalationWaiter(ctx, options) {
     // This event marker is diagnostic evidence in its own right. Record it
     // before every early return so doctor can distinguish a working Stop route
     // from the prompt-only state that previously looked healthy.
-    updateSessionState(sessionId, ctx.env, (current) => ({
-        ...current,
-        ...(ctx.harness === undefined ? {} : { harness: ctx.harness }),
-        last_stop_at: ctx.now(),
-    }));
+    if (options.recordStop !== false) {
+        updateSessionState(sessionId, ctx.env, (current) => ({
+            ...current,
+            ...(ctx.harness === undefined ? {} : { harness: ctx.harness }),
+            last_stop_at: ctx.now(),
+        }));
+    }
     // The waiter, not its host, owns this lease. It spans grace, submission,
     // polling, close fencing, route delivery, and every retirement path.
     // Real clock, deliberately, not `ctx.now` — the claim answers whether
@@ -2585,6 +2713,16 @@ export function handleSessionEnd(env, envelope, now = Date.now()) {
     if (envelope.cwd !== undefined)
         clearMatchingProjectSession(envelope.cwd, env, sessionId);
     const state = readSessionState(sessionId, env);
+    let stateWithHistory = state;
+    for (const entry of pendingList(state)) {
+        stateWithHistory = rememberQuestionState(stateWithHistory, entry, entry.request_id === undefined && entry.submission === undefined ? 'withdrawn' : 'retired');
+    }
+    for (const answer of state.accepted?.answers ?? []) {
+        stateWithHistory = rememberQuestionState(stateWithHistory, answer.pending, 'answered');
+    }
+    for (const retirement of state.retiring ?? []) {
+        stateWithHistory = rememberQuestionState(stateWithHistory, retirement, retirement.state === 'answered' ? 'answered' : 'retired');
+    }
     const orphans = [...(state.retiring ?? [])];
     const retirementCandidates = [
         ...pendingList(state),
@@ -2613,7 +2751,7 @@ export function handleSessionEnd(env, envelope, now = Date.now()) {
         notes.push(`queued ${orphans.length} question${orphans.length > 1 ? 's' : ''} for retirement on the next hook`);
     }
     if (state.accepted !== undefined || (state.acknowledgement_due?.length ?? 0) > 0) {
-        const preserved = { ...state };
+        const preserved = { ...stateWithHistory };
         delete preserved.pending;
         delete preserved.retiring;
         delete preserved.acknowledgement_blocks;
@@ -2634,7 +2772,11 @@ export function handleSessionEnd(env, envelope, now = Date.now()) {
             },
         };
     }
+    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 } };
 }
 // ---------------------------------------------------------------------------