blun-king-cli 9.1.599 → 9.1.600

package/agent-spine-plugin/src/lib/hook-output.js

@@ -1,99 +1,119 @@
-const BLUN_MESSAGE_MAX_BYTES = 1200;
-const BLUN_BOUND_MARKER = "\n[optional runtime detail omitted: 1200-byte bound]";
+const MAX_BYTES=1200;
+const BOUND="\n[optional runtime detail omitted: 1200-byte bound]";
+const bytes=value=>Buffer.byteLength(JSON.stringify(value));
 
-function byteSize(value) {
-  return Buffer.byteLength(JSON.stringify(value));
-}
-
-function addRecallField(packet, key, value, maximum = 1020) {
-  if (value === undefined || value === null) return;
-  packet[key] = value;
-  if (byteSize(packet) <= maximum) return true;
+function addRecallField(packet,key,value,maximum=1020){
+  if(value===undefined||value===null)return;
+  packet[key]=value;
+  if(bytes(packet)<=maximum)return true;
   delete packet[key];
   return false;
 }
 
-function sharedPrefix(values) {
-  let prefix = values[0] || "";
-  for (const value of values.slice(1)) {
-    while (prefix && !value.startsWith(prefix)) prefix = prefix.slice(0, -1);
+function sharedPrefix(values){
+  let prefix=values[0]||"";
+  for(const value of values.slice(1)){
+    while(prefix&&!value.startsWith(prefix))prefix=prefix.slice(0,-1);
   }
-  return prefix.length >= 4 ? prefix : "";
+  return prefix.length>=4?prefix:"";
 }
 
-function compactCandidateRows(packet, candidates) {
-  if (candidates.rows.length < 2) return;
-  if (!candidates.prefixes) {
-    const digest = candidates.fields.indexOf("digest");
-    if (digest >= 0 && candidates.rows.every((row) => row[digest] === candidates.rows[0][digest])) {
-      candidates.common = { ...(candidates.common || {}), digest: candidates.rows[0][digest] };
-      candidates.fields.splice(digest, 1);
-      for (const row of candidates.rows) row.splice(digest, 1);
+function compactRows(packet,candidates){
+  if(candidates.rows.length<2)return;
+  if(!candidates.prefixes){
+    const digest=candidates.fields.indexOf("digest");
+    if(digest>=0&&candidates.rows.every(row=>row[digest]===candidates.rows[0][digest])){
+      candidates.common={...(candidates.common||{}),digest:candidates.rows[0][digest]};
+      candidates.fields.splice(digest,1);
+      for(const row of candidates.rows)row.splice(digest,1);
     }
-    candidates.prefixes = candidates.fields.map((field, index) => {
-      const values = candidates.rows.map((row) => row[index]);
-      const prefix = ["id", "message", "session"].includes(field) ? sharedPrefix(values)
-        : field === "at" && values.every((value) => /^\d{4}-\d{2}-\d{2}T\d{2}:/.test(value))
-          ? values[0].slice(0, 14) : "";
-      if (!prefix || !values.every((value) => value.startsWith(prefix))) return "";
-      for (const row of candidates.rows) row[index] = row[index].slice(prefix.length);
+    candidates.prefixes=candidates.fields.map((field,index)=>{
+      const values=candidates.rows.map(row=>row[index]);
+      const prefix=["id","message","session"].includes(field)?sharedPrefix(values)
+        :field==="at"&&values.every(value=>/^\d{4}-\d{2}-\d{2}T\d{2}:/.test(value))
+          ?values[0].slice(0,14):"";
+      if(!prefix||!values.every(value=>value.startsWith(prefix)))return"";
+      for(const row of candidates.rows)row[index]=row[index].slice(prefix.length);
       return prefix;
     });
   }
-  if (packet.task) {
+  if(packet.task){
     delete packet.task.status;
-    if (packet.task.lastVerifiedStep) delete packet.task.lastVerifiedStep.result;
+    if(packet.task.lastVerifiedStep)delete packet.task.lastVerifiedStep.result;
   }
-  const review = packet.feedbackReview;
-  if (review?.modelClarification) packet.feedbackReview = {
-    status: review.status, completionVerified: false, target: review.targetAssertionId,
-    question: review.modelClarification.question, model: true
+  const review=packet.feedbackReview;
+  if(review?.modelClarification)packet.feedbackReview={
+    status:review.status,completionVerified:false,target:review.targetAssertionId,
+    question:review.modelClarification.question,model:true
   };
 }
 
-function compactFeedbackCandidates(packet) {
-  const candidates = packet.feedbackCandidates;
-  const proposal = packet.feedbackReview?.modelClarification;
-  if (proposal) for (const key of ["completionVerified", "provider", "replaces"]) delete proposal[key];
-  if (candidates && !Array.isArray(candidates)
-    && Array.isArray(candidates.fields) && Array.isArray(candidates.rows)) {
-    compactCandidateRows(packet, candidates);
+function compactFeedback(packet){
+  const candidates=packet.feedbackCandidates;
+  const proposal=packet.feedbackReview?.modelClarification;
+  if(proposal)for(const key of ["completionVerified","provider","replaces"])delete proposal[key];
+  if(candidates&&!Array.isArray(candidates)
+    &&Array.isArray(candidates.fields)&&Array.isArray(candidates.rows)){
+    compactRows(packet,candidates);
     return true;
   }
-  if (!Array.isArray(candidates) || candidates.length < 2) return false;
-  const origins = ["provider", "session"];
-  const sharedKeys = origins.filter((key) =>
-    candidates.every((item) => item?.[key] === candidates[0]?.[key]));
-  const fields = ["id", "text", "digest", "message", "at",
-    ...origins.filter((key) => !sharedKeys.includes(key))];
-  packet.feedbackCandidates = {
+  if(!Array.isArray(candidates)||candidates.length<2)return false;
+  const origins=["provider","session"];
+  const sharedKeys=origins.filter(key=>candidates.every(item=>item?.[key]===candidates[0]?.[key]));
+  const fields=["id","text","digest","message","at",
+    ...origins.filter(key=>!sharedKeys.includes(key))];
+  packet.feedbackCandidates={
     fields,
-    ...(sharedKeys.length ? { common: Object.fromEntries(sharedKeys.map((key) =>
-      [key, candidates[0][key]])) } : {}),
-    rows: candidates.map((item) => fields.map((key) => item[key]))
+    ...(sharedKeys.length?{common:Object.fromEntries(sharedKeys.map(key=>
+      [key,candidates[0][key]]))}:{}),
+    rows:candidates.map(item=>fields.map(key=>item[key]))
   };
-  compactCandidateRows(packet, packet.feedbackCandidates);
+  compactRows(packet,packet.feedbackCandidates);
   return true;
 }
 
-export function preAnswerRecallCapsule(detailed) {
-  if (detailed?.event !== "UserPromptSubmit" || !detailed.loaded) return null;
-  const briefing = detailed.briefing;
-  const preflight = detailed.preflight?.briefing;
-  if (!briefing || !preflight) return null;
-  if (briefing.scope?.groupId !== null && briefing.scope?.groupId !== undefined) return null;
-  const omitted = [];
-  const packet = briefing.preAnswerRecall ? { ...briefing.preAnswerRecall } : {
-    schema: "agentspine.pre-answer-recall/v1",
-    order: "review-before-claims-and-actions",
-    authority: "context-only"
+function timelineRecall(t){
+  if(!t.events?.length)return{status:t.status,reason:t.reason,awaited:t.awaited,
+    reads:t.sourceReads,completionVerified:false,omitted:t.omittedEvents||0};
+  return{status:t.status,awaited:t.awaited,reads:t.sourceReads,completionVerified:false,
+    naturalMessages:"unresolved",trust:"untrusted-session-history",
+    ...(t.source?{source:t.source}:{sources:t.sources}),prefixes:t.prefixes,
+    fields:t.fields,rows:t.events.map(row=>[...row]),omitted:t.omittedEvents||0}
+}
+
+export function preAnswerRecallCapsule(detailed){
+  if(detailed?.event!=="UserPromptSubmit"||!detailed.loaded)return null;
+  const briefing=detailed.briefing;
+  const preflight=detailed.preflight?.briefing;
+  if(!briefing||!preflight)return null;
+  if(briefing.scope?.groupId!==null&&briefing.scope?.groupId!==undefined)return null;
+  const omitted=[];
+  const packet=briefing.preAnswerRecall?structuredClone(briefing.preAnswerRecall):{
+    schema:"agentspine.pre-answer-recall/v1",
+    order:"review-before-claims-and-actions",
+    authority:"context-only"
   };
+  const timeline=detailed.sourceResolution?.timeline?.preAnswerRecall;
+  if(timeline?.awaited){
+    let candidate=timelineRecall(timeline);
+    while(!addRecallField(packet,"timeline",candidate)&&candidate.rows?.length){
+      candidate.rows.pop();
+      candidate.omitted += 1;
+      if(!candidate.rows.length)candidate={status:"unavailable",reason:"host-context-budget",
+        awaited:candidate.awaited,reads:candidate.reads,completionVerified:false,omitted:candidate.omitted};
+    }
+    if(!packet.timeline&&bytes(packet)>MAX_BYTES){
+      const keys=Object.keys(packet).filter(key=>!/^schema$|^order$|^authority$/.test(key));
+      for(const key of keys)delete packet[key];
+      packet.timeline=candidate;packet.omitted=keys;
+    }else if(!packet.timeline)packet.timelineOmitted=true;
+  }
   const mustRemember = (preflight.mustRemember || []).map((item) => ({
     id: item.id, claim: item.claim, checksum: item.checksum
   }));
   if (mustRemember.length && !addRecallField(packet, "mustRemember", mustRemember)) {
-    if (!compactFeedbackCandidates(packet)
-      || !addRecallField(packet, "mustRemember", mustRemember, BLUN_MESSAGE_MAX_BYTES)) {
+    if (!compactFeedback(packet)
+      || !addRecallField(packet, "mustRemember", mustRemember, MAX_BYTES)) {
       omitted.push("mustRemember");
     }
   }
@@ -101,13 +121,13 @@ export function preAnswerRecallCapsule(detailed) {
     (provider.items || []).map((item) => ({ providerId: provider.providerId,
       id: item.id, revision: item.revision, claim: item.claim, source: item.source }))).slice(0, 3);
   if (retrieval.length && !addRecallField(packet, "retrieval", retrieval)) {
-    if (!compactFeedbackCandidates(packet)
-      || !addRecallField(packet, "retrieval", retrieval, BLUN_MESSAGE_MAX_BYTES)) {
+    if (!compactFeedback(packet)
+      || !addRecallField(packet, "retrieval", retrieval, MAX_BYTES)) {
       omitted.push("retrieval");
     }
   }
-  compactFeedbackCandidates(packet);
-  if (omitted.length && byteSize({ ...packet, omitted }) <= BLUN_MESSAGE_MAX_BYTES) packet.omitted = omitted;
+  compactFeedback(packet);
+  if(omitted.length&&bytes({...packet,omitted})<=MAX_BYTES)packet.omitted=omitted;
   return Object.keys(packet).length > 3 ? packet : null;
 }
 
@@ -166,11 +186,10 @@ export function blunRuntimeContext(context) {
 
 export function blunRuntimeMessage(context) {
   const runtime = JSON.parse(blunRuntimeContext(context));
-  const warning = runtime.sourceResolution?.incomplete ? ` Warning: ${runtime.sourceResolution.warning}` : "";
   const base = runtime.loaded
     ? runtime.preAnswerRecall
-      ? `AgentSpine ready: ${runtime.indexedSources} sources indexed.${warning}`
-      : `AgentSpine ready: ${runtime.indexedSources} sources indexed. Load detailed continuity only on demand through session_briefing.${warning}`
+      ? `AgentSpine ready: ${runtime.indexedSources} sources indexed.`
+      : `AgentSpine ready: ${runtime.indexedSources} sources indexed. Load detailed continuity only on demand through session_briefing.`
     : `AgentSpine unavailable${runtime.sourceResolution?.reason ? `: ${runtime.sourceResolution.reason}` : ""}. ${runtime.instruction}`;
   const active = {};
   if (runtime.signal && (runtime.signal.captured || runtime.signal.accepted
@@ -195,22 +214,25 @@ export function blunRuntimeMessage(context) {
     : runtime.premortem?.instruction;
   const premortem = instruction ? `\n${instruction}` : "";
   const message = `${base}${recall}${details}${premortem}`;
-  if (Buffer.byteLength(message) <= BLUN_MESSAGE_MAX_BYTES) return message;
-  const compact = `${base}${recall}${BLUN_BOUND_MARKER}\n${compactPremortemRegistration(runtime.premortem)}`;
-  if (Buffer.byteLength(compact) <= BLUN_MESSAGE_MAX_BYTES) return compact;
+  if (Buffer.byteLength(message) <= MAX_BYTES) return message;
+  const compact = `${base}${recall}${BOUND}\n${compactPremortemRegistration(runtime.premortem)}`;
+  if (Buffer.byteLength(compact) <= MAX_BYTES) return compact;
   if (!runtime.preAnswerRecall) {
-    return `${base}${BLUN_BOUND_MARKER}\n${compactPremortemRegistration(runtime.premortem, false)}`;
+    return `${base}${BOUND}\n${compactPremortemRegistration(runtime.premortem, false)}`;
   }
-  const recallOnly = `${base}${recall}${BLUN_BOUND_MARKER}`;
-  if (Buffer.byteLength(recallOnly) <= BLUN_MESSAGE_MAX_BYTES) return recallOnly;
-  return Buffer.byteLength(recall)<=BLUN_MESSAGE_MAX_BYTES+1?recall.slice(1):`${base}\nRecall unavailable.`;
+  const recallOnly = `${base}${recall}${BOUND}`;
+  if (Buffer.byteLength(recallOnly) <= MAX_BYTES) return recallOnly;
+  return Buffer.byteLength(recall)<=MAX_BYTES+1?recall.slice(1):`${base}\nRecall unavailable.`;
 }
 
-export function hookOutput(event, context, env = process.env) {
+export function hookOutput(event, context, env = process.env, sourceWarning = null) {
   if (env.BLUN_PLUGIN_ROOT) {
-    return { hookSpecificOutput: { hookEventName: event, additionalContext: blunRuntimeMessage(context) } };
+    const source=JSON.parse(context).sourceResolution,w=sourceWarning||(source?.incomplete&&source.warning);
+    return {hookSpecificOutput:{hookEventName:event,additionalContext:blunRuntimeMessage(context),
+      ...(w?{message:`AgentSpine source warning: ${w}`}:{})}};
   }
-  return { hookSpecificOutput: { hookEventName: event, additionalContext: context } };
+  return { hookSpecificOutput: { hookEventName: event, additionalContext: context,
+    ...(sourceWarning ? { message: sourceWarning } : {}) } };
 }
 
 export function blockedHookOutput(event, reason, env = process.env) {
@@ -234,15 +256,12 @@ export function blockStop(event, reason) {
   process.stdout.write(`${JSON.stringify(blockedHookOutput(event, reason))}\n`);
 }
 
-export function lifecycleOutput(event, artifactGuard, premortem, deliveryVerification = null, env = process.env,
+export function lifecycleOutput(event, artifactGuard, premortem, delivery = null, env = process.env,
   sourceWarning = null, lessonRecall = null) {
-  const messages = sourceWarning ? [`AgentSpine source warning: ${sourceWarning}`] : [];
-  if (artifactGuard?.reason) messages.push(artifactGuard.reason);
-  if (deliveryVerification?.status === "test-failed" && deliveryVerification.reason) {
-    messages.push(deliveryVerification.reason);
-  }
+  const w=[sourceWarning&&`AgentSpine source warning: ${sourceWarning}`,artifactGuard?.reason,
+    delivery?.status==="test-failed"&&delivery.reason].filter(Boolean),c=[];
   if (/^[a-f0-9]{64}$/.test(premortem?.writeDigest || "")) {
-    messages.push([
+    c.push([
       premortem.writeIntent
         ? "AgentSpine recorded the allowed mutation intent for the delivery premortem."
         : "AgentSpine recorded the direct write for the delivery premortem.",
@@ -250,7 +269,7 @@ export function lifecycleOutput(event, artifactGuard, premortem, deliveryVerific
     ].join("\n"));
   }
   if (lessonRecall?.status === "recalled") {
-    messages.push(JSON.stringify({
+    c.push(JSON.stringify({
       schema: lessonRecall.schema, receiptDigest: lessonRecall.receiptDigest,
       instruction: lessonRecall.instruction, items: lessonRecall.items,
       learning: lessonRecall.learning || [], learningDiagnostics: lessonRecall.learningDiagnostics || null,
@@ -258,6 +277,8 @@ export function lifecycleOutput(event, artifactGuard, premortem, deliveryVerific
       authority: "context-only"
     }));
   }
-  if (!messages.length) return {};
-  return { hookSpecificOutput: { hookEventName: event, additionalContext: messages.join("\n") } };
+  const o={hookEventName:event},f=env.BLUN_PLUGIN_ROOT?"message":"additionalContext";
+  if(w.length)o[f]=w.join("\n");
+  if(c.length)o.additionalContext=[o.additionalContext,...c].filter(Boolean).join("\n");
+  return Object.keys(o).length>1?{hookSpecificOutput:o}:{};
 }

package/agent-spine-plugin/src/lib/hook-timeline.js

@@ -1,6 +1,9 @@
 import { sessionTimelineLifecycleHint } from "./session-timeline.js";
 import { issueHostTranscriptReceipt } from "./session-timeline-enrollment.js";
 import { consumeTimelineHostOrigin } from "./session-timeline-host-origin.js";
+import {
+  automaticPreAnswerTimelineRecall, timelineRecallNotFound
+} from "./pre-answer-timeline-recall.js";
 import {
   timelineHostForRuntime, timelineHostHome, timelineProtocolFromRuntime, timelineSourceFromRuntime
 } from "./session-timeline-provider.js";
@@ -21,7 +24,6 @@ function hasRawTimelineGroupSignal(input) {
     }
     return values.some((value) => value !== undefined && value !== null && value !== "");
   } catch {
-    // Parser-shaped uncertainty must not turn a lifecycle hint into a denial.
     return false;
   }
 }
@@ -36,8 +38,6 @@ function receiptObservation(receipt) {
     expiresAt: receipt.expiresAt || null, authority: AUTHORITY };
 }
 
-// This observes a provider hook payload but never returns the
-// opaque enrollment token through model-visible context.
 export async function observeHostTranscriptReceipt({ root, event, input, scope, hostHome, hostOrigin = null, clock = null }) {
   if (event !== "UserPromptSubmit") return receiptObservation({ status: "not-applicable" });
   if (hasRawTimelineGroupSignal(input)) return receiptObservation({ status: "unavailable", reason: "raw-group-scope" });
@@ -50,7 +50,9 @@ export async function observeHostTranscriptReceipt({ root, event, input, scope,
   return receiptObservation(receipt);
 }
 
-export async function captureSessionTimelineLifecycle({ root, event, input, scope, hostHome, hostOrigin = null, clock = null }) {
+export async function captureSessionTimelineLifecycle({
+  root, event, input, scope, hostHome, hostOrigin = null, clock = null, turnId = null, prompt
+}) {
   if (hasRawTimelineGroupSignal(input)) return groupSuppressed("raw-group-scope");
   if (!scope || scope.groupId !== null) return groupSuppressed("computed-group-scope");
   let hostReceipt = null;
@@ -64,14 +66,21 @@ export async function captureSessionTimelineLifecycle({ root, event, input, scop
   const result = (value) => hostReceipt ? { ...value, hostReceipt } : value;
   const host = timelineHostForRuntime(scope.host, process.env);
   if (!host || (host === "king" && !timelineProtocolFromRuntime(host))) return unavailable("host-not-supported");
-  return result(await sessionTimelineLifecycleHint({ root, host,
-    sessionId: input.session_id ?? input.sessionId, scope, environment: process.env }));
+  const session = input.session_id ?? input.sessionId;
+  const lifecycle = await sessionTimelineLifecycleHint({ root, host,
+    sessionId: session, scope, environment: process.env });
+  if (event !== "UserPromptSubmit" || !hostOrigin) return result(lifecycle);
+  const preAnswerRecall = lifecycle.priorSessions?.available
+    ? await automaticPreAnswerTimelineRecall({
+      root, host, sessionId: session, scope, hostHome, eventId: input.event_id ?? input.hook_event_id,
+      turnId, prompt,
+      environment: process.env
+    }) : timelineRecallNotFound();
+  const prior = lifecycle.priorSessions;
+  return result({ ...lifecycle, priorSessions: prior && { available: prior.available, sessions: prior.sessions,
+    indexedEvents: prior.indexedEvents, freshness: prior.freshness, authority: prior.authority }, preAnswerRecall });
 }
 
-// The calling hook performs this only at its final pre-answer boundary.  The
-// origin helper consumes the exact signed preflight receipt before this can
-// touch timeline receipt state. Failure to form a timeline origin is optional
-// and yields no opaque receipt; failure to consume preflight remains blocking.
 export async function finalizeUserPromptSessionTimeline({
   root, input, scope, resolvedSources, preflight, prompt, now = new Date()
 }) {
@@ -83,7 +92,7 @@ export async function finalizeUserPromptSessionTimeline({
     return { preflightConsumed: true, briefingOrigin: consumed.briefingOrigin,
       timeline: await captureSessionTimelineLifecycle({
       root, event: "UserPromptSubmit", input, scope, hostHome: resolvedSources.hostHome,
-      hostOrigin: consumed.origin, clock: () => new Date(now)
+      hostOrigin: consumed.origin, clock: () => new Date(now), turnId: preflight.receipt.id, prompt
     }) };
   } catch (error) {
     return { preflightConsumed: true, briefingOrigin: consumed.briefingOrigin, timeline: {

package/agent-spine-plugin/src/lib/host-instruction-budget.js

@@ -1,17 +1,11 @@
-const STANDARD_BYTES = 8 * 1024;
-export const KING_SOURCE_MAX_BYTES = 4 * 1024 * 1024;
-export const KING_TOTAL_MAX_BYTES = 8 * 1024 * 1024;
-
-export function isKingHost(env = process.env) {
-  return Boolean(env.BLUN_PLUGIN_ROOT && env.BLUN_HOME);
-}
+const STANDARD = 8192;
+export const KING_SOURCE_BYTES = 4194304;
+const KING_TOTAL = 8388608;
+export const isKingHost = (env = process.env) => !!(env.BLUN_PLUGIN_ROOT && env.BLUN_HOME);
 
 export function instructionBudget(host, usedBytes = 0, env = process.env) {
-  const hardLimitBytes = host === "codex" && isKingHost(env) ? KING_TOTAL_MAX_BYTES
-    : host === "claude" ? 16 * 1024 : host === "codex" ? 32 * 1024 : STANDARD_BYTES;
-  const overflowBytes = Math.max(0, usedBytes - STANDARD_BYTES);
-  return {
-    mode: overflowBytes ? `${host}-required-overflow` : "standard",
-    standardBytes: STANDARD_BYTES, hardLimitBytes, usedBytes, overflowBytes
-  };
+  const hardLimitBytes = host === "codex" && isKingHost(env) ? KING_TOTAL
+    : host === "claude" ? 16384 : host === "codex" ? 32768 : STANDARD;
+  return { mode: usedBytes > STANDARD ? `${host}-required-overflow` : "standard",
+    standardBytes: STANDARD, hardLimitBytes, usedBytes, overflowBytes: Math.max(0, usedBytes - STANDARD) };
 }

package/agent-spine-plugin/src/lib/mcp-timeline-tools.js

@@ -51,9 +51,6 @@ export function timelineInterpretationRequest(value) {
   return structuredClone(value);
 }
 
-// Hosts qualify MCP tools differently. These prefixes must stay exact: a
-// foreign MCP server can expose an identically named tool but must never
-// receive a timeline invocation permit.
 export const AGENTSPINE_TIMELINE_TOOL_PREFIX = "mcp__plugin_agent-spine_agent-spine__";
 export const BLUN_TIMELINE_TOOL_PREFIX = "mcp__agent-spine__";
 
@@ -138,10 +135,6 @@ function resolvedClaims(args) {
   return result;
 }
 
-// Direct stdio callers can bypass the MCP schema. Merge the flat and nested
-// representations only when every present claim agrees. In particular, a
-// nested group claim stays visible when a top-level argument tries to clear
-// it with null, so no existing private permit crosses into a group turn.
 export function timelineInvocationInput(args = {}) {
   return resolvedClaims(args);
 }

package/agent-spine-plugin/src/lib/pre-answer-timeline-recall.js

@@ -0,0 +1,104 @@
+import {createHash} from "node:crypto";
+import {authorizeSessionTimelineInvocation,searchSessionTimeline} from "./session-timeline.js";
+import {resolvePrivateSessionTimelineEnrollment} from "./session-timeline-enrollment.js";
+import {rankTimelineEvents,timelineTerms} from "./session-timeline-query.js";
+import {timelineTransportDigest} from "./session-timeline-transport.js";
+
+const SCHEMA="agentspine.pre-answer-timeline-recall/v1", AUTHORITY="context-only";
+const hash=value=>createHash("sha256").update(value).digest("hex");
+const unavailable=(reason,s=0,o=0)=>({schema:SCHEMA,status:"unavailable",reason,awaited:true,
+  sourceReads:s,events:[],omittedEvents:o,completionVerified:false,authority:AUTHORITY});
+
+function exactScope(binding,visibility){
+  const {host,sessionId,taskId,...continuity}=binding;
+  return {...continuity,groupId:null,currentTaskId:taskId,timelineVisibility:visibility};
+}
+
+function prefix(values){
+  let value=values[0]||"";
+  for (const item of values.slice(1)) while(value&&!item.startsWith(value)) value=value.slice(0,-1);
+  return value;
+}
+
+function compact(events){
+  const sources=[],indices=new Map(),messagePrefix=prefix(events.map(item=>item.messageRef)),
+    timePrefix=prefix(events.map(item=>item.at));
+  const rows=events.map(item=>{
+    const key=`${item.sourceDigest}\0${item.sourceProvider}\0${item.sessionRef}`;
+    let source=indices.get(key);
+    if(source===undefined){source=sources.length;indices.set(key,source);
+      sources.push({digest:item.sourceDigest,provider:item.sourceProvider,session:item.sessionRef});}
+    const kind=item.kind === "objective-result" ? "result" : item.kind === "user-message-candidate" ? "user" : "correction";
+    const value=kind === "result" ? [item.outcome,item.count?.value ?? null,item.count?.total ?? null,
+      item.testLabel, item.excerpt] : kind === "correction" ? item.nextStepSummary : item.sourceText;
+    return [source, item.messageRef.slice(messagePrefix.length), item.at.slice(timePrefix.length), kind, value];
+  });
+  const fields = ["source", "message", "at", "kind", "value"], prefixes = [messagePrefix, timePrefix];
+  return sources.length === 1 ? { source: sources[0], prefixes, fields: fields.slice(1), events: rows.map((row) => row.slice(1)) }
+    : { sources, prefixes, fields, events: rows };
+}
+
+async function lane({root,enrollment,hostHome,transport,turnId,name,query,ref,at,environment}){
+  const {binding:b,enrollmentDigest:d,timelineVisibility:v}=enrollment,{host,...fields}=b,w=at?900:0;
+  const scope = exactScope(b,v);
+  const runtime = { root, host, sessionId:b.sessionId, scope, hostHome, environment };
+  const request = { root, tool: "search", ...fields, groupId: null,
+    timelineVisibility:v, enrollmentDigest:d, at:at||null, query, windowSeconds:w,
+    includePriorSessions: true, includePriorProviders: false, ...(ref && { ref }) };
+  const authorized = await authorizeSessionTimelineInvocation({ ...runtime, tool: "search", request,
+    toolUseId: `automatic-pre-answer:${hash(`${turnId}\0${name}\0${d}`)}`,
+    transportDigest: transport, enrollmentDigest:d });
+  return authorized && searchSessionTimeline({ ...runtime, at, query, windowSeconds:w, includePriorSessions: true,
+    includePriorProviders: false, invocationRequest: request, invocationTool: "search", transportDigest: transport,
+    enrollmentDigest:d });
+}
+
+export async function automaticPreAnswerTimelineRecall({root,host,sessionId,scope,hostHome,eventId,
+  turnId,prompt,environment=process.env}) {
+  if(!scope||scope.groupId!==null||!scope.currentTaskId)return unavailable("private-task-scope-unavailable");
+  let sourceReads=0;
+  try {
+    const enrollment=await resolvePrivateSessionTimelineEnrollment({root,host,sessionId,hostHome});
+    if(enrollment.status!=="enrolled")return unavailable("private-enrollment-unavailable");
+    const transport=timelineTransportDigest({root,binding:enrollment.binding,environment});
+    if(!transport)return unavailable("timeline-transport-unavailable");
+    const recallId=turnId||eventId||"turn",terms=timelineTerms(prompt);
+    sourceReads++;
+    const objective = await lane({ root, enrollment, hostHome, transport, turnId: recallId,
+      name: "objective", query: ["objective result", ...terms].join(" ").slice(0,512), environment });
+    if(!objective||objective.blocked)return unavailable("timeline-search-unavailable",sourceReads);
+    const selected = rankTimelineEvents((objective.events || []).map((item) =>
+      ({ ...item, terms: timelineTerms(item.excerpt) })), terms)[0];
+    if(!selected)return timelineRecallNotFound(sourceReads);
+    sourceReads++;
+    const natural = await lane({ root, enrollment, hostHome, transport, turnId: recallId,
+      name: "natural-feedback", query: "user message", ref: selected?.sessionRef, at:selected?.at, environment });
+    if(!natural||natural.blocked)return unavailable("timeline-search-unavailable",sourceReads);
+    const events = [...selected ? [selected] : [], ...(natural.events || []).slice(0, 3)];
+    const unique = [...new Map(events.map((item) => [`${item.sourceDigest}\0${item.id}`, item])).values()];
+    return { schema: SCHEMA, status: unique.length ? "recalled" : "not-found", awaited: true,
+      sourceReads, ...compact(unique), omittedEvents:(objective.events?.length||0)
+        +(natural.events?.length||0)-unique.length,completionVerified:false,
+      naturalMessages: "unresolved", trust: "untrusted-session-history", authority: AUTHORITY };
+  } catch { return unavailable("timeline-search-unavailable", sourceReads); }
+}
+
+const removeLast=r=>r.events.length>1?{...r,events:r.events.slice(0,-1),omittedEvents:r.omittedEvents+1}
+  :unavailable("host-context-budget",r.sourceReads,r.omittedEvents+1);
+export const timelineRecallNotFound=(s=0)=>({...unavailable(null,s),status:"not-found"});
+
+export function fitTimelineRecallToHostContext({timeline,render,maximumBytes}) {
+  let fitted=timeline,recall=timeline?.preAnswerRecall,context=render(fitted);
+  while (Buffer.byteLength(context)>maximumBytes&&recall?.events?.length) {
+    recall=removeLast(recall); fitted={...fitted,preAnswerRecall:recall}; context=render(fitted);
+  }
+  if (Buffer.byteLength(context)>maximumBytes&&recall) {
+    fitted={...fitted,preAnswerRecall:unavailable("host-context-budget",recall.sourceReads,
+      recall.omittedEvents)}; context=render(fitted);
+  }
+  if (Buffer.byteLength(context)>maximumBytes) {
+    fitted={schema:"agentspine.session-timeline/v1",status:"unavailable",
+      reason: "host-context-budget", authority: AUTHORITY }; context = render(fitted);
+  }
+  return {timeline:fitted,context};
+}

package/agent-spine-plugin/src/lib/session-timeline-codex.js

@@ -11,8 +11,6 @@ const RECORDS = new Set(["session_meta", "response_item", "event_msg", "compacte
   "token_usage_record", "world_state", "retained_context", "security_risk_score", "realtime_item",
   "inter_agent_communication", "inter_agent_communication_metadata"]);
 
-// Read only the explicitly supplied native source. No directory discovery,
-// decompression, inherited-history traversal or source rewriting is allowed.
 export async function validateCodexTimelineHeader({ source, root, sessionId }) {
   let handle;
   try {
@@ -37,8 +35,6 @@ export async function validateCodexTimelineHeader({ source, root, sessionId }) {
   finally { await handle?.close(); }
 }
 
-// Whitelist actual Responses output records, never assistant/user assertions.
-// The caller applies the common secret/injection filter to the original line.
 export function codexTimelineToolResult(line) {
   if (!RECORDS.has(line?.type) || line.schema_version !== undefined) {
     throw new Error("codex-history-format-mismatch");

package/agent-spine-plugin/src/lib/session-timeline-enrollment-source.js

@@ -7,9 +7,6 @@ export const PRIVATE_TIMELINE_PREFIX_BYTES = 4096;
 
 function digest(value) { return createHash("sha256").update(value).digest("hex"); }
 
-// A receipt and enrollment never read a complete host transcript.  A small
-// stable prefix makes later replacement detectable while append verification
-// establishes the bounded full commitment separately.
 export async function privateTimelinePrefixDigest(source, bytes = Math.min(source?.size, PRIVATE_TIMELINE_PREFIX_BYTES)) {
   if (!Number.isSafeInteger(bytes) || bytes < 0 || bytes > PRIVATE_TIMELINE_PREFIX_BYTES) return null;
   let handle;

package/agent-spine-plugin/src/lib/session-timeline-enrollment-storage.js

@@ -55,10 +55,6 @@ export async function readPrivateEnrollmentState({
   if (typeof assertOwned !== "function" || !recoverableForwardCommit(state, head)) {
     throw new Error("private timeline enrollment state replay was rejected");
   }
-  // A state replacement can survive a crash before its paired head replacement.
-  // Repair is allowed only while holding the owned lock and only for the exact
-  // authenticated one-generation successor of the retained head.  Re-read both
-  // records after writing so a path swap cannot produce usable content.
   const freshState = await readAuthenticatedTimelineState(path, maximumBytes, assertStable);
   const checkedState = await verifySessionTimelineState(validate(JSON.parse(freshState), root.value));
   const checkedHead = await readHead(headPath, root, assertStable, headSchema, headAuthority, maximumBytes);

package/agent-spine-plugin/src/lib/session-timeline-enrollment-transport.js

@@ -2,8 +2,6 @@ import { sameTimelineBinding } from "./session-timeline-contract.js";
 import { resolvePrivateSessionTimelineEnrollment } from "./session-timeline-enrollment.js";
 import { validTimelineTransportDigest } from "./session-timeline-transport.js";
 
-// Keep the digest inside the signed enrollment record. This verifier returns
-// only a boolean so neither the transport value nor its digest reaches cards.
 export async function timelineTransportEnrollmentMatches({
   root, binding, enrollmentDigest, transportDigest, hostHome = null
 }) {