blun-king-cli 9.1.597 → 9.1.600

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

@@ -3,20 +3,20 @@ import { mkdir } from "node:fs/promises";
 import { isAbsolute } from "node:path";
 import { withOwnedFileLock } from "./owned-file-lock.js";
 import {
-  completeTimelineBinding, hasVerifiedTimelinePrivateScope, sameTimelineBinding, sessionTimelineBinding,
-  TIMELINE_ID_RE, validTimelineBinding
+completeTimelineBinding, hasVerifiedTimelinePrivateScope, sameTimelineBinding, sessionTimelineBinding,
+TIMELINE_ID_RE, validTimelineBinding
 } from "./session-timeline-contract.js";
 import {
-  ensureSessionTimelineTrust, sessionTimelineStatePaths
+ensureSessionTimelineTrust, sessionTimelineStatePaths
 } from "./session-timeline-auth.js";
 import { consumeSessionTimelineInvocation, issueSessionTimelineInvocation } from "./session-timeline-invocation.js";
 import {
-  loadPrivateSessionTimelineEnrollment, resolvePrivateSessionTimelineEnrollment
+loadPrivateSessionTimelineEnrollment, resolvePrivateSessionTimelineEnrollment
 } from "./session-timeline-enrollment.js";
 import { timelineTransportEnrollmentMatches } from "./session-timeline-enrollment-transport.js";
 import { sameTimelineTransportDigest, timelineTransportDigest } from "./session-timeline-transport.js";
 import {
-  matchesTimelineEvent, rankTimelineEvents, timelineQuery
+matchesTimelineEvent, rankTimelineEvents, timelineQuery
 } from "./session-timeline-query.js";
 import { timelineContinuationCapsule, timelineSearchResult } from "./session-timeline-results.js";
 import { seekTimelineEvidence, verifyTimelineEvent } from "./session-timeline-search.js";
@@ -28,7 +28,6 @@ import { readTimelineState, saveTimelineState } from "./session-timeline-state.j
 import { sessionTimelineRootDigest } from "./session-timeline-root.js";
 import { priorTimelineHint, selectPriorTimelineSource, timelineSessionReference } from "./session-timeline-prior.js";
 import { crossProviderTimelineEnabled } from "./session-timeline-provider.js";
-
 export const SESSION_TIMELINE_SCHEMA = "agentspine.session-timeline/v1";
 const STATE_SCHEMA = "agentspine.session-timeline-state/v1";
 const AUTHORITY = "context-only";
@@ -41,460 +40,423 @@ const ROOM_BYTES = 1024 * 1024;
 const EVENT_OUTCOMES = new Set(["pass", "fail", "blocked", "timeout", "error", "skipped"]);
 const EVENT_LABEL_RE = /^(?:suite-(?:0|[1-9]\d{0,3})|acceptance|audit|npm-check|ci|test)$/;
 const EVENT_KEYS = new Set(["nativeMessageId", "id", "at", "offset", "bytes", "sha256", "kind", "outcome", "count", "testLabel", "nextStepSummary", "terms", "authority"]);
-
 function digest(value) { return createHash("sha256").update(value).digest("hex"); }
 function asDate(value) {
-  const date = value instanceof Date ? value : new Date(value);
-  if (!Number.isFinite(date.getTime())) throw new Error("session timeline timestamp is invalid");
-  return date;
+const date = value instanceof Date ? value : new Date(value);
+if (!Number.isFinite(date.getTime())) throw new Error("session timeline timestamp is invalid");
+return date;
 }
 function date(value) { return Number.isFinite(new Date(value).getTime()); }
