pi-pier 0.4.1 → 0.4.2

package/src/jev-core.ts

@@ -10,6 +10,7 @@
  */
 import { isPlainObject } from './guards.ts';
 import { containsLikelySecret, FAILURE_SIGNAL } from './reducer-core.ts';
+import { completeLineExcerpt } from './observation-core.ts';
 
 /* ── Request/response shapes (closed set) ── */
 
@@ -153,6 +154,8 @@ export interface DiagnosticGateVerdict {
   readonly choice: string | null;
   readonly noul: number | null;
 }
+/** Confidence is checked before the choice: an unconfident rejection is not authoritative, so the
+ *  caller's regex list must decide (same fail-open path as a typed `low-confidence` answer). */
 export function evaluateDiagnosticGate(
   answers: Record<string, JevAnswer>,
   minConfidence: number,
@@ -162,12 +165,12 @@ export function evaluateDiagnosticGate(
   if (kind === undefined || output === undefined) {
     return { hit: false, reason: 'missing-answer', confidence: null, choice: null, noul: null };
   }
-  if (kind.choice !== 'build_test_run') {
-    return { hit: false, reason: `not-build-test:${kind.choice}`, confidence: kind.confidence, choice: kind.choice, noul: output.noul };
-  }
   if (kind.confidence < minConfidence) {
     return { hit: false, reason: 'low-confidence', confidence: kind.confidence, choice: kind.choice, noul: output.noul };
   }
+  if (kind.choice !== 'build_test_run') {
+    return { hit: false, reason: `not-build-test:${kind.choice}`, confidence: kind.confidence, choice: kind.choice, noul: output.noul };
+  }
   if (output.noul < DIAGNOSTIC_OUTPUT_MIN_NOUL) {
     return { hit: false, reason: 'non-diagnostic-output', confidence: kind.confidence, choice: kind.choice, noul: output.noul };
   }
@@ -262,9 +265,12 @@ export interface ExcerptWindow {
   readonly id: ExcerptWindowId;
   readonly label: string;
   readonly text: string;
+  /** 0-based first line of the window in the packed output (telemetry joins picks to objects). */
+  readonly startLine: number;
 }
 
 interface LineWindow {
+  readonly start: number;
   readonly text: string;
   readonly bytes: number;
   readonly signalCount: number;
@@ -286,12 +292,12 @@ function buildLineWindow(lines: readonly string[], start: number, budgetBytes: n
     if (signalLines.has(i)) signalCount++;
   }
   if (selected.length === 0) return null;
-  return { text: selected.join('\n'), bytes, signalCount };
+  return { start, text: selected.join('\n'), bytes, signalCount };
 }
 
 /** Code-owned middle-window candidates for a packed observation: failure-signal windows (first hit,
- * densest cluster) when present, plus a plain mid-output window ALWAYS offered, so jev judges every
- * packed output — including logs whose failure lines the English FAILURE_SIGNAL regex cannot see. */
+ * densest cluster) when present, plus a plain mid-output window. The picker asks jev only when a
+ * signal window exists; a mid-only set kept head/tail or failed in 8 of 10 asks (D123). */
 export function buildExcerptWindows(text: string, halfBudgetBytes: number): ExcerptWindow[] {
   if (halfBudgetBytes <= 0) return [];
   const lines = text.split('\n');
@@ -308,7 +314,7 @@ export function buildExcerptWindows(text: string, halfBudgetBytes: number): Exce
     const firstWindow = buildLineWindow(lines, Math.max(0, first - 2), halfBudgetBytes, signalLines);
     if (firstWindow !== null && !seen.has(firstWindow.text)) {
       seen.add(firstWindow.text);
-      out.push({ id: 'first_signal', label: 'first failure-signal region', text: firstWindow.text });
+      out.push({ id: 'first_signal', label: 'first failure-signal region', text: firstWindow.text, startLine: firstWindow.start });
     }
 
     let best: LineWindow | null = null;
@@ -319,49 +325,80 @@ export function buildExcerptWindows(text: string, halfBudgetBytes: number): Exce
     }
     if (best !== null && !seen.has(best.text)) {
       seen.add(best.text);
-      out.push({ id: 'densest', label: 'densest failure-signal region', text: best.text });
+      out.push({ id: 'densest', label: 'densest failure-signal region', text: best.text, startLine: best.start });
     }
   }
 
   const midAnchor = Math.min(Math.floor(lines.length / 2), Math.max(0, lines.length - 1));
   const midWindow = buildLineWindow(lines, midAnchor, halfBudgetBytes, signalLines);
   if (midWindow !== null && !seen.has(midWindow.text)) {
-    out.push({ id: 'mid', label: 'middle region of the output', text: midWindow.text });
+    out.push({ id: 'mid', label: 'middle region of the output', text: midWindow.text, startLine: midWindow.start });
   }
   return out;
 }
 
