mixdog 1.1.2 → 1.2.1

package/src/tui/session/session-flow.mjs

@@ -23,6 +23,7 @@ export function createSessionFlow(bag) {
     steering,
     submissions,
     flushDeferredClearedSessionUi: autoClear.flushDeferredClearedSessionUi,
+    autoClearBeforeWake: autoClear.autoClearBeforeWake,
   });
 
   return {
@@ -41,6 +42,7 @@ export function createSessionFlow(bag) {
     drainPendingSteering: steering.drainPendingSteering,
     restoreLeadSteeringFromDisk: steering.restoreLeadSteeringFromDisk,
     autoClearBeforeSubmit: autoClear.autoClearBeforeSubmit,
+    autoClearBeforeWake: autoClear.autoClearBeforeWake,
     performAutoClear: autoClear.performAutoClear,
     restoreQueued: queue.restoreQueued,
     prioritizeQueued: queue.prioritizeQueued,

package/src/tui/session/transcript-intake.mjs

@@ -11,6 +11,7 @@ import {
 } from '../../runtime/shared/tool-execution-contract.mjs';
 import { isLateToolAnnouncement } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { appendPromptHistory } from '../prompt-history-store.mjs';
+import { newTranscriptMessageId } from '../../runtime/shared/transcript-metadata.mjs';
 import {
   buildExecutionResponseToolItem,
   completionCardFromExecution,
@@ -21,7 +22,7 @@ import { appendAgentResponseTail } from './agent-response-tail.mjs';
 import { nextId } from './transcript-spill.mjs';
 
 export function createTranscriptIntake({ getState, flags, pushItem, patchItem, transcriptRouteMetadata }) {
-  const upsertSyntheticToolItem = (text, id = nextId(), parsed = null) => {
+  const upsertSyntheticToolItem = (text, id = nextId(), parsed = null, messageId = '') => {
     const synthetic = parsed || parseSyntheticAgentMessage(text);
     if (!synthetic) return false;
     const label = synthetic.label || 'notification';
@@ -56,6 +57,7 @@ export function createTranscriptIntake({ getState, flags, pushItem, patchItem, t
     pushItem({
       kind: 'tool',
       id,
+      ...(messageId ? { messageId } : {}),
       name: synthetic.name || 'agent',
       args,
       result: synthetic.result,
@@ -75,11 +77,11 @@ export function createTranscriptIntake({ getState, flags, pushItem, patchItem, t
     // the text parser cannot read still shows up instead of vanishing.
     if (origin === 'injected' && (extra?.mode === 'task-notification' || extra?.execution)) {
       const card = completionCardFromExecution(extra?.execution, text);
-      if (card && upsertSyntheticToolItem(text, id, card)) return;
+      if (card && upsertSyntheticToolItem(text, id, card, extra?.messageId)) return;
     }
     if (origin === 'injected') {
       const completion = parseModelVisibleCompletionWrapper(text);
-      if (completion && upsertSyntheticToolItem(text, id, completion)) return;
+      if (completion && upsertSyntheticToolItem(text, id, completion, extra?.messageId)) return;
     }
     // The lenient shape-only wrapper check is display-suppression only and
     // must never hide a real, directly-typed/pasted user prompt just because
@@ -95,13 +97,20 @@ export function createTranscriptIntake({ getState, flags, pushItem, patchItem, t
     // keep it in model context, but render NOTHING user-facing — not even the
     // collapsed one-line notice (user request: hide late-tool notices entirely).
     if (isLateToolAnnouncement(text)) return;
-    if (upsertSyntheticToolItem(text, id)) return;
+    if (upsertSyntheticToolItem(text, id, null, extra?.messageId)) return;
     // Genuine, directly-typed/pasted user submissions only (never injected or
     // synthetic paths, which returned above): persist to the cwd-scoped store so
     // up-arrow history survives across sessions. Runs before pushItem so the
     // merge in pushItem's user branch (loadPromptHistory) already sees it.
     if (origin === 'user') appendPromptHistory(getState().cwd, text);
-    const transcriptMeta = transcriptRouteMetadata();
+    // The row carries its message's stable id: the runtime's (a steered
+    // message reports it) or, for a typed prompt, a new one that goes with
+    // the prompt into the model transcript. An injected row with no message
+    // id of its own carries none.
+    let messageId = '';
+    if (typeof extra?.messageId === 'string' && extra.messageId) messageId = extra.messageId;
+    else if (origin === 'user') messageId = newTranscriptMessageId();
+    const transcriptMeta = { ...transcriptRouteMetadata(), ...(messageId ? { messageId } : {}) };
     if (origin === 'user') flags.pendingTranscriptMeta = transcriptMeta;
     pushItem({
       kind: 'user',

package/src/tui/session/tui-steering-persist.mjs

@@ -15,11 +15,19 @@ const STALE_STEERING_RESTORE_TTL_MS = 30 * 60 * 1000;
 // Cross-process mutual exclusion still comes from the shared lock protocol;
 // this chain only orders same-process operations that were previously
 // naturally ordered by the synchronous call site.
-let _persistChain = Promise.resolve();
-function _serialize(task) {
-  const run = _persistChain.then(task, task);
+// One chain per session key so a slow write for one session never delays
+// another; an entry is removed once its chain is idle.
+const _persistChains = new Map();
+function _serialize(key, task) {
+  const prev = _persistChains.get(key) || Promise.resolve();
+  const run = prev.then(task, task);
   // Never let a rejection poison the chain; each op logs its own error.
-  _persistChain = run.catch(() => {});
+  const tail = run
+    .catch(() => {})
+    .then(() => {
+      if (_persistChains.get(key) === tail) _persistChains.delete(key);
+    });
+  _persistChains.set(key, tail);
   return run;
 }
 
@@ -159,7 +167,7 @@ export function appendTuiSteeringPersist(leadSessionId, entry) {
     ...(submissionId ? { submissionId } : {}),
     ...(Number.isFinite(submittedAt) && submittedAt > 0 ? { submittedAt } : {}),
   };
-  return _serialize(async () => {
+  return _serialize(key, async () => {
     try {
       await updatePendingShard(key, (raw) => {
         const next = normalizePendingStore(raw);
@@ -184,7 +192,7 @@ export function dropTuiSteeringPersist(leadSessionId, entries) {
   if (!key) return Promise.resolve();
   const batch = Array.isArray(entries) ? entries : [];
   if (batch.length === 0) return Promise.resolve();
-  return _serialize(async () => {
+  return _serialize(key, async () => {
     try {
       await updatePendingShard(key, (raw) => {
         const next = normalizePendingStore(raw);
@@ -207,8 +215,16 @@ export function dropTuiSteeringPersist(leadSessionId, entries) {
   });
 }
 
-export function flushTuiSteeringPersist() {
-  return _persistChain.catch(() => {});
+export async function flushTuiSteeringPersist() {
+  // Loop: chains started while waiting are awaited too.
+  while (_persistChains.size > 0) {
+    await Promise.all([..._persistChains.values()]);
+  }
+}
+
+// Test hook: number of live per-key chains.
+export function _steeringPersistChainCount() {
+  return _persistChains.size;
 }
 
 function drainedRowToRestore(row) {
@@ -233,7 +249,7 @@ function drainedRowToRestore(row) {
 export function drainTuiSteeringPersist(leadSessionId) {
   const key = tuiSteeringSessionKey(leadSessionId);
   if (!key) return Promise.resolve([]);
-  return _serialize(async () => {
+  return _serialize(key, async () => {
     let drained = [];
     let droppedStale = 0;
     try {

package/src/tui/session/turn-stream.mjs

@@ -5,6 +5,7 @@
 // scalars); every function here takes it as its first argument.
 import { TUI_FRAME_MS, yieldToRenderer } from './render-timing.mjs';
 import { retryStatusLine } from '../../runtime/shared/err-text.mjs';
+import { newTranscriptMessageId } from '../../runtime/shared/transcript-metadata.mjs';
 
 // Share Ink's exact 120fps cadence with the frame-batched store. A separate
 // 16ms timer left every other terminal frame idle, so completed script lines
@@ -59,9 +60,27 @@ function ensureAssistant(stream, initialText = '') {
   if (!stream.currentAssistantId) {
     stream.currentAssistantId = stream.nextId();
     const meta = stream.transcriptMeta;
-    const assistantAt =
-      Number.isFinite(Number(meta.assistantAt)) && Number(meta.assistantAt) > 0 ? Number(meta.assistantAt) : Date.now();
-    meta.assistantAt = assistantAt;
+    // A non-streaming continuation was persisted before its text reached this
+    // row: the runtime left that message's id and time (ask-session
+    // takeAssistant), and the row carries them instead of minting new ones.
+    const persisted = stream.claimPersistedAssistant ? meta.persistedAssistant : null;
+    if (persisted) meta.persistedAssistant = null;
+    let assistantAt = persisted?.at;
+    let messageId = persisted?.messageId;
+    if (!persisted) {
+      assistantAt =
+        Number.isFinite(Number(meta.assistantAt)) && Number(meta.assistantAt) > 0
+          ? Number(meta.assistantAt)
+          : Date.now();
+      meta.assistantAt = assistantAt;
+      // The reply this segment becomes is persisted with this stable id (the
+      // runtime takes it with assistantAt), so a compaction that drops the
+      // reply greys this row.
+      if (!(typeof meta.assistantMessageId === 'string' && meta.assistantMessageId)) {
+        meta.assistantMessageId = newTranscriptMessageId();
+      }
+      messageId = meta.assistantMessageId;
+    }
     // Do NOT reset currentAssistantText here: the first onTextDelta has
     // already accumulated the opening chunk before this batched flush runs.
     // Segment resets are owned by closeAssistantSegment(). Seed the new row
@@ -70,6 +89,7 @@ function ensureAssistant(stream, initialText = '') {
     stream.updateStreamingTail(stream.currentAssistantId, {
       text: String(initialText || ''),
       at: assistantAt,
+      messageId,
       ...stream.routeMeta,
     });
   }
@@ -86,6 +106,7 @@ function resetLineScan(stream) {
 function closeAssistantSegment(stream) {
   stream.currentAssistantId = null;
   stream.currentAssistantText = '';
+  stream.claimPersistedAssistant = false;
   resetLineScan(stream);
 }
 
@@ -290,11 +311,18 @@ export function appendTextDelta(stream, textChunk) {
 // Mid-turn assistant text that precedes a tool call from a provider that only
 // returns the final response.content (no deltas); the streaming path owns
 // the render when it already produced text for this segment.
-export function appendAssistantText(stream, full) {
+export function appendAssistantText(stream, full, { committed = false } = {}) {
   endThinkingForText(stream);
   stream.assistantText += full;
   stream.currentAssistantText += full;
   stream.pendingTextFlush = true;
+  // Only post-commit text is the persisted message's own: its row takes that
+  // id. Any other text (a tool preamble published before its message commits)
+  // leaves an earlier recorded id unclaimed, so drop it.
+  stream.claimPersistedAssistant = committed;
+  if (!committed && stream.transcriptMeta && typeof stream.transcriptMeta === 'object') {
+    stream.transcriptMeta.persistedAssistant = null;
+  }
   flushStreamBatch(stream);
 }
 

package/src/tui/session/turn-tool-cards.mjs

@@ -57,10 +57,12 @@ export async function builtinSkillNamesFor(runtime, calls) {
 }
 
 // Transcript spec for a standalone (non-aggregated) tool card.
-function standaloneCardSpec(itemId, name, args) {
+function standaloneCardSpec(itemId, name, args, callId = '') {
   return {
     kind: 'tool',
     id: itemId,
+    // Ties the card to its call (a compaction that drops it greys the card).
+    ...(callId ? { callId } : {}),
     name,
     args,
     result: null,
@@ -221,7 +223,13 @@ function openToolCard(cards, call, index, batch) {
     // Defer the visible push: the card enters the transcript when its real
     // header will paint (delay elapsed) or its result lands first, so no
     // blank placeholder height scrolls the body ahead of the glyphs.
-    const card = { itemId, callId: callKey, done: false, pushed: false, spec: standaloneCardSpec(itemId, name, args) };
+    const card = {
+      itemId,
+      callId: callKey,
+      done: false,
+      pushed: false,
+      spec: standaloneCardSpec(itemId, name, args, callId),
+    };
     cards.deferredCards.registerCard(card);
     trackCard(cards, callId, card);
     // Immediate row-reserve is deferred until every touched aggregate has its

package/src/tui/session/turn.mjs

@@ -18,6 +18,7 @@ import { isRejected429, safeErrorDetails } from '../../runtime/shared/error-pres
 import { registerTaskWaitSteeringCheck } from '../../runtime/agent/orchestrator/session/task-wait-control.mjs';
 import { promptDisplayText, STEERING_SUPPRESSED_DISPLAY } from './queue-helpers.mjs';
 import { yieldToRenderer } from './render-timing.mjs';
+import { archiveItemsForCompaction, compactionArchivedRows } from './compaction-view.mjs';
 import {
   createTurnStream,
   flushStreamBatch,
@@ -105,7 +106,8 @@ function beginTurn({ flags, getState, transcriptRouteMetadata }, options) {
     completionVerb,
   };
   flags.pendingTranscriptMeta = null;
-  const { at: _userItemAt, ...routeMeta } = transcriptMeta;
+  // The prompt's own time and stable id stay on the prompt row.
+  const { at: _userItemAt, messageId: _promptMessageId, ...routeMeta } = transcriptMeta;
   return {
     index,
     startedAt,
@@ -182,6 +184,11 @@ function commitPromptRestore(flags, turn) {
 
 function steeringItemExtras(steeringMeta) {
   return {
+    // The steered message's stable id, so a compaction that drops it greys
+    // this row.
+    ...(typeof steeringMeta?.messageId === 'string' && steeringMeta.messageId
+      ? { messageId: steeringMeta.messageId }
+      : {}),
     // Queue mode + execution provenance: a task notification is rendered as
     // a tool card, never as an injected user bubble.
     ...(steeringMeta?.mode === 'task-notification' ? { mode: 'task-notification' } : {}),
@@ -261,10 +268,10 @@ function publishContextPressure({ syncContextStats, getState, set }, info) {
 }
 
 // Compaction itself remains owned by the pre-provider-send pass. This event
-// trims the visible transcript to the current turn and refreshes the gauge
-// from the already-mutated transcript before another render can show stale
-// pressure.
-function applyCompactEvent(ctx, event) {
+// archives the visible rows before the current turn (they stay in view above
+// the compaction divider) and refreshes the gauge from the already-mutated
+// transcript before another render can show stale pressure.
+export function applyCompactEvent(ctx, event) {
   const { turn, stream, cards, getState, set, replaceItems, pushItem, nextId, syncContextStats, routeState } = ctx;
   flushStreamBatch(stream);
   // Non-tool transcript item — same block-boundary rule as the steered user
@@ -272,12 +279,31 @@ function applyCompactEvent(ctx, event) {
   cards.aggregates.clearAggregateContinuation();
   const compactStatus = String(event?.status || '').toLowerCase();
   const compactChanged = !['failed', 'skipped', 'no_change'].includes(compactStatus);
+  const doneItem = {
+    kind: 'statusdone',
+    id: nextId(),
+    label: compactEventLabel(event),
+    detail: compactEventDetail(event),
+  };
   if (compactChanged) {
-    set({ items: replaceItems(getState().items.slice(turn.currentItemsStart), { preserveStreamingTail: true }) });
-    turn.currentItemsStart = 0;
+    // The current turn starts at its submitted row (spill paging may have
+    // shifted the index recorded at turn start).
+    const current = getState().items;
+    const submitted = new Set(turn.submittedIds.filter((id) => id != null));
+    const submittedIndex = submitted.size ? current.findIndex((item) => submitted.has(item?.id)) : -1;
+    const boundary = submittedIndex >= 0 ? submittedIndex : turn.currentItemsStart;
+    const { items, dividerIndex } = archiveItemsForCompaction(current, doneItem, boundary, {
+      archived: compactionArchivedRows(event),
+      // Only explicit identities name what left the current turn; a bare
+      // count says nothing about it.
+      archiveTail: Boolean(event?.droppedIdentities && typeof event.droppedIdentities === 'object'),
+    });
+    set({ items: replaceItems(items, { preserveStreamingTail: true, preserveSpill: true }) });
+    turn.currentItemsStart = dividerIndex + 1;
     turn.transcriptCompacted = true;
+  } else {
+    pushItem(doneItem);
   }
-  pushItem({ kind: 'statusdone', id: nextId(), label: compactEventLabel(event), detail: compactEventDetail(event) });
   syncContextStats({ allowEstimated: true, invalidateExact: compactChanged });
   // syncContextStats only STAGES its patch; publication is the caller's, and
   // without this set the post-compact gauge reached React only if some later
@@ -296,9 +322,26 @@ function applyTurnUsageDelta({ turn, getState, set, syncContextStats }, delta) {
   set({ stats: { ...getState().stats }, ...(spinner ? { spinner: { ...spinner, inputTokens, outputTokens } } : {}) });
 }
 
+// The runtime reports the skills a user turn actually loaded (`Skill:` header
+// or inline `$name`); the prompt row carries them as `appliedSkills`, the same
+// field a restored row reads from the persisted transcript metadata.
+function applySkillsToPromptRow({ turn, getState, patchItem }, names, detail = {}) {
+  const appliedSkills = (Array.isArray(names) ? names : []).filter((name) => typeof name === 'string' && name);
+  if (!appliedSkills.length) return;
+  const messageId = typeof detail?.messageId === 'string' ? detail.messageId : '';
+  const submitted = turn.submittedIds[0];
+  const row = getState().items.findLast(
+    (item) => item?.kind === 'user' && (messageId ? item.messageId === messageId : item.id === submitted)
+  );
+  if (row) patchItem(row.id, { appliedSkills });
+}
+
 function turnHandlers(ctx) {
   const { isCurrentTurn, drainPendingSteering } = ctx;
   return {
+    onSkillsApplied: (names, detail) => {
+      if (isCurrentTurn()) applySkillsToPromptRow(ctx, names, detail);
+    },
     drainSteering: (_sessionId, drainOptions) =>
       isCurrentTurn() ? drainPendingSteering({ ...drainOptions, turnEpoch: ctx.turn.epoch }) : [],
     onStreamDelta: () => {},
@@ -359,7 +402,7 @@ function streamHandlers(ctx) {
       appendTextDelta(stream, textChunk);
     },
     onTextReset: (reset = {}) => (isCurrentTurn() ? resetStreamedText(stream, reset) : false),
-    onAssistantText: (text) => {
+    onAssistantText: (text, detail) => {
       const full = String(text ?? '');
       if (!full.trim() || !isCurrentTurn()) return;
       // The streaming path owns this segment when it already produced text.
@@ -367,7 +410,7 @@ function streamHandlers(ctx) {
       // there across tool calls.
       if (stream.currentAssistantText.trim()) return;
       ctx.markPromptCommitted();
-      appendAssistantText(stream, full);
+      appendAssistantText(stream, full, { committed: detail?.committed === true });
     },
     onReasoningDelta: (chunk) => {
       if (isCurrentTurn()) appendReasoningDelta(stream, String(chunk ?? ''));
@@ -420,9 +463,12 @@ export function failTurn(ctx, error) {
 }
 
 export function turnDoneItem({ turn, stream, cards, getState, nextId }) {
+  // The outer prompt id is the turn's change-record key (runtime.ask `id`).
+  const checkpointId = turn.submittedIds[0] == null ? '' : String(turn.submittedIds[0]).trim();
   return {
     kind: 'turndone',
     id: nextId(),
+    ...(checkpointId ? { checkpointId } : {}),
     elapsedMs: Date.now() - turn.startedAt,
     status: turnOutcome(turn.cancelled, turn.failed),
     // Notifications resolve this exact terminal assistant item, never a

package/src/runtime/effort-judge/previous-human-request.mjs

@@ -1,162 +0,0 @@
-// Pure pre-turn extraction of the previous human request and the assistant
-// text around it, from the session history as it stands BEFORE the current
-// turn is committed (the boundary resolveTurnAutoEffort runs at). Nothing here
-// reads the current prompt's outcome; nothing is mutated; no text is matched
-// against word lists. Ownership comes only from typed provenance that the
-// runtime already writes (meta.runtimeUserContext, meta.synthetic, meta.source,
-// the compaction/skill/reminder predicates in compact/messages.mjs).
-//
-// Result of previousHumanContext(messages, { retryPrompt }):
-//   {
-//     version: 1,
-//     boundary: number,          // messages[0..boundary) were considered
-//     retryTrimmedIndex: number, // index of the unanswered resubmitted prompt
-//                                // dropped from the view, or -1
-//     prevHuman: { text, index, source, runtimeContext } | null,
-//         // latest actual human message before the boundary. `text` is the
-//         // runtime-context-stripped, trimmed text (untruncated). `source` is
-//         // meta.source or null ('steering' = a human interjection).
-//         // `runtimeContext` is 'stripped' | 'none'.
-//     prevHumanMissing: 'empty-history' | 'no-human-request' | null,
-//     canonicalReply: { text, index } | null,
-//         // exactly what the shipped rp `prev` is: the latest non-empty
-//         // assistant message before the boundary, whatever turn it is from.
-//     pairedReply: { text, index } | null,
-//         // latest non-empty assistant text inside prevHuman's own turn span
-//         // (after prevHuman up to the next human message / boundary). Never
-//         // falls back to another turn: a tool-only or unanswered turn gives
-//         // null with pairedMissing set.
-//     pairedMissing: 'no-human-request' | 'no-assistant-text-in-turn' | null,
-//     replyIsPaired: boolean,    // canonicalReply and pairedReply are the same message
-//     skipped: [{ index, role, reason }], // user messages passed over after
-//         // prevHuman's search began (newest first); reasons: 'summary',
-//         // 'protected-context', 'skill-body', 'synthetic-flag',
-//         // 'typed-source', 'runtime-owned', 'empty'.
-//   }
-//
-// Policy decisions (PREVIOUS_HUMAN_POLICY):
-//   synthetic    meta.synthetic === true, or a source the runtime stores as
-//                "not the user speaking" (task-notification, skill-context),
-//                or anything isActualUserInstructionMessage rejects
-//                (goal-continuation/closeout, compact-*, *-recovery, control
-//                lines), is skipped, not treated as a request.
-//   steering     meta.source === 'steering' is a human interjection (the
-//                provider layer keeps it as its own user turn for that
-//                reason) and counts as a human request.
-//   retry        when retryPrompt repeats the trailing unanswered user prompt
-//                (trailingUnansweredPromptIndex), that stale copy is excluded
-//                so the prompt is never its own "previous request".
-//   summary      compact summaries are skipped; nothing before them is
-//                recovered, so history truncated by compaction yields
-//                'no-human-request' rather than a guess.
-// Limitation: user messages stored without meta (old transcripts) cannot be
-// told apart from the human when a runtime wrapper was never recorded; they
-// are accepted as human, and a wrapper with stale provenance stays unstripped.
-import { stripRuntimeUserContext } from '../agent/orchestrator/session/runtime-user-context.mjs';
-import {
-  isActualUserInstructionMessage,
-  isInjectedSkillBodyMessage,
-  isProtectedContextUserMessage,
-  isSummaryMessage,
-} from '../agent/orchestrator/session/compact/messages.mjs';
-import { trailingUnansweredPromptIndex } from '../agent/orchestrator/session/manager/failed-turn-rewind.mjs';
-import { promptContentText } from '../agent/orchestrator/session/manager/prompt-utils.mjs';
-
-export const PREVIOUS_HUMAN_POLICY = Object.freeze({
-  synthetic: 'skip',
-  steering: 'human',
-  retry: 'exclude-trailing-unanswered-copy',
-  summary: 'skip-no-recovery',
-});
-
-const TYPED_NON_HUMAN_SOURCES = new Set(['task-notification', 'skill-context']);
-
-const textOf = (message) => promptContentText(message?.content).trim();
-
-/** { human, reason?, message } for a user message; null for other roles. */
-function classify(message) {
-  if (message?.role !== 'user') return null;
-  const stripped = stripRuntimeUserContext(message);
-  const meta = stripped.meta && typeof stripped.meta === 'object' ? stripped.meta : {};
-  const no = (reason) => ({ human: false, reason, message: stripped });
-  if (isSummaryMessage(stripped)) return no('summary');
-  if (isProtectedContextUserMessage(stripped)) return no('protected-context');
-  if (isInjectedSkillBodyMessage(stripped)) return no('skill-body');
-  if (meta.synthetic === true) return no('synthetic-flag');
-  if (TYPED_NON_HUMAN_SOURCES.has(String(meta.source || ''))) return no('typed-source');
-  if (!isActualUserInstructionMessage(stripped)) return no('runtime-owned');
-  if (!textOf(stripped)) return no('empty');
-  return { human: true, message: stripped, stripped: stripped !== message };
-}
-
-function latestAssistant(messages, from, to) {
-  for (let index = to - 1; index >= from; index -= 1) {
-    if (messages[index]?.role !== 'assistant') continue;
-    const text = textOf(messages[index]);
-    if (text) return { text, index };
-  }
-  return null;
-}
-
-export function previousHumanContext(messages, { retryPrompt } = {}) {
-  const list = Array.isArray(messages) ? messages : [];
-  const retryTrimmedIndex = retryPrompt == null ? -1 : trailingUnansweredPromptIndex(list, retryPrompt);
-  const boundary = retryTrimmedIndex >= 0 ? retryTrimmedIndex : list.length;
-  const verdicts = [];
-  for (let index = 0; index < boundary; index += 1) verdicts.push(classify(list[index]));
-
-  const skipped = [];
-  let humanIndex = -1;
-  for (let index = boundary - 1; index >= 0; index -= 1) {
-    const verdict = verdicts[index];
-    if (!verdict) continue;
-    if (verdict.human) {
-      humanIndex = index;
-      break;
-    }
-    skipped.push({ index, role: 'user', reason: verdict.reason });
-    // A summary replaces earlier conversational context; do not recover a
-    // request from an older retained fragment behind that boundary.
-    if (verdict.reason === 'summary') break;
-  }
-
-  const canonicalReply = latestAssistant(list, 0, boundary);
-  let prevHuman = null;
-  let pairedReply = null;
-  let pairedMissing = 'no-human-request';
-  if (humanIndex >= 0) {
-    const verdict = verdicts[humanIndex];
-    const source = verdict.message.meta?.source;
-    prevHuman = {
-      text: textOf(verdict.message),
-      index: humanIndex,
-      source: typeof source === 'string' && source ? source : null,
-      runtimeContext: verdict.stripped ? 'stripped' : 'none',
-    };
-    let end = boundary;
-    for (let index = humanIndex + 1; index < boundary; index += 1) {
-      if (verdicts[index]?.human) {
-        end = index;
-        break;
-      }
-    }
-    pairedReply = latestAssistant(list, humanIndex + 1, end);
-    pairedMissing = pairedReply ? null : 'no-assistant-text-in-turn';
-  }
-
-  let prevHumanMissing = null;
-  if (!prevHuman) prevHumanMissing = boundary === 0 ? 'empty-history' : 'no-human-request';
-
-  return {
-    version: 1,
-    boundary,
-    retryTrimmedIndex,
-    prevHuman,
-    prevHumanMissing,
-    canonicalReply,
-    pairedReply,
-    pairedMissing,
-    replyIsPaired: Boolean(pairedReply && canonicalReply && pairedReply.index === canonicalReply.index),
-    skipped,
-  };
-}

package/src/runtime/effort-judge/verified-context-input.mjs

@@ -1,10 +0,0 @@
-// Experimental input only. An unavailable verified request preserves rp exactly.
-// Ownership and pairing are established by the caller, never inferred here.
-export function verifiedContextText({ request, prev, prevRequestVerified } = {}) {
-  const current = String(request || '').slice(0, 1500);
-  const reply = String(prev || '').slice(-1000);
-  const prior = Array.from(String(prevRequestVerified || ''))
-    .slice(0, 300)
-    .join('');
-  return `request: ${current}${prior ? `\nprevious request: ${prior}` : ''}\nprevious reply: ${reply}`;
-}