-
 function empty(root) { return { schema: STATE_SCHEMA, rootDigest: sessionTimelineRootDigest(root), sources: [], authority: AUTHORITY }; }
 function hasOnlyKeys(item, allowed) { return Object.keys(item).every((key) => allowed.has(key)); }
 function validCount(item) {
-  return item === null || Boolean(item && typeof item === "object" && Object.keys(item).length === 2
-    && Number.isSafeInteger(item.value) && item.value >= 0 && Number.isSafeInteger(item.total)
-    && item.total > 0 && item.value <= item.total);
+return item === null || Boolean(item && typeof item === "object" && Object.keys(item).length === 2
+&& Number.isSafeInteger(item.value) && item.value >= 0 && Number.isSafeInteger(item.total)
+&& item.total > 0 && item.value <= item.total);
 }
 function validEvent(item) {
-  const common = item && typeof item === "object" && hasOnlyKeys(item, EVENT_KEYS)
-    && typeof item.id === "string" && TIMELINE_ID_RE.test(item.id) && date(item.at)
-    && Number.isSafeInteger(item.offset) && item.offset >= 0 && Number.isSafeInteger(item.bytes) && item.bytes > 0
-    && /^[a-f0-9]{64}$/.test(item.sha256 || "")
-    && Array.isArray(item.terms) && item.terms.length <= 24 && item.terms.every((term) => /^[\p{L}\p{N}]{3,}$/u.test(term))
-    && (item.nativeMessageId === undefined || typeof item.nativeMessageId === "string" && TIMELINE_ID_RE.test(item.nativeMessageId))
-    && item.authority === AUTHORITY;
-  if (!common) return false;
-  if (item.kind === "user-message-candidate") return item.outcome === undefined
-    && item.count === undefined && item.testLabel === undefined && item.nextStepSummary === undefined
-    && item.terms.join(" ") === "user message";
-  if (item.kind === "objective-result") {
-    return EVENT_OUTCOMES.has(item.outcome) && validCount(item.count)
-      && (item.testLabel === null || typeof item.testLabel === "string" && EVENT_LABEL_RE.test(item.testLabel))
-      && item.nextStepSummary === undefined;
-  }
-  return item.kind === "explicit-next-step-correction" && item.outcome === undefined
-    && item.count === undefined && item.testLabel === undefined
-    && (item.nextStepSummary === undefined || typeof item.nextStepSummary === "string"
-      && Boolean(item.nextStepSummary.trim()) && item.nextStepSummary.length <= 500);
+const common = item && typeof item === "object" && hasOnlyKeys(item, EVENT_KEYS)
+&& typeof item.id === "string" && TIMELINE_ID_RE.test(item.id) && date(item.at)
+&& Number.isSafeInteger(item.offset) && item.offset >= 0 && Number.isSafeInteger(item.bytes) && item.bytes > 0
+&& /^[a-f0-9]{64}$/.test(item.sha256 || "")
+&& Array.isArray(item.terms) && item.terms.length <= 24 && item.terms.every((term) => /^[\p{L}\p{N}]{3,}$/u.test(term))
+&& (item.nativeMessageId === undefined || typeof item.nativeMessageId === "string" && TIMELINE_ID_RE.test(item.nativeMessageId))
+&& item.authority === AUTHORITY;
+if (!common) return false;
+if (item.kind === "user-message-candidate") return item.outcome === undefined
+&& item.count === undefined && item.testLabel === undefined && item.nextStepSummary === undefined
+&& item.terms.join(" ") === "user message";
+if (item.kind === "objective-result") {
+return EVENT_OUTCOMES.has(item.outcome) && validCount(item.count)
+&& (item.testLabel === null || typeof item.testLabel === "string" && EVENT_LABEL_RE.test(item.testLabel))
+&& item.nextStepSummary === undefined;
+}
+return item.kind === "explicit-next-step-correction" && item.outcome === undefined
+&& item.count === undefined && item.testLabel === undefined
+&& (item.nextStepSummary === undefined || typeof item.nextStepSummary === "string"
+&& Boolean(item.nextStepSummary.trim()) && item.nextStepSummary.length <= 500);
 }
 function validSource(item) {
-  return item && validTimelineBinding(item.binding) && typeof item.path === "string" && isAbsolute(item.path)
-    && item.path.length > 0 && item.path.length <= 4096 && typeof item.profileRoot === "string" && isAbsolute(item.profileRoot)
-    && item.profileRoot.length > 0 && item.profileRoot.length <= 4096 && typeof item.projectsRoot === "string" && isAbsolute(item.projectsRoot)
-    && item.projectsRoot.length > 0 && item.projectsRoot.length <= 4096 && item.pathDigest === digest(item.path)
-    && typeof item.identity === "string" && item.identity.length <= 256
-    && /^[0-9]+$/.test(item.mtimeNs || "") && /^[0-9]+$/.test(item.ctimeNs || "")
-    && Number.isInteger(item.indexedBytes) && item.indexedBytes >= 0 && Number.isInteger(item.size) && item.size >= 0
-    && item.indexedBytes <= item.size && Array.isArray(item.events) && item.events.length <= MAX_EVENTS
-    && item.events.every((event) => validEvent(event) && event.bytes <= MAX_LINE_BYTES && event.offset + event.bytes <= item.size)
-    && (item.lessonDigest === null || /^[a-f0-9]{64}$/.test(item.lessonDigest || ""))
-    && date(item.updatedAt) && item.authority === AUTHORITY;
+return item && validTimelineBinding(item.binding) && typeof item.path === "string" && isAbsolute(item.path)
+&& item.path.length > 0 && item.path.length <= 4096 && typeof item.profileRoot === "string" && isAbsolute(item.profileRoot)
+&& item.profileRoot.length > 0 && item.profileRoot.length <= 4096 && typeof item.projectsRoot === "string" && isAbsolute(item.projectsRoot)
+&& item.projectsRoot.length > 0 && item.projectsRoot.length <= 4096 && item.pathDigest === digest(item.path)
+&& typeof item.identity === "string" && item.identity.length <= 256
+&& /^[0-9]+$/.test(item.mtimeNs || "") && /^[0-9]+$/.test(item.ctimeNs || "")
+&& Number.isInteger(item.indexedBytes) && item.indexedBytes >= 0 && Number.isInteger(item.size) && item.size >= 0
+&& item.indexedBytes <= item.size && Array.isArray(item.events) && item.events.length <= MAX_EVENTS
+&& item.events.every((event) => validEvent(event) && event.bytes <= MAX_LINE_BYTES && event.offset + event.bytes <= item.size)
+&& (item.lessonDigest === null || /^[a-f0-9]{64}$/.test(item.lessonDigest || ""))
+&& date(item.updatedAt) && item.authority === AUTHORITY;
 }
 function validate(value, root) {
-  if (!value || value.schema !== STATE_SCHEMA || value.rootDigest !== sessionTimelineRootDigest(root) || value.authority !== AUTHORITY
-    || !Array.isArray(value.sources) || value.sources.length > MAX_SOURCES || value.sources.some((item) => !validSource(item))) {
-    throw new Error("session timeline state is invalid");
-  }
-  return value;
+if (!value || value.schema !== STATE_SCHEMA || value.rootDigest !== sessionTimelineRootDigest(root) || value.authority !== AUTHORITY
+|| !Array.isArray(value.sources) || value.sources.length > MAX_SOURCES || value.sources.some((item) => !validSource(item))) {
+throw new Error("session timeline state is invalid");
+}
+return value;
 }
-
 function paths(root) { return sessionTimelineStatePaths(root); }
 function readState(path, root, assertStable) {
-  return readTimelineState({ path, root, maximumBytes: MAX_STATE_BYTES, empty, validate, assertStable });
+return readTimelineState({ path, root, maximumBytes: MAX_STATE_BYTES, empty, validate, assertStable });
 }
 function saveState(state, path, assertOwned, root, assertStable) {
-  return saveTimelineState({ state, path, root, maximumBytes: MAX_STATE_BYTES, assertOwned, assertStable });
+return saveTimelineState({ state, path, root, maximumBytes: MAX_STATE_BYTES, assertOwned, assertStable });
 }
-
 function status(value, extra = {}) { return { schema: SESSION_TIMELINE_SCHEMA, ...value, ...extra, authority: AUTHORITY }; }
 function hasExactPrivateTimelineScope(scope) { return scope?.groupId === null; }
 function sourceFor(state, scope) { return state.sources.find((item) => sameTimelineBinding(item.binding, scope)) || null; }
 function sourceMetadata(source) {
-  const sourceDigest = digest(`${source.pathDigest}\0${source.identity}\0${source.size}\0${source.mtimeNs}\0${source.ctimeNs}`);
-  return { sourceDigest, indexedBytes: source.indexedBytes, size: source.size, events: source.events.length,
-    rooms: Math.ceil(source.size / ROOM_BYTES), continuation: timelineContinuationCapsule({ source, sourceDigest, roomBytes: ROOM_BYTES, authority: AUTHORITY }) };
+const sourceDigest = digest(`${source.pathDigest}\0${source.identity}\0${source.size}\0${source.mtimeNs}\0${source.ctimeNs}`);
+return { sourceDigest, indexedBytes: source.indexedBytes, size: source.size, events: source.events.length,
+rooms: Math.ceil(source.size / ROOM_BYTES), continuation: timelineContinuationCapsule({ source, sourceDigest, roomBytes: ROOM_BYTES, authority: AUTHORITY }) };
 }
 function sameSourceSnapshot(left, right) {
-  return Boolean(left && right) && ["path", "profileRoot", "projectsRoot", "pathDigest", "identity", "size", "mtimeNs", "ctimeNs"]
-    .every((key) => left[key] === right[key]);
+return Boolean(left && right) && ["path", "profileRoot", "projectsRoot", "pathDigest", "identity", "size", "mtimeNs", "ctimeNs"]
+.every((key) => left[key] === right[key]);
 }
 async function confirmedSourceEnrollment({ root, scoped, source, hostHome }) {
-  const enrollment = await resolvePrivateSessionTimelineEnrollment({ root, host: scoped.host, sessionId: scoped.sessionId,
-    transcriptPath: source.path, hostHome });
-  if (enrollment.status !== "enrolled" || !sameTimelineBinding(enrollment.binding, scoped)
-    || !sameSourceSnapshot(enrollment.source, source)) return false;
-  return true;
+const enrollment = await resolvePrivateSessionTimelineEnrollment({ root, host: scoped.host, sessionId: scoped.sessionId,
+transcriptPath: source.path, hostHome });
+if (enrollment.status !== "enrolled" || !sameTimelineBinding(enrollment.binding, scoped)
+|| !sameSourceSnapshot(enrollment.source, source)) return false;
+return true;
 }