-export function excerptPickRequest(
-  middleWindows: readonly ExcerptWindow[],
-  headExcerpt: string,
-  tailExcerpt: string,
-): JevRequest | null {
-  if (middleWindows.length === 0) return null;
-  const criteria: Record<string, string> = {
-    keep_head_tail: 'The existing head and tail excerpts are already the most informative; keep them',
-  };
-  const excerpts: Record<string, string> = { head_excerpt: headExcerpt, tail_excerpt: tailExcerpt };
-  for (const window of middleWindows) {
-    criteria[window.id] = `${window.label}: excerpt from the middle of the output`;
-    excerpts[window.id] = window.text;
+/**
+ * Which packed outputs are worth an excerpt ask, keeping each item's index into `items`. Skipped:
+ * outputs without a failure-signal window (only `mid` competes with head/tail; that lost in 8 of 10
+ * asks, D123) and outputs whose excerpts carry a credential shape (§8 privacy boundary).
+ */
+export function planExcerptAsks(
+  items: ReadonlyArray<{ obsId: string; text: string }>,
+  excerptBudgetBytes: number,
+): Array<{ index: number; obsId: string } & ExcerptPickItem> {
+  const halfBudget = Math.floor(excerptBudgetBytes / 2);
+  const asks: Array<{ index: number; obsId: string } & ExcerptPickItem> = [];
+  for (let index = 0; index < items.length; index++) {
+    const { obsId, text } = items[index]!;
+    const windows = buildExcerptWindows(text, halfBudget);
+    if (!windows.some((w) => w.id !== 'mid')) continue;
+    const headExcerpt = completeLineExcerpt(text, halfBudget, false);
+    const tailExcerpt = completeLineExcerpt(text, excerptBudgetBytes - halfBudget, true);
+    if (!excerptAskIsSafe(windows, headExcerpt, tailExcerpt)) continue;
+    asks.push({ index, obsId, windows, headExcerpt, tailExcerpt });
   }
-  return {
-    state: { excerpts },
-    questions: {
-      window: {
-        type: 'choice',
-        instructions: 'A large tool output was replaced by a placeholder keeping two short excerpts. Which excerpt set would most help a coding agent locate the problem without recalling the full text?',
-        criteria,
-      },
-    },
-  };
+  return asks;
+}
+
+export interface ExcerptPickItem {
+  readonly windows: readonly ExcerptWindow[];
+  readonly headExcerpt: string;
+  readonly tailExcerpt: string;
+}
+
+/** One request for every packed output (a compaction batch packs up to 20): one round trip instead of
+ *  a 20-way burst. `outputs[i]` carries item i's excerpts; its question is `excerpt_${i}_window`. */
+export function excerptPickRequest(items: readonly ExcerptPickItem[]): JevRequest | null {
+  if (items.length === 0) return null;
+  const questions: Record<string, JevQuestion> = {};
+  const outputs: Array<Record<string, string>> = [];
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i]!;
+    const criteria: Record<string, string> = {
+      keep_head_tail: 'The existing head and tail excerpts are already the most informative; keep them',
+    };
+    const excerpts: Record<string, string> = { head_excerpt: item.headExcerpt, tail_excerpt: item.tailExcerpt };
+    for (const window of item.windows) {
+      criteria[window.id] = `${window.label}: excerpt from the middle of the output`;
+      excerpts[window.id] = window.text;
+    }
+    outputs.push(excerpts);
+    // Question keys are NOT sent to the model, so the instruction names its output index.
+    questions[`excerpt_${i}_window`] = {
+      type: 'choice',
+      instructions: `A large tool output (outputs[${i}]) was replaced by a placeholder keeping two short excerpts. Which excerpt set would most help a coding agent locate the problem without recalling the full text?`,
+      criteria,
+    };
+  }
+  return { state: { outputs }, questions };
 }
 
 export function evaluateExcerptPick(
   answers: Record<string, JevAnswer>,
+  index: number,
   minConfidence: number,
 ): ExcerptWindowId | null {
-  const picked = answerOf(answers, 'window', 'choice');
+  const picked = answerOf(answers, `excerpt_${index}_window`, 'choice');
   if (picked === undefined) return null;
   if (picked.confidence < minConfidence) return null;
   return picked.choice === 'first_signal' || picked.choice === 'densest' || picked.choice === 'mid'

package/src/observation-core.ts

@@ -138,6 +138,8 @@ export interface RecallSliceResult {
   text: string;
   bytes: number;
   lines: number;
+  /** Byte offset the returned text actually starts at (after line-start alignment). */
+  offset: number;
   nextOffset: number;
   eof: boolean;
 }
@@ -157,7 +159,7 @@ export function sliceBufferChunk(
   limits: { maxBytes: number; maxLines: number },
 ): RecallSliceResult {
   if (offset >= buf.length) {
-    return { text: '', bytes: 0, lines: 0, nextOffset: buf.length, eof: true };
+    return { text: '', bytes: 0, lines: 0, offset, nextOffset: buf.length, eof: true };
   }
 
   let end = Math.min(buf.length - offset, limits.maxBytes);
@@ -169,6 +171,15 @@ export function sliceBufferChunk(
     }
   }
 
+  // A byte-cap cut mid-line would make the next page (and its aligned next_offset) skip the rest of
+  // that line; end this page at the previous line boundary instead. A line longer than maxBytes has
+  // no boundary to snap to and stays byte-sliced.
+  const cappedAt = offset + end;
+  if (cappedAt < buf.length && buf[cappedAt - 1] !== 0x0a) {
+    const lastNewline = buf.lastIndexOf(0x0a, cappedAt - 1);
+    if (lastNewline >= offset) end = lastNewline + 1 - offset;
+  }
+
   const chunkBuf = buf.subarray(offset, offset + trimUtf8End(buf.subarray(offset), end));
   const text = chunkBuf.toString('utf8');
   const nextOffset = offset + chunkBuf.length;
@@ -176,6 +187,7 @@ export function sliceBufferChunk(
     text,
     bytes: chunkBuf.length,
     lines: countLines(text),
+    offset,
     nextOffset,
     eof: nextOffset >= buf.length,
   };

package/src/pipe-channel.ts

@@ -58,14 +58,6 @@ export type PipeRequest =
       id: string;
       role: string;
     }
