mixdog 1.2.0 → 1.2.2

package/src/tui/session/turn.mjs

@@ -15,6 +15,10 @@ import { preserveGoalStateAfterTurn } from './goal-turn-state.mjs';
 export { preserveGoalStateAfterTurn } from './goal-turn-state.mjs';
 export { transcriptToolCallDisplayMode } from './turn-tool-cards.mjs';
 import { isRejected429, safeErrorDetails } from '../../runtime/shared/error-presentation.mjs';
+import {
+  QUOTA_KINDS,
+  providerErrorKind,
+} from '../../runtime/agent/orchestrator/providers/provider-error-kind.mjs';
 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';
@@ -47,14 +51,11 @@ import {
   startLiveTail,
 } from './turn-tool-cards.mjs';
 
-function isUsageLimitError(error) {
+// A usage limit is exactly a spent quota, a plan-gated feature or a billing
+// refusal; overloads, rate limits and server faults recover by waiting.
+function isUsageLimitError(error, kind = providerErrorKind(error)) {
   if (!error || isRejected429(error)) return false;
-  const status = Number(error?.httpStatus || error?.status || error?.response?.status || 0);
-  if (error?.providerQuota === true || error?.quotaExceeded === true || status === 429) return true;
-  const text = String(error?.message || error);
-  return /\brate[_ -]?limit\b|\bquota\b|too many requests|resource exhausted|insufficient_quota|quota_exceeded/i.test(
-    text
-  );
+  return QUOTA_KINDS.has(kind.kind);
 }
 
 function turnOutcome(cancelled, failed) {
@@ -165,7 +166,7 @@ function promptRestoreFor(displayText, options, submittedIds, content = null) {
   };
 }
 
-function commitPromptRestore(flags, turn) {
+export function commitPromptRestore(flags, turn) {
   const restore = flags.activePromptRestore;
   if (!restore) return;
   if (!turn.promptCommitted && typeof restore.onCommitted === 'function') {
@@ -322,9 +323,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: () => {},
@@ -372,7 +390,7 @@ function toolHandlers(ctx) {
   };
 }
 
-function streamHandlers(ctx) {
+export function streamHandlers(ctx) {
   const { isCurrentTurn, stream } = ctx;
   return {
     onStageChange: async (stage, detail = null) => {
@@ -381,7 +399,10 @@ function streamHandlers(ctx) {
     onTextDelta: (chunk) => {
       const textChunk = String(chunk ?? '');
       if (!textChunk || !isCurrentTurn()) return;
-      ctx.markPromptCommitted();
+      // Same verdict as the runtime's interruption check (finalizeInterruptedTurn
+      // trims): whitespace-only text is not output, so it must not commit the
+      // prompt — the runtime would rewind it while the host skipped the requeue.
+      if (textChunk.trim()) ctx.markPromptCommitted();
       appendTextDelta(stream, textChunk);
     },
     onTextReset: (reset = {}) => (isCurrentTurn() ? resetStreamedText(stream, reset) : false),
@@ -431,13 +452,30 @@ export function failTurn(ctx, error) {
   }
   turn.failed = true;
   cards.aggregates.finalizeToolHeaders();
-  turn.usageLimited = isUsageLimitError(error);
+  // Presentation only: legacy untyped failure text may still name a usage limit.
+  const errorKind = providerErrorKind(error, { legacyQuotaWording: true });
+  // The UI reads this descriptor instead of re-parsing the error text.
+  turn.errorKind = {
+    kind: errorKind.kind,
+    code: errorKind.code,
+    status: errorKind.status,
+    retryAfterMs: errorKind.retryAfterMs,
+    resetAt: errorKind.resetAt,
+  };
+  turn.usageLimited = isUsageLimitError(error, errorKind);
   const exhausted = error?.quotaExhausted;
-  if (exhausted && typeof exhausted === 'object') {
+  // Quota metadata: the pool's validated exhaustion, or a spent quota whose
+  // provider named the real reset time.
+  const resetKnown = errorKind.kind === 'quota_exhausted' && Number.isFinite(errorKind.resetAt);
+  if ((exhausted && typeof exhausted === 'object') || resetKnown) {
+    const source = exhausted && typeof exhausted === 'object' ? exhausted : {};
+    let resetAt = null;
+    if (Number.isFinite(source.resetAt)) resetAt = source.resetAt;
+    else if (Number.isFinite(errorKind.resetAt)) resetAt = errorKind.resetAt;
     turn.quota = {
-      provider: String(exhausted.provider || turn.routeMeta?.provider || ''),
-      model: String(exhausted.model || turn.routeMeta?.model || ''),
-      resetAt: Number.isFinite(exhausted.resetAt) ? exhausted.resetAt : null,
+      provider: String(source.provider || turn.routeMeta?.provider || ''),
+      model: String(source.model || turn.routeMeta?.model || ''),
+      resetAt,
     };
   }
   turn.failureDetail = toolErrorDisplay(error, 'turn').replace(/^Error:\s*/i, '');
@@ -468,6 +506,7 @@ export function turnDoneItem({ turn, stream, cards, getState, nextId }) {
     ...(turn.failureDiagnostic ? { errorDetails: turn.failureDiagnostic } : {}),
     ...turn.routeMeta,
     ...(turn.failed && turn.quota ? { quota: turn.quota } : {}),
+    ...(turn.failed && turn.errorKind ? { errorKind: turn.errorKind } : {}),
   };
 }
 
@@ -547,6 +586,7 @@ async function settleTurn(ctx) {
     result: turn.askResult,
     session: runtime.session || null,
     error: turn.failureDetail || null,
+    errorKind: turn.failed ? turn.errorKind || null : null,
   };
   // Publish termination before optional Goal work can delay the caller.
   bag.settleSteeredSubmissions?.(turn.epoch, detail);

package/src/tui/statusline-ansi-bridge.mjs

@@ -65,7 +65,7 @@ export function statuslineFooterIdentityChanged(args, lastArgs) {
   if (!lastArgs) return true;
   if (args.sessionId !== lastArgs.sessionId) return true;
   if (args.provider !== lastArgs.provider || args.model !== lastArgs.model) return true;
-  if (args.effort !== lastArgs.effort || args.fast !== lastArgs.fast) return true;
+  if (args.effort !== lastArgs.effort || args.fast !== lastArgs.fast || args.ultra !== lastArgs.ultra) return true;
   if (args.contextWindow !== lastArgs.contextWindow || args.rawContextWindow !== lastArgs.rawContextWindow) return true;
   if (args.displayContextWindow !== lastArgs.displayContextWindow) return true;
   if (args.compactBoundaryTokens !== lastArgs.compactBoundaryTokens) return true;

package/src/ui/statusline-agents.mjs

@@ -25,8 +25,7 @@ let _hiddenStatuslineAgents = null;
 function normalizeAgentWorkerForStatusline(worker = {}) {
   const tag = String(worker.tag || worker.agent || worker.name || '').trim();
   if (!tag) return null;
-  const statuses = agentStatusValues(worker);
-  const status = isActiveAgentEntry(statuses) ? 'running' : 'idle';
+  const status = isActiveAgentEntry(lifecycleStatuses(worker)) ? 'running' : 'idle';
   return {
     tag,
     status,
@@ -63,11 +62,12 @@ function normalizeAgentJobForStatusline(job = {}) {
       model: job.model || null,
     };
   }
-  if (!isActiveAgentEntry(statuses)) return null;
+  const lifecycle = lifecycleStatuses(job);
+  if (!isActiveAgentEntry(lifecycle)) return null;
   return {
     tag,
     taskId,
-    status: isQueuedAgentEntry(statuses) ? 'queued' : 'running',
+    status: isQueuedAgentEntry(lifecycle) ? 'queued' : 'running',
     startedAtMs,
     agent: job.agent || null,
     stage: job.stage || job.workerStatus || job.status || null,
@@ -214,6 +214,17 @@ function agentStatusValues(value = {}) {
     .filter((status, index, values) => Boolean(status) && values.indexOf(status) === index);
 }
 
+/** The statuses that decide whether an entry is working. `status` is the
+ *  lifecycle; `stage` is the runtime phase copied in beside it, which can read
+ *  idle/done/error mid-work, so it decides only for an entry with no status. A
+ *  cancel in either field still counts (it keeps both in play). */
+function lifecycleStatuses(value = {}) {
+  const statuses = agentStatusValues(value);
+  if (statuses.some((status) => /cancel|killed/i.test(status))) return statuses;
+  const status = String(value.status || '').trim();
+  return status ? [status] : statuses;
+}
+
 function isTerminalAgentEntry(statuses = []) {
   return statuses.some((status) => TERMINAL_AGENT_STATUS.test(String(status || '')));
 }

package/src/ui/statusline.mjs

@@ -197,6 +197,7 @@ export async function renderStatusline({
   model = '',
   effort = '',
   fast = false,
+  ultra = false,
   cwd = '',
   stats,
   sessionId,
@@ -223,6 +224,7 @@ export async function renderStatusline({
       model,
       effort,
       fast,
+      ultra,
       cwd,
       stats,
       sessionId,
@@ -233,7 +235,7 @@ export async function renderStatusline({
       ...displayArgs,
     });
   } catch {
-    return fallbackLine({ provider, model, effort, fast, cwd, stats, ...displayArgs });
+    return fallbackLine({ provider, model, effort, fast, ultra, cwd, stats, ...displayArgs });
   }
 }
 
@@ -244,6 +246,7 @@ function renderNativeStatusline({
   model = '',
   effort = '',
   fast = false,
+  ultra = false,
   stats,
   sessionId,
   contextWindow = 0,
@@ -275,7 +278,7 @@ function renderNativeStatusline({
 
   const sep = ` ${D}│${R} `;
   const l1Parts = [
-    formatModelSegment({ provider, model, effort, fast, cols }),
+    formatModelSegment({ provider, model, effort, fast, ultra, cols }),
     formatContextSegment(ctxPct, cols, s.currentContextSource),
     ...quotaSegmentsFor({ provider, model, effort, fast, sessionId, clientHostPid, gatewayStatus, cols }),
   ].filter(Boolean);
@@ -664,6 +667,7 @@ function fallbackLine({
   model = '',
   effort = '',
   fast = false,
+  ultra = false,
   cwd: _cwd = '',
   stats,
   contextWindow = 0,
@@ -687,7 +691,7 @@ function fallbackLine({
   });
   const sep = ` ${D}│${R} `;
   const parts = [
-    formatModelSegment({ provider, model, effort, fast, cols }),
+    formatModelSegment({ provider, model, effort, fast, ultra, cols }),
     formatContextSegment(ctxPct, cols, s.currentContextSource),
   ].filter(Boolean);
   if (!parts.length) return statusSubtle('> mixdog');

package/src/ui/streaming-markdown-heal.mjs

@@ -213,12 +213,43 @@ function healIncompleteLink(text, isPendingLocalPath) {
   return `${prefix}[${closeEmphasis(caption)}${']'.repeat(Math.max(0, depth - 1))}]()`;
 }
 
+const PIPE_ROW = /^ {0,3}\|/;
+const DELIMITER_ROW = /^ {0,3}\|?\s*:?-+:?\s*(?:\|\s*:?-+:?\s*)*\|?\s*$/;
+const PARTIAL_DELIMITER_ROW = /^ {0,3}\|?[\s:|-]*$/;
+
+function tableCells(line) {
+  const cells = line.trim().split(/(?<!\\)\|/);
+  if (cells[0].trim() === '') cells.shift();
+  if (cells.length && cells[cells.length - 1].trim() === '') cells.pop();
+  return cells.length;
+}
+
+// A table streams in as its header row, then its delimiter row a token at a
+// time. Until the delimiter is complete (and has the header's cell count) the
+// rows are a paragraph of raw pipes, which then re-laid out as a table of a
+// different height — the reply grew and shrank under a followed transcript.
+// Hold both rows back until the table can form in one step.
+function trimPendingTableHead(text) {
+  let offset = 0;
+  for (const blank of text.matchAll(/\n[ \t]*\r?\n/g)) offset = blank.index + blank[0].length;
+  const block = text.slice(offset);
+  const lines = block.split('\n').map((line) => line.replace(/\r$/, ''));
+  if (lines.length === 0 || lines.length > 2 || !PIPE_ROW.test(lines[0])) return text;
+  if (lines.length === 2) {
+    const delimiter = lines[1];
+    if (!PARTIAL_DELIMITER_ROW.test(delimiter)) return text;
+    if (DELIMITER_ROW.test(delimiter) && tableCells(delimiter) === tableCells(lines[0])) return text;
+  }
+  return text.slice(0, offset);
+}
+
 export function healStreamingMarkdownTail(text, isPendingLocalPath) {
-  const value = String(text ?? '');
+  const source = String(text ?? '');
+  const fence = source.includes('`') || source.includes('~') ? openFence(source) : null;
+  if (fence) return trimPartialClosingFence(source, fence);
+  const value = source.includes('|') ? trimPendingTableHead(source) : source;
   const hasSyntax = HEALABLE_MARKDOWN_SYNTAX.test(value);
   if (!value || (!hasSyntax && !isPendingLocalPath)) return value;
-  const fence = openFence(value);
-  if (fence) return trimPartialClosingFence(value, fence);
   const healed = hasSyntax
     ? closeEmphasis(healIncompleteLink(closeInlineCode(value, isPendingLocalPath), isPendingLocalPath))
     : value;

package/src/vendor/statusline/src/gateway/claude-current.mjs

@@ -1,6 +1,8 @@
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
+import { getModelMetadataSync } from '../../../../runtime/shared/llm/model-catalog.mjs';
+import { providerCachedModelsSync } from '../../../../runtime/shared/llm/provider-catalog-cache.mjs';
 
 export const CLAUDE_CURRENT_MODE = 'claude-current';
 export const CLAUDE_CURRENT_CHOICE_ID = 'claude-current';
@@ -95,11 +97,21 @@ function snapshotEquivalent(a, b) {
   return keys.every(k => (a[k] ?? null) === (b[k] ?? null));
 }
 
+// The newest roster model of a family, by the roster's own release stamps.
+function newestRosterModel(family) {
+  const stamp = (row) => Date.parse(row.releaseDate) || (Number(row.created) > 0 ? Number(row.created) : 0);
+  const rows = providerCachedModelsSync('anthropic-oauth').filter((row) =>
+    String(row.id).toLowerCase().startsWith(`claude-${family}-`)
+  );
+  rows.sort((a, b) => stamp(b) - stamp(a));
+  return rows[0]?.id || null;
+}
+
 function familyDefaultModel(family) {
   const f = String(family || '').toLowerCase();
   if (!f) return null;
   const envName = `ANTHROPIC_DEFAULT_${f.toUpperCase()}_MODEL`;
-  return cleanString(process.env[envName]) || DEFAULT_FAMILY_MODEL[f] || null;
+  return cleanString(process.env[envName]) || newestRosterModel(f) || DEFAULT_FAMILY_MODEL[f] || null;
 }
 
 export function stripClaudeContextSuffix(model) {
@@ -109,9 +121,7 @@ export function stripClaudeContextSuffix(model) {
 function contextWindowFromRawModel(raw, resolved) {
   const s = cleanString(raw).toLowerCase();
   if (/\[1m\]/.test(s)) return 1000000;
-  if (/^claude-(opus|sonnet)-4-(6|7|8)(?:$|-)/i.test(resolved || '')) return 1000000;
-  if (/^claude-haiku-4-5/i.test(resolved || '')) return 200000;
-  return null;
+  return (resolved && getModelMetadataSync(resolved, 'anthropic-oauth')?.contextWindow) || null;
 }
 
 export function resolveClaudeModelAlias(model) {

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}`;
-}

package/src/runtime/memory/lib/memory-session-merge.mjs

@@ -1,32 +0,0 @@
-// Pure, DB-free merge of session-fallback recall rows into the already-ranked
-// global hybrid rows. Extracted into its own module so the starve-prevention +
-// dedupe contract can be unit-tested without booting the memory worker (which
-// has heavy top-level side effects: http server, pg, onnx embedding).
-//
-// Contract:
-//   - APPEND session rows, never prepend. Blind prepend lets session rows
-//     (limit+) starve the global first page and distorts sort/offset/limit.
-//   - Re-apply the SAME sort policy as the global path so global hybrid hits
-//     (carrying a real retrievalScore) keep their rank; session rows
-//     (retrievalScore 0 under importance, ts-ordered under date) only fill
-//     genuinely open slots.
-//   - Dedupe drops any session row whose id already appears as a global row OR
-//     as a global root's inlined chunk member (prevents member/leaf double
-//     output).
-import { compareRecallByScore, compareRecallNewestFirst } from './recall-order.mjs';
-
-export function mergeSessionRowsIntoGlobal(globalRows, sessionRows, { sort = 'importance' } = {}) {
-  const filtered = Array.isArray(globalRows) ? [...globalRows] : [];
-  if (!Array.isArray(sessionRows) || sessionRows.length === 0) return filtered;
-  const seen = new Set(filtered.map((r) => Number(r.id)));
-  for (const r of filtered) {
-    if (Array.isArray(r.members)) {
-      for (const m of r.members) seen.add(Number(m.id));
-    }
-  }
-  const merged = sessionRows.filter((r) => !seen.has(Number(r.id)));
-  if (merged.length === 0) return filtered;
-  const out = [...filtered, ...merged];
-  out.sort(sort === 'date' ? compareRecallNewestFirst : compareRecallByScore);
-  return out;
-}