-
 async function bootstrapEnrollment(root, enrollmentDigest, environment) {
-  const loaded = await loadPrivateSessionTimelineEnrollment({ root, enrollmentDigest });
-  if (loaded.status !== "loaded") return null;
-  const transportDigest = timelineTransportDigest({
-    root: loaded.rootPath, binding: loaded.record.binding, environment
-  });
-  return transportDigest && sameTimelineTransportDigest(loaded.record.transportDigest, transportDigest) ? loaded : null;
-}
-
+const loaded = await loadPrivateSessionTimelineEnrollment({ root, enrollmentDigest });
+if (loaded.status !== "loaded") return null;
+const transportDigest = timelineTransportDigest({
+root: loaded.rootPath, binding: loaded.record.binding, environment
+});
+return transportDigest && sameTimelineTransportDigest(loaded.record.transportDigest, transportDigest) ? loaded : null;
+}
 function enrolledSource(record, previous, now) {
-  const source = record.source;
-  const unchanged = previous && sameSourceSnapshot(previous, source);
-  return {
-    binding: record.binding, path: source.path, profileRoot: source.profileRoot, projectsRoot: source.projectsRoot,
-    pathDigest: source.pathDigest, identity: source.identity, size: source.size, mtimeNs: source.mtimeNs,
-    ctimeNs: source.ctimeNs, lessonDigest: unchanged ? previous.lessonDigest : null,
-    indexedBytes: unchanged ? previous.indexedBytes : 0, events: unchanged ? previous.events : [],
-    updatedAt: asDate(now).toISOString(), authority: AUTHORITY
-  };
-}
-
-// Bootstrap has no caller-provided source location. It copies only the source
-// metadata sealed in the just-validated enrollment into the private sidecar;
-// the MCP index remains the first and only path that opens transcript bytes.
+const source = record.source;
+const unchanged = previous && sameSourceSnapshot(previous, source);
+return {
+binding: record.binding, path: source.path, profileRoot: source.profileRoot, projectsRoot: source.projectsRoot,
+pathDigest: source.pathDigest, identity: source.identity, size: source.size, mtimeNs: source.mtimeNs,
+ctimeNs: source.ctimeNs, lessonDigest: unchanged ? previous.lessonDigest : null,
+indexedBytes: unchanged ? previous.indexedBytes : 0, events: unchanged ? previous.events : [],
+updatedAt: asDate(now).toISOString(), authority: AUTHORITY
+};
+}
 export async function bootstrapSessionTimelineEnrollment({
-  root, enrollmentDigest, environment = process.env, now = new Date()
+root, enrollmentDigest, environment = process.env, now = new Date()
 }) {
-  const loaded = await bootstrapEnrollment(root, enrollmentDigest, environment);
-  if (!loaded) return status({ status: "unavailable", reason: "private-enrollment-unavailable" });
-  const { rootPath, record } = loaded;
-  try { await ensureSessionTimelineTrust({ create: true }); }
-  catch { return status({ status: "unavailable", reason: "timeline-state-unavailable" }); }
-  try {
-    const names = await paths(rootPath);
-    await withOwnedFileLock(names.lock, async ({ assertOwned }) => {
-      const state = await readState(names.path, rootPath, names.assertStable);
-      const previous = sourceFor(state, record.binding);
-      if (previous && sameSourceSnapshot(previous, record.source)) return;
-      state.sources = state.sources.filter((item) => !sameTimelineBinding(item.binding, record.binding));
-      state.sources.unshift(enrolledSource(record, previous, now));
-      state.sources = state.sources.slice(0, MAX_SOURCES);
-      await saveState(state, names.path, assertOwned, rootPath, names.assertStable);
-    }, { assertPath: names.assertStable });
-  } catch { return status({ status: "unavailable", reason: "timeline-state-unavailable" }); }
-  return status({ status: "registered", bootstrap: "signed-enrollment-metadata" });
-}
-
-// Hooks use this deliberately source-blind hint after compaction. It proves
-// only that a matching signed enrollment and sidecar still exist; the next
-// bound MCP index/search revalidates the immutable source before any read.
+const loaded = await bootstrapEnrollment(root, enrollmentDigest, environment);
+if (!loaded) return status({ status: "unavailable", reason: "private-enrollment-unavailable" });
+const { rootPath, record } = loaded;
+try { await ensureSessionTimelineTrust({ create: true }); }
+catch { return status({ status: "unavailable", reason: "timeline-state-unavailable" }); }
+try {
+const names = await paths(rootPath);
+await withOwnedFileLock(names.lock, async ({ assertOwned }) => {
+const state = await readState(names.path, rootPath, names.assertStable);
+const previous = sourceFor(state, record.binding);
+if (previous && sameSourceSnapshot(previous, record.source)) return;
+state.sources = state.sources.filter((item) => !sameTimelineBinding(item.binding, record.binding));
+state.sources.unshift(enrolledSource(record, previous, now));
+state.sources = state.sources.slice(0, MAX_SOURCES);
+await saveState(state, names.path, assertOwned, rootPath, names.assertStable);
+}, { assertPath: names.assertStable });
+} catch { return status({ status: "unavailable", reason: "timeline-state-unavailable" }); }
+return status({ status: "registered", bootstrap: "signed-enrollment-metadata" });
+}
 export async function sessionTimelineLifecycleHint({
-  root, host, sessionId, scope, environment = process.env
+root, host, sessionId, scope, environment = process.env
 }) {
-  const scoped = sessionTimelineBinding({ host, sessionId, scope });
-  if (!hasExactPrivateTimelineScope(scope)) return status({ status: "group-suppressed" });
-  // Lifecycle input cannot assert private visibility. Its exact signed
-  // enrollment below is the authority for this source-blind status hint.
-  if (!completeTimelineBinding(scoped)) {
-    return status({ status: "unavailable", reason: "timeline-scope-unverified" });
-  }
-  const loaded = await loadPrivateSessionTimelineEnrollment({ root, host, sessionId, scope });
-  if (loaded.status !== "loaded") return status({ status: "unavailable", reason: "private-enrollment-unavailable" });
-  const transportDigest = timelineTransportDigest({ root: loaded.rootPath, binding: loaded.record.binding, environment });
-  if (!transportDigest || !sameTimelineTransportDigest(loaded.record.transportDigest, transportDigest)) {
-    return status({ status: "unavailable", reason: "private-enrollment-unavailable" });
-  }
-  try {
-    await ensureSessionTimelineTrust();
-    const names = await paths(loaded.rootPath);
-    const state = await readState(names.path, loaded.rootPath, names.assertStable);
-    const source = sourceFor(state, scoped);
-    if (!source) return status({ status: "unavailable", reason: "timeline-not-registered" });
-    return status({ status: source.indexedBytes >= source.size ? "indexed" : "partial", ...sourceMetadata(source),
-      priorSessions: priorTimelineHint(state, scoped, (item) => sourceMetadata(item).sourceDigest,
-        { includePriorProviders: crossProviderTimelineEnabled(environment) }),
-      freshness: "source-not-read", instruction: "Use session_timeline_index before search when this snapshot is partial." });
-  } catch {
-    return status({ status: "unavailable", reason: "timeline-state-unavailable" });
-  }
-}
-
-// Source registration used to accept a raw caller path. That would turn a
-// direct API call into a second transcript reader, so the only supported
-// setup is now receipt-backed enrollment followed by signed metadata bootstrap.
-// Keep this explicit no-data result for callers upgrading from the legacy API.
+const scoped = sessionTimelineBinding({ host, sessionId, scope });
+if (!hasExactPrivateTimelineScope(scope)) return status({ status: "group-suppressed" });
+if (!completeTimelineBinding(scoped)) {
+return status({ status: "unavailable", reason: "timeline-scope-unverified" });
+}
+const loaded = await loadPrivateSessionTimelineEnrollment({ root, host, sessionId, scope });
+if (loaded.status !== "loaded") return status({ status: "unavailable", reason: "private-enrollment-unavailable" });
+const transportDigest = timelineTransportDigest({ root: loaded.rootPath, binding: loaded.record.binding, environment });
+if (!transportDigest || !sameTimelineTransportDigest(loaded.record.transportDigest, transportDigest)) {
+return status({ status: "unavailable", reason: "private-enrollment-unavailable" });
+}
+try {
+await ensureSessionTimelineTrust();
+const names = await paths(loaded.rootPath);
+const state = await readState(names.path, loaded.rootPath, names.assertStable);
+const source = sourceFor(state, scoped);
+if (!source) return status({ status: "unavailable", reason: "timeline-not-registered" });
+return status({ status: source.indexedBytes >= source.size ? "indexed" : "partial", ...sourceMetadata(source),
+priorSessions: priorTimelineHint(state, scoped, (item) => sourceMetadata(item).sourceDigest,
+{ includePriorProviders: crossProviderTimelineEnabled(environment) }),
+freshness: "source-not-read", instruction: "Use session_timeline_index before search when this snapshot is partial." });
+} catch {
+return status({ status: "unavailable", reason: "timeline-state-unavailable" });
+}
+}
 export async function registerSessionTimelineSource() {
-  return status({ status: "unavailable", reason: "timeline-enrollment-bootstrap-required" });
+return status({ status: "unavailable", reason: "timeline-enrollment-bootstrap-required" });
 }