-  | {
-      /** Phase 2 (RFC rfc-delegation-identity §3.2): worker → master progress report. The master
-       * injects it as a display-less custom message (no turn, no visible chat noise). */
-      type: 'progress';
-      id: string;
-      paneId: string;
-      text: string;
-    }
   | {
       /** D113 (RFC rfc-unified-widget): worker → master full todo push on every todo_write, so the
        * master's resident widget and /pier-tree render live worker state without polling herdr. */

package/src/plugins/heat-plan.ts

@@ -10,6 +10,7 @@ import { type ShapeNode } from './grid-shape.ts';
 
 export const SPAWN_PLACEHOLDER_ID = '__pier_new__';
 const RATIO_FLOOR = 0.10;
+const NON_AGENT_RATIO_FLOOR = 0.25;
 const FOCUS_SHARE = 0.72;
 const FOCUS_SHARE_BLOCKED = 0.60;
 const MAX_AUTO_LAYOUT_PANES = 10;
@@ -57,6 +58,19 @@ function clampRatio(r: number): number {
   return Math.min(1 - RATIO_FLOOR, Math.max(RATIO_FLOOR, r));
 }
 
+/** Agent-less panes (plain shells report no status or `unknown`) keep NON_AGENT_RATIO_FLOOR in mixed splits. */
+function hasAgentPanes(node: LayoutNode, statuses: AgentStatusMap): boolean {
+  return flattenPanes(node).some((id) => statuses[id] !== undefined && statuses[id] !== 'unknown');
+}
+
+function splitRatio(node: SplitNode, ratio: number, statuses: AgentStatusMap): number {
+  const firstAgent = hasAgentPanes(node.first, statuses);
+  const secondAgent = hasAgentPanes(node.second, statuses);
+  if (firstAgent && !secondAgent) ratio = Math.min(ratio, 1 - NON_AGENT_RATIO_FLOOR);
+  else if (!firstAgent && secondAgent) ratio = Math.max(ratio, NON_AGENT_RATIO_FLOOR);
+  return clampRatio(ratio);
+}
+
 function tierWeight(status: string | undefined, isAsk = false, slim = false): number {
   if (status === 'blocked') return isAsk ? ASK_WEIGHT : BLOCKED_WEIGHT;
   if (status === 'working') return slim ? WORKING_WEIGHT * SLIM_FACTOR : WORKING_WEIGHT;
@@ -129,7 +143,8 @@ export function planSpawnSplitRatio(opts: {
   if (paneCount <= 1 || paneCount > MAX_AUTO_LAYOUT_PANES) return null;
   if (!containsPane(simulated, opts.focusPaneId) || !containsPane(simulated, newId)) return null;
 
-  const statuses = opts.statuses ?? {};
+  // The new pane is an agent pane; `idle` weighs the same as a missing status.
+  const statuses: AgentStatusMap = { [newId]: 'idle', ...opts.statuses };
   const askFlags = opts.askFlags ?? {};
   const slim = paneCount - 1 >= SLIM_THRESHOLD;
   const focusSteps = findPath(simulated, opts.focusPaneId);
@@ -148,11 +163,11 @@ export function planSpawnSplitRatio(opts: {
     const r = clampRatio(target ** (1 / focusSteps.length));
     const at = focusSteps.find((s) => s.node === newSplit);
     if (!at) return null;
-    return at.side === 'first' ? r : 1 - r;
+    return splitRatio(newSplit, at.side === 'first' ? r : 1 - r, statuses);
   }
 
   const wFirst = weightOf(newSplit.first, statuses, askFlags, slim);
   const wSecond = weightOf(newSplit.second, statuses, askFlags, slim);
   if (wFirst + wSecond <= 0) return null;
-  return clampRatio(wFirst / (wFirst + wSecond));
+  return splitRatio(newSplit, wFirst / (wFirst + wSecond), statuses);
 }

package/src/plugins/observation.ts

@@ -11,7 +11,7 @@ import type {
 } from '@earendil-works/pi-coding-agent';
 import { Type } from 'typebox';
 import { containsReducerReceipt, countLines, deriveObservationId, estimateTokens, formatObservationPlaceholder, isObservationId, sha256Hex, shouldPackForCache } from '../observation-core.ts';
-import { appendEfficiencyLog, efficiencyLogPath, observationObjectPath, readStoredObjectChunk, resolveSessionRoot, storeContentAddressedObject } from '../efficiency-store.ts';
+import { appendEfficiencyLog, efficiencyLogPath, observationObjectExists, observationObjectPath, readStoredObjectChunk, resolveSessionRoot, storeContentAddressedObject } from '../efficiency-store.ts';
 import { resolveEfficiencyConfig, type EfficiencyConfig, type ObservationPackConfig } from '../efficiency-config-core.ts';
 import { resolveCacheRatioFromCost } from '../compact-economics-core.ts';
 import { planToolGate, type RuntimeRoleManifest } from '../tool-gate.ts';
@@ -51,14 +51,13 @@ function buildPlaceholder(
   toolCallId: string,
   text: string,
   textBytes: number,
+  contentHash: string,
   obsConfig: ObservationPackConfig,
   middle?: ExcerptMiddlePick,
-): { id: string; placeholder: string; contentHash: string } {
-  const contentHash = sha256Hex(text);
+): { id: string; placeholder: string } {
   const id = deriveObservationId(toolName, toolCallId, contentHash);
   return {
     id,
-    contentHash,
     placeholder: formatObservationPlaceholder({
       id,
       toolName,
@@ -77,6 +76,20 @@ function memoKeyFor(sessionRoot: string, toolCallId: string, charLength: number)
   return `${sessionRoot}:${toolCallId}:${charLength}`;
 }
 
+function rememberPlaceholder(
+  sessionRoot: string,
+  toolCallId: string,
+  charLength: number,
+  placeholder: string,
+  obsId: string,
+): void {
+  if (placeholderMemo.size >= MAX_MEMO_ENTRIES) {
+    const oldest = placeholderMemo.keys().next().value;
+    if (oldest) placeholderMemo.delete(oldest);
+  }
+  placeholderMemo.set(memoKeyFor(sessionRoot, toolCallId, charLength), { placeholder, obsId });
+}
+
 /** Append one observation.jsonl record; telemetry is always best-effort. */
 async function logObservation(sessionRoot: string, fields: Record<string, unknown>): Promise<void> {
   try {
@@ -100,8 +113,12 @@ interface ExcerptMiddlePick {
   label: string;
 }
 
-/** P0-3 seam: async middle-window picker (jev-backed); null keeps the legacy head+tail halves. */
-export type PickMiddleExcerpt = (text: string, excerptBudgetBytes: number) => Promise<ExcerptMiddlePick | null>;
+/** P0-3 seam: batched middle-window picker (jev-backed), one result per item in order; null keeps
+ *  the legacy head+tail halves. A whole compaction batch is one call. */
+export type PickMiddleExcerpts = (
+  items: ReadonlyArray<{ obsId: string; text: string }>,
+  excerptBudgetBytes: number,
+) => Promise<ReadonlyArray<ExcerptMiddlePick | null>>;
 
 /** Build the OCC `onBeforeCompact` hook: role-gated, config-gated batch packing of the branch's
  * large tool results before `ctx.compact()` rewrites the prefix. Exported so the gate behaviour is
@@ -110,7 +127,7 @@ export function createCompactionBatchPackHook(deps: {
   getObsConfig: () => ObservationPackConfig;
   getManifest?: () => RuntimeRoleManifest | null;
   getSessionId?: () => string | undefined;
-  pickMiddleExcerpt?: PickMiddleExcerpt;
+  pickMiddleExcerpts?: PickMiddleExcerpts;
 }): (sessionRoot: string, ctx: unknown) => Promise<void> {
   return async (sessionRoot: string, ctx: unknown): Promise<void> => {
     const obsConfig = deps.getObsConfig();
@@ -133,7 +150,7 @@ export function createCompactionBatchPackHook(deps: {
       sessionId: deps.getSessionId?.(),
       messages,
       obsConfig,
-      pickMiddleExcerpt: deps.pickMiddleExcerpt,
+      pickMiddleExcerpts: deps.pickMiddleExcerpts,
     });
   };
 }
@@ -147,20 +164,22 @@ async function packOneMessage(opts: {
   text: string;
   textBytes: number;
   charLength: number;
+  contentHash: string;
+  obsId: string;
   obsConfig: ObservationPackConfig;
   /** `extra` carries audit fields such as `source: 'compaction'`, `sendCount`, `tailTokensAfter`. */
   log?: { logEnabled: boolean; event: 'packed' | 'packed-batch'; sessionId?: string; extra?: Record<string, unknown> };
-  pickMiddleExcerpt?: PickMiddleExcerpt;
-  /** Prefetched middle excerpt (the batch path runs picks concurrently); null/undefined = none. */
+  pickMiddleExcerpts?: PickMiddleExcerpts;
+  /** Prefetched middle excerpt (the batch path picks for all items in one call); null/undefined = none. */
   middle?: ExcerptMiddlePick | null;
 }): Promise<string | null> {
-  const { sessionRoot, toolName, toolCallId, text, textBytes, charLength, obsConfig, log, pickMiddleExcerpt } = opts;
+  const { sessionRoot, toolName, toolCallId, text, textBytes, charLength, contentHash, obsConfig, log, pickMiddleExcerpts } = opts;
   const middle = opts.middle !== undefined
     ? (opts.middle ?? undefined)
-    : pickMiddleExcerpt
-      ? (await pickMiddleExcerpt(text, obsConfig.excerptBytes)) ?? undefined
+    : pickMiddleExcerpts
+      ? (await pickMiddleExcerpts([{ obsId: opts.obsId, text }], obsConfig.excerptBytes))[0] ?? undefined
       : undefined;
-  const { id: obsId, placeholder, contentHash } = buildPlaceholder(toolName, toolCallId, text, textBytes, obsConfig, middle);
+  const { id: obsId, placeholder } = buildPlaceholder(toolName, toolCallId, text, textBytes, contentHash, obsConfig, middle);
   const originalTokens = estimateTokens(text);
   const placeholderTokens = estimateTokens(placeholder);
 
@@ -174,11 +193,7 @@ async function packOneMessage(opts: {
     return null;
   }
 
-  if (placeholderMemo.size >= MAX_MEMO_ENTRIES) {
-    const oldest = placeholderMemo.keys().next().value;
-    if (oldest) placeholderMemo.delete(oldest);
-  }
-  placeholderMemo.set(memoKeyFor(sessionRoot, toolCallId, charLength), { placeholder, obsId });
+  rememberPlaceholder(sessionRoot, toolCallId, charLength, placeholder, obsId);
 
   if (log?.logEnabled && !loggedPackedObsIds.has(obsId)) {
     loggedPackedObsIds.add(obsId);
@@ -198,20 +213,65 @@ async function packOneMessage(opts: {
   return placeholder;
 }
 
-/** One packable message: a non-error tool result with text-only content that is not yet packed. */
-interface PackCandidate { toolName: string; toolCallId: string; text: string; textBytes: number; charLength: number }
+/** One packable message: a non-error, text-only tool result over the size threshold. */
+interface PackCandidate {
+  toolName: string;
+  toolCallId: string;
+  text: string;
+  textBytes: number;
+  charLength: number;
+  contentHash: string;
+  obsId: string;
+}
 
-function packCandidateAt(messages: readonly unknown[], index: number, sessionRoot: string): PackCandidate | null {
+function packCandidateAt(
+  messages: readonly unknown[],
+  index: number,
+  sessionRoot: string,
+  minBytes: number,
+): PackCandidate | null {
   const msg = messages[index] as ContextMessage | undefined;
   const content = toolResultContent(msg);
   if (!content) return null;
   const { texts, charLength } = content;
   const text = texts.join('\n');
+  const textBytes = Buffer.byteLength(text, 'utf8');
+  if (textBytes < minBytes) return null;
   const toolName = typeof msg?.toolName === 'string' ? msg.toolName : 'tool';
   const toolCallId = typeof msg?.toolCallId === 'string' ? msg.toolCallId : `call_${index}`;
   if (placeholderMemo.has(memoKeyFor(sessionRoot, toolCallId, charLength))) return null;
   if (containsReducerReceipt(text)) return null;
-  return { toolName, toolCallId, text, textBytes: Buffer.byteLength(text, 'utf8'), charLength };
+  const contentHash = sha256Hex(text);
+  return {
+    toolName,
+    toolCallId,
+    text,
+    textBytes,
+    charLength,
+    contentHash,
+    obsId: deriveObservationId(toolName, toolCallId, contentHash),
+  };
+}
+
+/** A resumed process starts with an empty memo, but the content-addressed object is still on disk.
+ *  Rebuild the deterministic placeholder from it instead of asking jev again, rewriting the object,
+ *  and logging the same saving twice. Returns null when the object is not (verifiably) there. */
+async function reusePackedObservation(
+  candidate: PackCandidate,
+  sessionRoot: string,
+  obsConfig: ObservationPackConfig,
+): Promise<string | null> {
+  if (!(await observationObjectExists(sessionRoot, candidate.obsId, candidate.textBytes))) return null;
+  const { placeholder } = buildPlaceholder(
+    candidate.toolName,
+    candidate.toolCallId,
+    candidate.text,
+    candidate.textBytes,
+    candidate.contentHash,
+    obsConfig,
+  );
+  rememberPlaceholder(sessionRoot, candidate.toolCallId, candidate.charLength, placeholder, candidate.obsId);
+  return placeholder;
 }
 
 export async function batchPackObservations(opts: {
@@ -220,7 +280,7 @@ export async function batchPackObservations(opts: {
   messages: readonly unknown[];
   obsConfig: ObservationPackConfig;
   limits?: { maxItems?: number; maxBytes?: number };
-  pickMiddleExcerpt?: PickMiddleExcerpt;
+  pickMiddleExcerpts?: PickMiddleExcerpts;
 }): Promise<number> {
   const { sessionRoot, sessionId, messages, obsConfig } = opts;
   if (!obsConfig.enabled || !sessionRoot || !Array.isArray(messages)) return 0;
@@ -228,24 +288,25 @@ export async function batchPackObservations(opts: {
   const maxItems = opts.limits?.maxItems ?? MAX_BATCH_PACK_ITEMS;
   const maxBytes = opts.limits?.maxBytes ?? MAX_BATCH_PACK_BYTES;
 
-  // Pass 1 — select with the deterministic checks (memo, receipt, size, soft byte cap). Selection is
-  // optimistic on bytes: a later store failure can only pack fewer items, never more than the caps.
+  // Pass 1 — select with the deterministic checks (memo, receipt, size, existing store object, soft
+  // byte cap). A reused object is memoized here, so no jev ask, write, or telemetry follows for it.
   const candidates: PackCandidate[] = [];
   let selectedBytes = 0;
   for (let i = 0; i < messages.length && candidates.length < maxItems; i++) {
-    const candidate = packCandidateAt(messages, i, sessionRoot);
-    if (!candidate || candidate.textBytes < obsConfig.thresholdBytes) continue;
+    const candidate = packCandidateAt(messages, i, sessionRoot, obsConfig.thresholdBytes);
+    if (!candidate) continue;
+    if (await reusePackedObservation(candidate, sessionRoot, obsConfig)) continue;
     if (selectedBytes + candidate.textBytes > maxBytes && candidates.length > 0) break;
     selectedBytes += candidate.textBytes;
     candidates.push(candidate);
   }
   if (candidates.length === 0) return 0;
 
-  // Pass 2 — prefetch middle excerpts concurrently: every packed output asks jev, so a serial loop
-  // would block onBeforeCompact for maxItems × (0.25–0.77s) per compaction.
-  const picker = opts.pickMiddleExcerpt;
+  // Pass 2 — one batched pick for every selected output: per-item asks were a 6-20-way burst that
+  // all failed together when jev was down.
+  const picker = opts.pickMiddleExcerpts;
   const middles = picker
-    ? await Promise.all(candidates.map((c) => picker(c.text, obsConfig.excerptBytes)))
+    ? await picker(candidates.map((c) => ({ obsId: c.obsId, text: c.text })), obsConfig.excerptBytes)
     : [];
 
   let packedCount = 0;
@@ -274,7 +335,11 @@ async function runRecall(
     return toolError(`invalid observation id format: "${String(rawId)}"`);
   }
   const id = rawId;
-  const offset = typeof params?.offset === 'number' ? params.offset : 0;
+  const rawOffset = params?.offset;
+  if (rawOffset !== undefined && (typeof rawOffset !== 'number' || !Number.isInteger(rawOffset) || rawOffset < 0)) {
+    return toolError(`invalid observation offset: "${String(rawOffset)}"`);
+  }
+  const offset = rawOffset ?? 0;
 
   const sessionDir = ctx?.sessionManager?.getSessionDir?.();
   const sessionId = ctx?.sessionManager?.getSessionId?.();
@@ -288,9 +353,12 @@ async function runRecall(
       maxBytes: effConfig.observationPack.recallChunkBytes ?? RECALL_MAX_BYTES,
       maxLines: RECALL_MAX_LINES,
     });
+    // Mid-line offsets are advanced to the next line start by the reader; the header and telemetry
+    // report the offset the returned chunk actually starts at.
+    const alignedOffset = chunk.offset;
 
     const header = [
-      `[obs_recall id=${id} offset=${offset} next_offset=${chunk.nextOffset} eof=${chunk.eof}]`,
+      `[obs_recall id=${id} offset=${alignedOffset} next_offset=${chunk.nextOffset} eof=${chunk.eof}]`,
       `[chunk_bytes=${chunk.bytes} chunk_lines=${chunk.lines}; use next_offset to continue]`,
     ].join('\n');
 
@@ -299,7 +367,7 @@ async function runRecall(
         event: 'recall',
         sessionId: sessionId ?? 'unknown',
         obsId: id,
-        offset,
+        offset: alignedOffset,
         chunkBytes: chunk.bytes,
         lines: chunk.lines,
         nextOffset: chunk.nextOffset,
@@ -312,7 +380,7 @@ async function runRecall(
       content: [{ type: 'text', text: `${header}\n${chunk.text}` }],
       details: {
         id,
-        offset,
+        offset: alignedOffset,
         bytes: chunk.bytes,
         lines: chunk.lines,
         nextOffset: chunk.nextOffset,
@@ -341,7 +409,7 @@ interface ObservationPackDeps {
   getConfig?: (ctx: ExtensionContext) => EfficiencyConfig;
   getRuntimeManifest?: () => RuntimeRoleManifest | null;
   getRemainingHorizon?: () => number;
-  pickMiddleExcerpt?: PickMiddleExcerpt;
+  pickMiddleExcerpts?: PickMiddleExcerpts;
 }
 
 async function projectPlaceholders(
@@ -395,8 +463,16 @@ async function projectPlaceholders(
     const sendCount = priorAssistantCounts[i] ?? 0;
     if (sendCount < obsConfig.fullSends) continue;
 
-    const candidate = packCandidateAt(projected, i, sessionRoot);
-    if (!candidate || candidate.textBytes < obsConfig.thresholdBytes) continue;
+    const candidate = packCandidateAt(projected, i, sessionRoot, obsConfig.thresholdBytes);
+    if (!candidate) continue;
+
+    // Resume: the object survived the restart even though the memo did not. Project the same
+    // deterministic placeholder without re-asking jev or re-logging the saving.
+    const reused = await reusePackedObservation(candidate, sessionRoot, obsConfig);
+    if (reused) {
+      projected[i] = { ...msg, content: [{ type: 'text', text: reused }] };
+      continue;
+    }
 
     let tailTokensAfter = 0;
     for (let j = i + 1; j < len; j++) {
@@ -410,7 +486,7 @@ async function projectPlaceholders(
     // Projected saving of the legacy placeholder drives the economic decision; packOneMessage
     // recomputes the same placeholder when the answer is yes.
     const originalTokens = estimateTokens(candidate.text);
-    const estimate = buildPlaceholder(candidate.toolName, candidate.toolCallId, candidate.text, candidate.textBytes, obsConfig);
+    const estimate = buildPlaceholder(candidate.toolName, candidate.toolCallId, candidate.text, candidate.textBytes, candidate.contentHash, obsConfig);
     const removedTokens = Math.max(0, originalTokens - estimateTokens(estimate.placeholder));
     // Same resolution as OCC (provider family / token-account fallback): passing a raw 'auto' would
     // let shouldPackForCache fall back on its own hardcoded ratio and diverge from compaction.
@@ -437,7 +513,7 @@ async function projectPlaceholders(
         sessionId,
         extra: { sendCount, tailTokensAfter },
       },
-      pickMiddleExcerpt: deps.pickMiddleExcerpt,
+      pickMiddleExcerpts: deps.pickMiddleExcerpts,
     });
     if (!packed) continue;
     projected[i] = { ...msg, content: [{ type: 'text', text: packed }] };
@@ -454,11 +530,7 @@ export function registerObservationPack(deps: ObservationPackDeps & { pi: Extens
     name: RECALL_TOOL_NAME,
     label: 'Recall Observation',
     description:
-      'Recall a paged slice of a previously replaced large tool result by observation id and byte offset.',
-    promptGuidelines: [
-      'Call obs_recall with id and offset to inspect specific parts of large tool outputs.',
-      'Check the returned next_offset and eof to page through long logs.',
-    ],
+      'Recall a paged slice of a previously replaced large tool result by observation id and byte offset; page on with the returned next_offset until eof.',
     parameters: Type.Object({
       id: Type.String({ description: 'Observation ID from placeholder (e.g. obs_...)' }),
       offset: Type.Optional(