-
 function mergeEvents(existing, additions) {
-  const byId = new Map(existing.map((item) => [item.id, item]));
-  for (const item of additions) byId.set(item.id, item);
-  const ordered = [...byId.values()].sort((left, right) => left.at.localeCompare(right.at) || left.offset - right.offset);
-  const evidence = ordered.filter((item) => item.kind !== "user-message-candidate").slice(-MAX_EVENTS);
-  const available = Math.min(256, MAX_EVENTS - evidence.length);
-  const feedback = ordered.filter((item) => item.kind === "user-message-candidate")
-    .slice(available ? -available : ordered.length);
-  return [...evidence, ...feedback].sort((left, right) => left.at.localeCompare(right.at) || left.offset - right.offset);
+const byId = new Map(existing.map((item) => [item.id, item]));
+for (const item of additions) byId.set(item.id, item);
+const ordered = [...byId.values()].sort((left, right) => left.at.localeCompare(right.at) || left.offset - right.offset);
+const evidence = ordered.filter((item) => item.kind !== "user-message-candidate").slice(-MAX_EVENTS);
+const available = Math.min(256, MAX_EVENTS - evidence.length);
+const feedback = ordered.filter((item) => item.kind === "user-message-candidate")
+.slice(available ? -available : ordered.length);
+return [...evidence, ...feedback].sort((left, right) => left.at.localeCompare(right.at) || left.offset - right.offset);
 }
 function parsedEvents(buffer, start, dropFirst = false, host = "claude", includeUserMessages = false) {
-  const result = [];
-  let index = 0;
-  while (index < buffer.byteLength) {
-    const newline = buffer.indexOf(0x0a, index);
-    const end = newline < 0 ? buffer.byteLength : newline + 1;
-    const line = buffer.subarray(index, end);
-    if (!(dropFirst && index === 0) && line.byteLength) {
-      const event = eventFromTimelineLine(line.toString("utf8"), start + index, AUTHORITY, host);
-      if (event && (includeUserMessages || event.kind !== "user-message-candidate")) {
-        if (event.kind === "explicit-next-step-correction") delete event.nextStepSummary;
-        delete event.sourceText;
-        result.push(event);
-      }
-    }
-    index = end;
-  }
-  return result;
-}
-
+const result = [];
+let index = 0;
+while (index < buffer.byteLength) {
+const newline = buffer.indexOf(0x0a, index);
+const end = newline < 0 ? buffer.byteLength : newline + 1;
+const line = buffer.subarray(index, end);
+if (!(dropFirst && index === 0) && line.byteLength) {
+const event = eventFromTimelineLine(line.toString("utf8"), start + index, AUTHORITY, host);
+if (event && (includeUserMessages || event.kind !== "user-message-candidate")) {
+if (event.kind === "explicit-next-step-correction") delete event.nextStepSummary;
+delete event.sourceText;
+result.push(event);
+}
+}
+index = end;
+}
+return result;
+}
 async function indexRange(source, start, maximum, hostHome = null) {
-  const opened = await validatedHandle(source, hostHome);
-  if (opened.status !== "open") return opened;
-  try {
-    if (start >= opened.size) return { status: "indexed", next: opened.size, events: [], size: opened.size };
-    const bytes = await readRange(opened.handle, start, Math.min(maximum, opened.size - start));
-    const last = bytes.lastIndexOf(0x0a);
-    const completeAtEnd = start + bytes.byteLength === opened.size;
-    if (last < 0 && !completeAtEnd) return { status: "partial-line", events: [], size: opened.size };
-    const selected = last < 0 || completeAtEnd ? bytes : bytes.subarray(0, last + 1);
-    const before = start > 0 ? await readRange(opened.handle, start - 1, 1) : Buffer.alloc(0);
-    if (!await unchangedHandle(opened.handle, source, hostHome)) return { status: "unavailable", reason: "transcript-changed" };
-    return { status: "indexed", next: start + selected.byteLength,
-      events: parsedEvents(selected, start, start > 0 && before[0] !== 0x0a, source.binding.host,
-        Boolean(source.binding.portalRef && source.binding.threadRef)), size: opened.size };
-  } finally { await opened.handle.close(); }
-}
-
+const opened = await validatedHandle(source, hostHome);
+if (opened.status !== "open") return opened;
+try {
+if (start >= opened.size) return { status: "indexed", next: opened.size, events: [], size: opened.size };
+const bytes = await readRange(opened.handle, start, Math.min(maximum, opened.size - start));
+const last = bytes.lastIndexOf(0x0a);
+const completeAtEnd = start + bytes.byteLength === opened.size;
+if (last < 0 && !completeAtEnd) return { status: "partial-line", events: [], size: opened.size };
+const selected = last < 0 || completeAtEnd ? bytes : bytes.subarray(0, last + 1);
+const before = start > 0 ? await readRange(opened.handle, start - 1, 1) : Buffer.alloc(0);
+if (!await unchangedHandle(opened.handle, source, hostHome)) return { status: "unavailable", reason: "transcript-changed" };
+return { status: "indexed", next: start + selected.byteLength,
+events: parsedEvents(selected, start, start > 0 && before[0] !== 0x0a, source.binding.host,
+Boolean(source.binding.portalRef && source.binding.threadRef)), size: opened.size };
+} finally { await opened.handle.close(); }
+}
 async function mutateSource(root, scoped, task) {
-  try { await ensureSessionTimelineTrust(); }
-  catch { return status({ status: "unavailable", reason: "timeline-state-unavailable" }); }
-  let names;
-  try { names = await paths(root); }
-  catch { return status({ status: "unavailable", reason: "timeline-state-unavailable" }); }
-  return withOwnedFileLock(names.lock, async ({ assertOwned }) => {
-    let state;
-    try { state = await readState(names.path, root, names.assertStable); }
-    catch { return status({ status: "unavailable", reason: "timeline-state-unavailable" }); }
-    const source = sourceFor(state, scoped);
-    if (!source) return status({ status: "unavailable", reason: "timeline-not-registered" });
-    const result = await task(source);
-    if (result.status === "indexed") {
-      source.size = result.size;
-      if (!result.preserveCursor) source.indexedBytes = Math.max(source.indexedBytes, result.next);
-      source.events = mergeEvents(source.events, result.events); source.updatedAt = new Date().toISOString();
-      await saveState(state, names.path, assertOwned, root, names.assertStable);
-    }
-    return result.status === "indexed" ? status({ status: source.indexedBytes >= source.size ? "indexed"
-      : result.preserveCursor ? "fresh-tail" : "partial", ...sourceMetadata(source), added: result.events.length })
-      : status(result);
-  }, { assertPath: names.assertStable }).catch(() =>
-    status({ status: "unavailable", reason: "timeline-state-unavailable" }));
-}
-
+try { await ensureSessionTimelineTrust(); }
+catch { return status({ status: "unavailable", reason: "timeline-state-unavailable" }); }
+let names;
+try { names = await paths(root); }
+catch { return status({ status: "unavailable", reason: "timeline-state-unavailable" }); }
+return withOwnedFileLock(names.lock, async ({ assertOwned }) => {
+let state;
+try { state = await readState(names.path, root, names.assertStable); }
+catch { return status({ status: "unavailable", reason: "timeline-state-unavailable" }); }
+const source = sourceFor(state, scoped);
+if (!source) return status({ status: "unavailable", reason: "timeline-not-registered" });
+const result = await task(source);
+if (result.status === "indexed") {
+source.size = result.size;
+if (!result.preserveCursor) source.indexedBytes = Math.max(source.indexedBytes, result.next);
+source.events = mergeEvents(source.events, result.events); source.updatedAt = new Date().toISOString();
+await saveState(state, names.path, assertOwned, root, names.assertStable);
+}
+return result.status === "indexed" ? status({ status: source.indexedBytes >= source.size ? "indexed"
+: result.preserveCursor ? "fresh-tail" : "partial", ...sourceMetadata(source), added: result.events.length })
+: status(result);
+}, { assertPath: names.assertStable }).catch(() =>
+status({ status: "unavailable", reason: "timeline-state-unavailable" }));
+}
 export async function indexSessionTimeline({
-  root, host, sessionId, scope, maxBytes = 4 * 1024 * 1024,
-  invocationRequest = null, transportDigest = null, enrollmentDigest = null, hostHome = null
+root, host, sessionId, scope, maxBytes = 4 * 1024 * 1024,
+invocationRequest = null, transportDigest = null, enrollmentDigest = null, hostHome = null
 }) {
-  const scoped = sessionTimelineBinding({ host, sessionId, scope });
-  if (!hasExactPrivateTimelineScope(scope)) return status({ status: "group-suppressed" });
-  if (!hasVerifiedTimelinePrivateScope(scope)) return status({ status: "unavailable", reason: "timeline-scope-unverified" });
-  if (!completeTimelineBinding(scoped)) return status({ status: "unavailable", reason: "missing-session-scope" });
-  if (!Number.isInteger(maxBytes) || maxBytes < 64 * 1024 || maxBytes > MAX_INDEX_BYTES) throw new Error("timeline index byte budget is invalid");
-  return mutateSource(root, scoped, async (source) => {
-    if (!await confirmedSourceEnrollment({ root, scoped, source, hostHome })) {
-      return { status: "unavailable", reason: "private-enrollment-unavailable" };
-    }
-    const sourceDigest = sourceMetadata(source).sourceDigest;
-    if (!invocationRequest || !await timelineTransportEnrollmentMatches({ root, binding: scoped, enrollmentDigest, transportDigest, hostHome })
-      || !await consumeSessionTimelineInvocation({ root, tool: "index", binding: scoped, sourceDigest,
-        request: invocationRequest, transportDigest })) {
-      return { status: "unavailable", reason: "timeline-invocation-unavailable" };
-    }
-    return indexRange(source, source.indexedBytes, maxBytes, hostHome);
-  });
-}
-
-// Tail refresh is intentionally retired: only a bound MCP index invocation
-// may open an enrolled transcript, and it must consume its one-use permit.
+const scoped = sessionTimelineBinding({ host, sessionId, scope });
+if (!hasExactPrivateTimelineScope(scope)) return status({ status: "group-suppressed" });
+if (!hasVerifiedTimelinePrivateScope(scope)) return status({ status: "unavailable", reason: "timeline-scope-unverified" });
+if (!completeTimelineBinding(scoped)) return status({ status: "unavailable", reason: "missing-session-scope" });
+if (!Number.isInteger(maxBytes) || maxBytes < 64 * 1024 || maxBytes > MAX_INDEX_BYTES) throw new Error("timeline index byte budget is invalid");
+return mutateSource(root, scoped, async (source) => {
+if (!await confirmedSourceEnrollment({ root, scoped, source, hostHome })) {
+return { status: "unavailable", reason: "private-enrollment-unavailable" };
+}
+const sourceDigest = sourceMetadata(source).sourceDigest;
+if (!invocationRequest || !await timelineTransportEnrollmentMatches({ root, binding: scoped, enrollmentDigest, transportDigest, hostHome })
+|| !await consumeSessionTimelineInvocation({ root, tool: "index", binding: scoped, sourceDigest,
+request: invocationRequest, transportDigest })) {
+return { status: "unavailable", reason: "timeline-invocation-unavailable" };
+}
+return indexRange(source, source.indexedBytes, maxBytes, hostHome);
+});
+}
 export async function refreshSessionTimelineTail() {
-  return status({ status: "unavailable", reason: "timeline-mcp-index-required" });
+return status({ status: "unavailable", reason: "timeline-mcp-index-required" });
 }
-
 export async function sessionTimelineStatus({ root, host, sessionId, scope, environment = process.env }) {
-  if (!hasExactPrivateTimelineScope(scope)) return status({ status: "group-suppressed" });
-  if (!hasVerifiedTimelinePrivateScope(scope)) return status({ status: "unavailable", reason: "timeline-scope-unverified" });
-  // Status is intentionally a sidecar-only hint. Immutable source validation
-  // is kept at receipt consumption and PreTool, while MCP index/search alone
-  // perform bounded evidence reads.
-  return sessionTimelineLifecycleHint({ root, host, sessionId, scope, environment });
-}
-
+if (!hasExactPrivateTimelineScope(scope)) return status({ status: "group-suppressed" });
+if (!hasVerifiedTimelinePrivateScope(scope)) return status({ status: "unavailable", reason: "timeline-scope-unverified" });
+return sessionTimelineLifecycleHint({ root, host, sessionId, scope, environment });
+}
 export async function authorizeSessionTimelineInvocation({
-  root, host, sessionId, scope, hostHome, tool, request, toolUseId, transportDigest, enrollmentDigest,
-  environment = process.env
+root, host, sessionId, scope, hostHome, tool, request, toolUseId, transportDigest, enrollmentDigest,
+environment = process.env
 }) {
-  const scoped = sessionTimelineBinding({ host, sessionId, scope });
-  if (!hasExactPrivateTimelineScope(scope) || !completeTimelineBinding(scoped) || !/^(index|search|capture)$/.test(tool || "")) return null;
-  if (!hasVerifiedTimelinePrivateScope(scope)) return null;
-  try {
-    await ensureSessionTimelineTrust();
-    const names = await paths(root);
-    const state = await readState(names.path, root, names.assertStable);
-    const currentSource = sourceFor(state, scoped);
-    if (!currentSource || !await pathMatchesSource(currentSource, hostHome)
-      || !await confirmedSourceEnrollment({ root, scoped, source: currentSource, hostHome })) return null;
-    const includePriorProviders = request?.includePriorProviders === true;
-    if (includePriorProviders && (request?.includePriorSessions !== true || !crossProviderTimelineEnabled(environment))) return null;
-    const query = tool !== "index" ? timelineQuery({ at: request?.at, query: request?.query }) : null;
-    const source = request?.includePriorSessions === true
-      ? selectPriorTimelineSource(state, scoped, { ...query, windowMs: request.windowSeconds * 1000,
-        includePriorProviders }) : currentSource;
-    const sourceHome = source?.binding.host === scoped.host ? hostHome : source?.profileRoot;
-    if (!source || !await pathMatchesSource(source, sourceHome)
-      || !await confirmedSourceEnrollment({ root, scoped: source.binding, source, hostHome: sourceHome })) return null;
-    const sourceDigest = sourceMetadata(source).sourceDigest;
-    if (!await timelineTransportEnrollmentMatches({ root, binding: scoped, enrollmentDigest, transportDigest, hostHome })) return null;
-    await issueSessionTimelineInvocation({
-      root, tool, binding: scoped, sourceDigest, request, toolUseId, transportDigest
-    });
-    return { sourceDigest, authority: AUTHORITY };
-  } catch { return null; }
-}
-
-// Reopen only exact, already-captured sources needed by one interpretation.
-// The outer capture invocation remains the sole public gate.
+const scoped = sessionTimelineBinding({ host, sessionId, scope });
+if (!hasExactPrivateTimelineScope(scope) || !completeTimelineBinding(scoped) || !/^(index|search|capture)$/.test(tool || "")) return null;
+if (!hasVerifiedTimelinePrivateScope(scope)) return null;
+try {
+await ensureSessionTimelineTrust();
+const names = await paths(root);
+const state = await readState(names.path, root, names.assertStable);
+const currentSource = sourceFor(state, scoped);
+if (!currentSource || !await pathMatchesSource(currentSource, hostHome)
+|| !await confirmedSourceEnrollment({ root, scoped, source: currentSource, hostHome })) return null;
+const includePriorProviders = request?.includePriorProviders === true;
+if (includePriorProviders && (request?.includePriorSessions !== true || !crossProviderTimelineEnabled(environment))) return null;
+const query = tool !== "index" ? timelineQuery({ at: request?.at, query: request?.query }) : null;
+const source = request?.includePriorSessions === true
+? selectPriorTimelineSource(state, scoped, { ...query, windowMs: request.windowSeconds * 1000,
+includePriorProviders, sessionRef: request?.ref }) : currentSource;
+const sourceHome = source?.binding.host === scoped.host ? hostHome : source?.profileRoot;
+if (!source || !await pathMatchesSource(source, sourceHome)
+|| !await confirmedSourceEnrollment({ root, scoped: source.binding, source, hostHome: sourceHome })) return null;
+const sourceDigest = sourceMetadata(source).sourceDigest;
+if (!await timelineTransportEnrollmentMatches({ root, binding: scoped, enrollmentDigest, transportDigest, hostHome })) return null;
+await issueSessionTimelineInvocation({
+root, tool, binding: scoped, sourceDigest, request, toolUseId, transportDigest
+});
+return { sourceDigest, authority: AUTHORITY };
+} catch { return null; }
+}
 export async function reverifyTimelineFeedbackSources({
-  root, host, sessionId, scope, references, includePriorProviders = false,
-  environment = process.env, hostHome = null
+root, host, sessionId, scope, references, includePriorProviders = false,
+environment = process.env, hostHome = null
 }) {
-  const scoped = sessionTimelineBinding({ host, sessionId, scope });
-  if (!completeTimelineBinding(scoped) || !hasVerifiedTimelinePrivateScope(scope)
-    || !Array.isArray(references) || !references.length || references.length > 3
-    || includePriorProviders && !crossProviderTimelineEnabled(environment)) return null;
-  try {
-    await ensureSessionTimelineTrust();
-    const names = await paths(root);
-    const state = await readState(names.path, root, names.assertStable);
-    const fields = ["entityId", "userId", "tenantId", "projectId", "taskId", "groupId", "portalRef", "threadRef"];
-    const eligible = state.sources.filter((source) => fields.every((key) =>
-      (source.binding[key] ?? null) === (scoped[key] ?? null))
-      && (includePriorProviders || source.binding.host === scoped.host));
-    const verified = [];
-    for (const reference of references) {
-      const source = eligible.find((item) => item.binding.host === reference.sourceProvider
-        && timelineSessionReference(item.binding) === reference.sessionRef
-        && sourceMetadata(item).sourceDigest === reference.sourceDigest);
-      const sourceHome = source?.binding.host === scoped.host ? hostHome : source?.profileRoot;
-      const indexed = source?.events.find((item) => item.id === reference.eventId
-        && item.sha256 === reference.messageDigest && item.at === reference.observedAt);
-      if (!source || !indexed || reference.messageRef !== reference.eventId
-        || !await confirmedSourceEnrollment({ root, scoped: source.binding, source, hostHome: sourceHome })) return null;
-      const opened = await validatedHandle(source, sourceHome);
-      if (opened.status !== "open") return null;
-      try {
-        const current = await verifyTimelineEvent({ handle: opened.handle, event: indexed, readRange, digest,
-          eventFromLine: (line, offset) => verifiedTimelineEventFromLine(line, offset, AUTHORITY, source.binding.host) });
-        if (!current || current.kind !== "user-message-candidate"
-          || !await unchangedHandle(opened.handle, source, sourceHome)) return null;
-        verified.push({ ...current, sourceDigest: reference.sourceDigest,
-          sourceProvider: reference.sourceProvider, sessionRef: reference.sessionRef });
-      } finally { await opened.handle.close(); }
-    }
-    return verified;
-  } catch { return null; }
-}
-
+const scoped = sessionTimelineBinding({ host, sessionId, scope });
+if (!completeTimelineBinding(scoped) || !hasVerifiedTimelinePrivateScope(scope)
+|| !Array.isArray(references) || !references.length || references.length > 3
+|| includePriorProviders && !crossProviderTimelineEnabled(environment)) return null;
+try {
+await ensureSessionTimelineTrust();
+const names = await paths(root);
+const state = await readState(names.path, root, names.assertStable);
+const fields = ["entityId", "userId", "tenantId", "projectId", "taskId", "groupId", "portalRef", "threadRef"];
+const eligible = state.sources.filter((source) => fields.every((key) =>
+(source.binding[key] ?? null) === (scoped[key] ?? null))
+&& (includePriorProviders || source.binding.host === scoped.host));
+const verified = [];
+for (const reference of references) {
+const source = eligible.find((item) => item.binding.host === reference.sourceProvider
+&& timelineSessionReference(item.binding) === reference.sessionRef
+&& sourceMetadata(item).sourceDigest === reference.sourceDigest);
+const sourceHome = source?.binding.host === scoped.host ? hostHome : source?.profileRoot;
+const indexed = source?.events.find((item) => item.id === reference.eventId
+&& item.sha256 === reference.messageDigest && item.at === reference.observedAt);
+if (!source || !indexed || reference.messageRef !== reference.eventId
+|| !await confirmedSourceEnrollment({ root, scoped: source.binding, source, hostHome: sourceHome })) return null;
+const opened = await validatedHandle(source, sourceHome);
+if (opened.status !== "open") return null;
+try {
+const current = await verifyTimelineEvent({ handle: opened.handle, event: indexed, readRange, digest,
+eventFromLine: (line, offset) => verifiedTimelineEventFromLine(line, offset, AUTHORITY, source.binding.host) });
+if (!current || current.kind !== "user-message-candidate"
+|| !await unchangedHandle(opened.handle, source, sourceHome)) return null;
+verified.push({ ...current, sourceDigest: reference.sourceDigest,
+sourceProvider: reference.sourceProvider, sessionRef: reference.sessionRef });
+} finally { await opened.handle.close(); }
+}
+return verified;
+} catch { return null; }
+}
 function searchResult(source, target, wanted, mode, events, extra = {}, includeMessageDigest = false) {
-  const index = sourceMetadata(source);
-  return timelineSearchResult({ sourceDigest: index.sourceDigest, sessionRef: timelineSessionReference(source.binding),
-    sourceProvider: source.binding.host, binding: source.binding, target, wanted, mode, events, index,
-    roomBytes: ROOM_BYTES, authority: AUTHORITY, extra, includeMessageDigest });
+const index = sourceMetadata(source);
+return timelineSearchResult({ sourceDigest: index.sourceDigest, sessionRef: timelineSessionReference(source.binding),
+sourceProvider: source.binding.host, binding: source.binding, target, wanted, mode, events, index,
+roomBytes: ROOM_BYTES, authority: AUTHORITY, extra, includeMessageDigest });
 }
-
 export async function searchSessionTimeline({
-  root, host, sessionId, scope, at, query, windowSeconds = undefined,
-  includePriorSessions = false, includePriorProviders = false, environment = process.env,
-  invocationRequest = null, invocationTool = "search", transportDigest = null, enrollmentDigest = null, hostHome = null
+root, host, sessionId, scope, at, query, windowSeconds = undefined,
+includePriorSessions = false, includePriorProviders = false, environment = process.env,
+invocationRequest = null, invocationTool = "search", transportDigest = null, enrollmentDigest = null, hostHome = null
 }) {
-  const scoped = sessionTimelineBinding({ host, sessionId, scope });
-  if (!hasExactPrivateTimelineScope(scope) || !hasVerifiedTimelinePrivateScope(scope) || !completeTimelineBinding(scoped)) {
-    return { blocked: true, reason: "session timeline scope is unavailable", authority: AUTHORITY };
-  }
-  const { target, wanted } = timelineQuery({ at, query });
-  const boundedWindowSeconds = windowSeconds === undefined ? 0 : windowSeconds;
-  if (!Number.isInteger(boundedWindowSeconds) || boundedWindowSeconds < 0 || boundedWindowSeconds > 900) {
-    throw new Error("timeline window is invalid");
-  }
-  if (typeof includePriorSessions !== "boolean") throw new Error("prior session selection is invalid");
-  if (typeof includePriorProviders !== "boolean") throw new Error("prior provider selection is invalid");
-  if (includePriorProviders && (!includePriorSessions || !crossProviderTimelineEnabled(environment))) {
-    return { blocked: true, reason: "cross-provider timeline recall is unavailable", authority: AUTHORITY };
-  }
-  try { await ensureSessionTimelineTrust(); }
-  catch { return { blocked: true, reason: "session timeline is unavailable", authority: AUTHORITY }; }
-  let names; let state;
-  try {
-    names = await paths(root);
-    state = await readState(names.path, root, names.assertStable);
-  }
-  catch { return { blocked: true, reason: "session timeline is unavailable", authority: AUTHORITY }; }
-  const currentSource = sourceFor(state, scoped);
-  if (!currentSource) return { blocked: true, reason: "session timeline is unavailable", authority: AUTHORITY };
-  if (!await confirmedSourceEnrollment({ root, scoped, source: currentSource, hostHome })) {
-    return { blocked: true, reason: "session timeline is unavailable", authority: AUTHORITY };
-  }
-  const source = includePriorSessions
-    ? selectPriorTimelineSource(state, scoped, { target, wanted, windowMs: boundedWindowSeconds * 1000,
-      includePriorProviders })
-    : currentSource;
-  const sourceHome = source?.binding.host === scoped.host ? hostHome : source?.profileRoot;
-  if (!source || !await pathMatchesSource(source, sourceHome)
-    || !await confirmedSourceEnrollment({ root, scoped: source.binding, source, hostHome: sourceHome })) {
-    return { blocked: true, reason: "session timeline is unavailable", authority: AUTHORITY };
-  }
-  const sourceDigest = sourceMetadata(source).sourceDigest;
-  if (!/^(search|capture)$/.test(invocationTool) || !invocationRequest
-    || !await timelineTransportEnrollmentMatches({ root, binding: scoped, enrollmentDigest, transportDigest, hostHome })
-    || !await consumeSessionTimelineInvocation({ root, tool: invocationTool, binding: scoped, sourceDigest,
-      request: invocationRequest, transportDigest })) {
-    return { blocked: true, reason: "session timeline invocation is unavailable", authority: AUTHORITY };
-  }
-  const indexed = rankTimelineEvents(source.events
-    .filter((event) => matchesTimelineEvent(event, wanted, target, boundedWindowSeconds * 1000)), wanted, target).slice(0, 8);
-  if (includePriorSessions && !indexed.length) {
-    return searchResult(source, target, wanted, "prior-index", [], { priorSession: true,
-      priorProvider: source.binding.host !== scoped.host }, invocationTool === "capture");
-  }
-  const opened = await validatedHandle(source, sourceHome);
-  if (opened.status !== "open") return { blocked: true, reason: opened.reason, authority: AUTHORITY };
-  try {
-    const verified = [];
-    for (const event of indexed) {
-      const current = await verifyTimelineEvent({ handle: opened.handle, event, readRange, digest,
-        eventFromLine: (line, offset) => verifiedTimelineEventFromLine(line, offset, AUTHORITY, source.binding.host) });
-      if (!current || !matchesTimelineEvent(current, wanted, target, boundedWindowSeconds * 1000)) return { blocked: true, reason: "timeline evidence changed", authority: AUTHORITY };
-      verified.push(current);
-    }
-    if (verified.length) {
-      if (!await unchangedHandle(opened.handle, source, sourceHome)) return { blocked: true, reason: "transcript-changed", authority: AUTHORITY };
-      return searchResult(source, target, wanted, includePriorSessions ? "prior-verified-index" : "verified-index", verified,
-        includePriorSessions ? { priorSession: true, priorProvider: source.binding.host !== scoped.host } : {},
-        invocationTool === "capture");
-    }
-    if (!target) return searchResult(source, target, wanted, "verified-index", [], {}, invocationTool === "capture");
-    const sought = await seekTimelineEvidence({ handle: opened.handle, size: opened.size, target, wanted,
-      windowMs: boundedWindowSeconds * 1000, readRange,
-      eventFromLine: (line, offset) => verifiedTimelineEventFromLine(line, offset, AUTHORITY, source.binding.host),
-      extractTimestamp: extractTimelineTimestamp,
-      matches: matchesTimelineEvent, rank: rankTimelineEvents });
-    if (sought.status === "searched") {
-      if (!await unchangedHandle(opened.handle, source, sourceHome)) return { blocked: true, reason: "transcript-changed", authority: AUTHORITY };
-      return searchResult(source, target, wanted, "timestamp-seek", sought.events,
-        { budgetExhausted: sought.budgetExhausted }, invocationTool === "capture");
-    }
-    if (sought.status === "out-of-range") {
-      return searchResult(source, target, wanted, "timestamp-seek", [], {}, invocationTool === "capture");
-    }
-    return { blocked: true, reason: sought.reason, authority: AUTHORITY };
-  } finally { await opened.handle.close(); }
+const scoped = sessionTimelineBinding({ host, sessionId, scope });
+if (!hasExactPrivateTimelineScope(scope) || !hasVerifiedTimelinePrivateScope(scope) || !completeTimelineBinding(scoped)) {
+return { blocked: true, reason: "session timeline scope is unavailable", authority: AUTHORITY };
+}
+const { target, wanted } = timelineQuery({ at, query });
+const boundedWindowSeconds = windowSeconds === undefined ? 0 : windowSeconds;
+if (!Number.isInteger(boundedWindowSeconds) || boundedWindowSeconds < 0 || boundedWindowSeconds > 900) {
+throw new Error("timeline window is invalid");
+}
+if (typeof includePriorSessions !== "boolean") throw new Error("prior session selection is invalid");
+if (typeof includePriorProviders !== "boolean") throw new Error("prior provider selection is invalid");
+if (includePriorProviders && (!includePriorSessions || !crossProviderTimelineEnabled(environment))) {
+return { blocked: true, reason: "cross-provider timeline recall is unavailable", authority: AUTHORITY };
+}
+try { await ensureSessionTimelineTrust(); }
+catch { return { blocked: true, reason: "session timeline is unavailable", authority: AUTHORITY }; }
+let names; let state;
+try {
+names = await paths(root);
+state = await readState(names.path, root, names.assertStable);
+}
+catch { return { blocked: true, reason: "session timeline is unavailable", authority: AUTHORITY }; }
+const currentSource = sourceFor(state, scoped);
+if (!currentSource) return { blocked: true, reason: "session timeline is unavailable", authority: AUTHORITY };
+if (!await confirmedSourceEnrollment({ root, scoped, source: currentSource, hostHome })) {
+return { blocked: true, reason: "session timeline is unavailable", authority: AUTHORITY };
+}
+const source=includePriorSessions
+?selectPriorTimelineSource(state,scoped,{target,wanted,windowMs:boundedWindowSeconds*1000,
+includePriorProviders,sessionRef:invocationRequest?.ref})
+: currentSource;
+const sourceHome=source?.binding.host===scoped.host?hostHome:source?.profileRoot;
+if(!source||!await pathMatchesSource(source,sourceHome)
+||!await confirmedSourceEnrollment({root,scoped:source.binding,source,hostHome:sourceHome})) {
+return { blocked: true, reason: "session timeline is unavailable", authority: AUTHORITY };
+}
+const sourceDigest=sourceMetadata(source).sourceDigest;
+if(!/^(search|capture)$/.test(invocationTool)||!invocationRequest
+||!await timelineTransportEnrollmentMatches({root,binding:scoped,enrollmentDigest,transportDigest,hostHome})
+||!await consumeSessionTimelineInvocation({root,tool:invocationTool,binding:scoped,sourceDigest,
+request:invocationRequest,transportDigest})) {
+return { blocked: true, reason: "session timeline invocation is unavailable", authority: AUTHORITY };
+}
+const matchAt=invocationRequest?.ref&&target&&query==="user message"?null:target;
+const indexed=rankTimelineEvents(source.events
+.filter(event=>matchesTimelineEvent(event,wanted,matchAt,boundedWindowSeconds*1000)),wanted,target).slice(0,8);
+if (includePriorSessions && !indexed.length) {
+return searchResult(source, target, wanted, "prior-index", [], { priorSession: true,
+priorProvider: source.binding.host !== scoped.host }, invocationTool === "capture");
+}
+const opened = await validatedHandle(source, sourceHome);
+if (opened.status !== "open") return { blocked: true, reason: opened.reason, authority: AUTHORITY };
+try {
+const verified = [];
+for (const event of indexed) {
+const current = await verifyTimelineEvent({ handle: opened.handle, event, readRange, digest,
+eventFromLine: (line, offset) => verifiedTimelineEventFromLine(line, offset, AUTHORITY, source.binding.host) });
+if(!current||!matchesTimelineEvent(current,wanted,matchAt,boundedWindowSeconds*1000)) return { blocked: true, reason: "timeline evidence changed", authority: AUTHORITY };
+verified.push(current);
+}
+if (verified.length) {
+if (!await unchangedHandle(opened.handle, source, sourceHome)) return { blocked: true, reason: "transcript-changed", authority: AUTHORITY };
+return searchResult(source, target, wanted, includePriorSessions ? "prior-verified-index" : "verified-index", verified,
+includePriorSessions ? { priorSession: true, priorProvider: source.binding.host !== scoped.host } : {},
+invocationTool === "capture");
+}
+if (!target) return searchResult(source, target, wanted, "verified-index", [], {}, invocationTool === "capture");
+const sought = await seekTimelineEvidence({ handle: opened.handle, size: opened.size, target, wanted,
+windowMs: boundedWindowSeconds * 1000, readRange,
+eventFromLine: (line, offset) => verifiedTimelineEventFromLine(line, offset, AUTHORITY, source.binding.host),
+extractTimestamp: extractTimelineTimestamp,
+matches: matchesTimelineEvent, rank: rankTimelineEvents });
+if (sought.status === "searched") {
+if (!await unchangedHandle(opened.handle, source, sourceHome)) return { blocked: true, reason: "transcript-changed", authority: AUTHORITY };
+return searchResult(source, target, wanted, "timestamp-seek", sought.events,
+{ budgetExhausted: sought.budgetExhausted }, invocationTool === "capture");
+}
+if (sought.status === "out-of-range") {
+return searchResult(source, target, wanted, "timestamp-seek", [], {}, invocationTool === "capture");
+}
+return { blocked: true, reason: sought.reason, authority: AUTHORITY };
+} finally { await opened.handle.close(); }
 }