blun-king-cli 9.1.587 → 9.1.588

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

@@ -1,6 +1,5 @@
 import { createHash } from "node:crypto";
-import { constants as fsConstants } from "node:fs";
-import { mkdir, open } from "node:fs/promises";
+import { mkdir } from "node:fs/promises";
 import { isAbsolute } from "node:path";
 import { withOwnedFileLock } from "./owned-file-lock.js";
 import {
@@ -23,10 +22,12 @@ import { timelineContinuationCapsule, timelineSearchResult } from "./session-tim
 import { seekTimelineEvidence, verifyTimelineEvent } from "./session-timeline-search.js";
 import { eventFromTimelineLine, extractTimelineTimestamp } from "./session-timeline-event-extract.js";
 import { verifiedTimelineEventFromLine } from "./session-timeline-event-extract.js";
-import { matchesSourceMetadata, pathMatchesSource } from "./session-timeline-source.js";
+import { pathMatchesSource } from "./session-timeline-source.js";
+import { readRange, unchangedHandle, validatedHandle } from "./session-timeline-source-open.js";
 import { readTimelineState, saveTimelineState } from "./session-timeline-state.js";
 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";
@@ -39,8 +40,7 @@ const MAX_INDEX_BYTES = 16 * 1024 * 1024;
 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", "terms", "authority"]);
-const MUTATION_TAILS = new Map();
+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) {
@@ -58,15 +58,26 @@ function validCount(item) {
     && item.total > 0 && item.value <= item.total);
 }
 function validEvent(item) {
-  return item && typeof item === "object" && hasOnlyKeys(item, EVENT_KEYS)
+  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 || "") && item.kind === "objective-result"
-    && EVENT_OUTCOMES.has(item.outcome) && validCount(item.count)
-    && (item.testLabel === null || typeof item.testLabel === "string" && EVENT_LABEL_RE.test(item.testLabel))
+    && /^[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)
@@ -97,20 +108,6 @@ function saveState(state, path, assertOwned, root, assertStable) {
   return saveTimelineState({ state, path, root, maximumBytes: MAX_STATE_BYTES, assertOwned, assertStable });
 }
 
-async function serializeLocalMutation(key, task) {
-  const previous = MUTATION_TAILS.get(key) || Promise.resolve();
-  let release;
-  const current = new Promise(resolve => { release = resolve; });
-  const tail = previous.catch(() => {}).then(() => current);
-  MUTATION_TAILS.set(key, tail);
-  await previous.catch(() => {});
-  try { return await task(); }
-  finally {
-    release();
-    if (MUTATION_TAILS.get(key) === tail) MUTATION_TAILS.delete(key);
-  }
-}
-
 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; }
@@ -204,7 +201,8 @@ export async function sessionTimelineLifecycleHint({
     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),
+      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" });
@@ -222,32 +220,14 @@ export async function registerSessionTimelineSource() {
 function mergeEvents(existing, additions) {
   const byId = new Map(existing.map((item) => [item.id, item]));
   for (const item of additions) byId.set(item.id, item);
-  return [...byId.values()].sort((left, right) => left.at.localeCompare(right.at) || left.offset - right.offset).slice(-MAX_EVENTS);
+  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);
 }
-async function unchangedHandle(handle, source, hostHome = null) {
-  try {
-    const metadata = await handle.stat({ bigint: true });
-    return matchesSourceMetadata(metadata, source) && await pathMatchesSource(source, hostHome);
-  } catch { return false; }
-}
-
-async function validatedHandle(source, hostHome = null) {
-  if (!await pathMatchesSource(source, hostHome)) return { status: "unavailable", reason: "transcript-changed" };
-  let handle;
-  try { handle = await open(source.path, fsConstants.O_RDONLY | (fsConstants.O_NOFOLLOW || 0)); }
-  catch { return { status: "unavailable", reason: "transcript-changed" }; }
-  if (!await unchangedHandle(handle, source, hostHome)) {
-    await handle.close();
-    return { status: "unavailable", reason: "transcript-changed" };
-  }
-  return { status: "open", handle, size: source.size };
-}
-async function readRange(handle, offset, length) {
-  const buffer = Buffer.alloc(length);
-  const { bytesRead } = await handle.read(buffer, 0, length, offset);
-  return buffer.subarray(0, bytesRead);
-}
-function parsedEvents(buffer, start, dropFirst = false, host = "claude") {
+function parsedEvents(buffer, start, dropFirst = false, host = "claude", includeUserMessages = false) {
   const result = [];
   let index = 0;
   while (index < buffer.byteLength) {
@@ -256,7 +236,11 @@ function parsedEvents(buffer, start, dropFirst = false, host = "claude") {
     const line = buffer.subarray(index, end);
     if (!(dropFirst && index === 0) && line.byteLength) {
       const event = eventFromTimelineLine(line.toString("utf8"), start + index, AUTHORITY, host);
-      if (event) result.push(event);
+      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;
   }
@@ -276,7 +260,8 @@ async function indexRange(source, start, maximum, hostHome = null) {
     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), size: opened.size };
+      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(); }
 }
 
@@ -286,7 +271,7 @@ async function mutateSource(root, scoped, task) {
   let names;
   try { names = await paths(root); }
   catch { return status({ status: "unavailable", reason: "timeline-state-unavailable" }); }
-  return serializeLocalMutation(names.lock, () => withOwnedFileLock(names.lock, async ({ assertOwned }) => {
+  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" }); }
@@ -302,7 +287,7 @@ async function mutateSource(root, scoped, task) {
     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(() =>
+  }, { assertPath: names.assertStable }).catch(() =>
     status({ status: "unavailable", reason: "timeline-state-unavailable" }));
 }
 
@@ -345,10 +330,11 @@ export async function sessionTimelineStatus({ root, host, sessionId, scope, envi
 }
 
 export async function authorizeSessionTimelineInvocation({
-  root, host, sessionId, scope, hostHome, tool, request, toolUseId, transportDigest, enrollmentDigest
+  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)$/.test(tool || "")) return null;
+  if (!hasExactPrivateTimelineScope(scope) || !completeTimelineBinding(scoped) || !/^(index|search|capture)$/.test(tool || "")) return null;
   if (!hasVerifiedTimelinePrivateScope(scope)) return null;
   try {
     await ensureSessionTimelineTrust();
@@ -357,10 +343,15 @@ export async function authorizeSessionTimelineInvocation({
     const currentSource = sourceFor(state, scoped);
     if (!currentSource || !await pathMatchesSource(currentSource, hostHome)
       || !await confirmedSourceEnrollment({ root, scoped, source: currentSource, hostHome })) return null;
-    const query = tool === "search" ? timelineQuery({ at: request?.at, query: request?.query }) : 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 }) : currentSource;
-    if (!source || !await pathMatchesSource(source, hostHome)) return null;
+      ? 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({
@@ -370,17 +361,60 @@ export async function authorizeSessionTimelineInvocation({
   } catch { return null; }
 }
 
-function searchResult(source, target, wanted, mode, events, extra = {}) {
+// Reopen only exact, already-captured sources needed by one interpretation.
+// The outer capture invocation remains the sole public gate.
+export async function reverifyTimelineFeedbackSources({
+  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; }
+}
+
+function searchResult(source, target, wanted, mode, events, extra = {}, includeMessageDigest = false) {
   const index = sourceMetadata(source);
   return timelineSearchResult({ sourceDigest: index.sourceDigest, sessionRef: timelineSessionReference(source.binding),
-    target, wanted, mode, events, index,
-    roomBytes: ROOM_BYTES, authority: AUTHORITY, extra });
+    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,
-  invocationRequest = null, transportDigest = null, enrollmentDigest = null, hostHome = null
+  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)) {
@@ -392,6 +426,10 @@ export async function searchSessionTimeline({
     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;
@@ -406,23 +444,28 @@ export async function searchSessionTimeline({
     return { blocked: true, reason: "session timeline is unavailable", authority: AUTHORITY };
   }
   const source = includePriorSessions
-    ? selectPriorTimelineSource(state, scoped, { target, wanted, windowMs: boundedWindowSeconds * 1000 })
+    ? selectPriorTimelineSource(state, scoped, { target, wanted, windowMs: boundedWindowSeconds * 1000,
+      includePriorProviders })
     : currentSource;
-  if (!source || !await pathMatchesSource(source, hostHome)) {
+  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 (!invocationRequest || !await timelineTransportEnrollmentMatches({ root, binding: scoped, enrollmentDigest, transportDigest, hostHome })
-    || !await consumeSessionTimelineInvocation({ root, tool: "search", binding: scoped, 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 });
+    return searchResult(source, target, wanted, "prior-index", [], { priorSession: true,
+      priorProvider: source.binding.host !== scoped.host }, invocationTool === "capture");
   }
-  const opened = await validatedHandle(source, hostHome);
+  const opened = await validatedHandle(source, sourceHome);
   if (opened.status !== "open") return { blocked: true, reason: opened.reason, authority: AUTHORITY };
   try {
     const verified = [];
@@ -433,21 +476,25 @@ export async function searchSessionTimeline({
       verified.push(current);
     }
     if (verified.length) {
-      if (!await unchangedHandle(opened.handle, source, hostHome)) return { blocked: true, reason: "transcript-changed", authority: AUTHORITY };
+      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 } : {});
+        includePriorSessions ? { priorSession: true, priorProvider: source.binding.host !== scoped.host } : {},
+        invocationTool === "capture");
     }
-    if (!target) return searchResult(source, target, wanted, "verified-index", []);
+    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, hostHome)) return { blocked: true, reason: "transcript-changed", authority: AUTHORITY };
-      return searchResult(source, target, wanted, "timestamp-seek", sought.events, { budgetExhausted: sought.budgetExhausted });
+      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");
     }
-    if (sought.status === "out-of-range") return searchResult(source, target, wanted, "timestamp-seek", []);
     return { blocked: true, reason: sought.reason, authority: AUTHORITY };
   } finally { await opened.handle.close(); }
 }

package/agent-spine-plugin/src/lib/source-roots.js

@@ -255,7 +255,7 @@ async function claudeSources({ cwd, projectRoot, configDir, input, env, registry
     const value = await readJsonObject(path);
     if (typeof value?.autoMemoryDirectory === "string") {
       const expanded = expandHome(value.autoMemoryDirectory, homedir());
-      if (!isAbsolute(expanded)) throw new Error("Claude autoMemoryDirectory must be absolute or home-relative");
+      if (!isAbsolute(expanded)) throw new Error("autoMemoryDirectory must be absolute or home-relative");
       memoryRoot = await existingDirectory(expanded);
       memoryProvenance = "autoMemoryDirectory";
     }
@@ -358,7 +358,8 @@ export async function resolveHostSourceCatalog({ host, cwd = process.cwd(), inpu
   let hostDetails = {};
   let rootResolution = "explicit-root";
   if (host === "codex") {
-    const codexHome = env.CODEX_HOME || env.BLUN_HOME || join(homedir(), ".codex");
+    const codexHome = env.BLUN_PLUGIN_ROOT && env.BLUN_HOME
+      ? env.BLUN_HOME : env.CODEX_HOME || env.BLUN_HOME || join(homedir(), ".codex");
     hostHome = await existingDirectory(resolve(codexHome)) || resolve(codexHome);
     const config = await codexConfig(hostHome);
     if (env.AGENTSPINE_ROOT) projectRoot = await canonicalPath(env.AGENTSPINE_ROOT);

package/agent-spine-plugin/src/lib/task-knowledge-context.js

@@ -1,3 +1,7 @@
+import {
+  relevantUserFeedback, relevantUserFeedbackInterpretation
+} from "./timeline-user-feedback.js";
+
 const MAX_ITEMS = 6;
 const STOP_WORDS = new Set([
   "and", "are", "das", "der", "die", "eine", "einer", "for", "from", "für", "ist",
@@ -39,7 +43,7 @@ function empty(taskId, status) {
 
 export function taskKnowledgeContext(entries, { taskId = null, continuation, maxItems = MAX_ITEMS } = {}) {
   if (!taskId) return empty(null, "not-requested");
-  const task = continuation.tasks.find((item) => item.taskId === taskId);
+  const task = [...continuation.tasks, ...continuation.terminal].find((item) => item.taskId === taskId);
   if (!task) {
     const terminal = continuation.terminal.some((item) => item.taskId === taskId);
     return empty(taskId, terminal ? "terminal" : "unavailable");
@@ -50,7 +54,23 @@ export function taskKnowledgeContext(entries, { taskId = null, continuation, max
   const minimumMatches = Math.min(2, queryTerms.length);
   const seen = new Set();
   const ranked = [];
+  const feedbackIds = entries.filter((entry) => relevantUserFeedback(entry, task))
+    .map((entry) => entry.id).sort();
   for (const entry of entries) {
+    if (relevantUserFeedback(entry, task)) {
+      ranked.push({ entry, matchedTerms: [], score: 100_000 });
+      continue;
+    }
+    if (relevantUserFeedbackInterpretation(entry, task)) {
+      const sourceIds = [...(entry.value.sourceBindings?.map((item) => item.feedbackAssertionId)
+        || [entry.value.sourceFeedbackAssertionId])].sort();
+      if (sourceIds.length === feedbackIds.length
+        && sourceIds.every((id, index) => id === feedbackIds[index])) {
+        ranked.push({ entry, matchedTerms: [], score: 99_999 });
+      }
+      continue;
+    }
+    if (task.status === "completed") continue;
     if (entry.status !== "confirmed" || !(entry.kind in KIND_WEIGHT)) continue;
     const matchedTerms = terms(entryText(entry)).filter((item) => querySet.has(item));
     if (matchedTerms.length < minimumMatches) continue;
@@ -63,6 +83,7 @@ export function taskKnowledgeContext(entries, { taskId = null, continuation, max
   ranked.sort((left, right) => right.score - left.score
     || right.entry.observedAt.localeCompare(left.entry.observedAt)
     || left.entry.id.localeCompare(right.entry.id));
+  if (task.status === "completed" && !ranked.length) return empty(taskId, "terminal");
   const limit = Math.min(MAX_ITEMS, Math.max(1, maxItems));
   return {
     schema: "agentspine.task-knowledge-context/v1",

package/agent-spine-plugin/src/lib/timeline-continuation-update.js

@@ -0,0 +1,100 @@
+import { createHash } from "node:crypto";
+import { recordWorldAssertion, worldContext } from "./world-model.js";
+import { TIMELINE_OUTCOME_CONTRACT_SCHEMA } from "./world-knowledge.js";
+
+const CONTINUATION_SCHEMA = "agentspine.task-continuation/v1";
+
+function digest(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+function sameStep(left, right) {
+  return Boolean(left && right && left.id === right.id && left.summary === right.summary);
+}
+
+function measuredResult(event, contract) {
+  if (event.testLabel !== contract.measurement.testLabel) return null;
+  const expectedTotal = contract.measurement.total;
+  if ((expectedTotal === null) !== (event.count === null)
+    || (event.count && event.count.total !== expectedTotal)) return null;
+  const succeeded = event.outcome === "pass"
+    && (event.count === null || event.count.value === contract.measurement.successCount);
+  const result = succeeded ? "passed"
+    : event.outcome === "blocked" || event.outcome === "skipped" ? "blocked" : "failed";
+  return { succeeded, result };
+}
+
+function response(status, reason = null, assertion = null) {
+  return { schema: "agentspine.timeline-continuation-update/v1", status, reason, assertion,
+    completionVerified: assertion?.value?.status === "completed", automaticRetry: false,
+    authority: "context-only" };
+}
+
+export async function updateTimelineContinuationFromObjective({ root, scope, event, now }) {
+  try {
+    const context = await worldContext({ root, subjectId: scope.currentTaskId,
+      projectId: scope.projectId, groupId: null, includePrivate: true, includeKnowledgeHistory: true,
+      continuationTaskId: scope.currentTaskId, portalRef: scope.portalRef, threadRef: scope.threadRef,
+      maxItems: 100, now });
+    const continuations = context.knowledge.current.filter((item) => item.subjectId === scope.currentTaskId
+      && item.predicate === "task.continuation" && item.value?.schema === CONTINUATION_SCHEMA);
+    const replay = continuations.find((item) => item.status === "confirmed"
+      && item.source.id === event.id && item.value.lastVerifiedStep?.evidenceId === event.id);
+    if (replay) return response("duplicate", null, replay);
+    if (continuations.length !== 1 || continuations[0].status !== "confirmed") {
+      return response("unavailable", continuations.length ? "timeline-continuation-conflicted"
+        : "timeline-continuation-missing");
+    }
+    const current = continuations[0];
+    const contracts = context.knowledge.current.filter((item) => item.subjectId === scope.currentTaskId
+      && item.predicate === "task.timeline-outcome-contract"
+      && item.value?.schema === TIMELINE_OUTCOME_CONTRACT_SCHEMA);
+    if (contracts.length !== 1 || contracts[0].status !== "confirmed") {
+      return response("unavailable", contracts.length ? "timeline-outcome-contract-conflicted"
+        : "timeline-outcome-contract-missing");
+    }
+    const contract = contracts[0];
+    if (!sameStep(current.value.nextStep, contract.value.step)) {
+      return response("unavailable", "timeline-outcome-contract-superseded");
+    }
+    const eventTime = new Date(event.at).getTime();
+    if (eventTime < new Date(contract.recordedAt).getTime()) {
+      return response("unavailable", "timeline-outcome-contract-postdated");
+    }
+    if (eventTime < new Date(current.observedAt).getTime()
+      || eventTime < new Date(contract.observedAt).getTime()) {
+      return response("unavailable", "timeline-outcome-event-stale");
+    }
+    const measured = measuredResult(event, contract.value);
+    if (!measured) return response("unavailable", "timeline-outcome-contract-mismatch");
+    const value = structuredClone(current.value);
+    value.lastVerifiedStep = {
+      id: contract.value.step.id, summary: contract.value.step.summary, result: measured.result,
+      evidenceId: event.id, evidenceDigest: event.messageDigest,
+      observedAt: new Date(event.at).toISOString(), sessionRef: event.sessionRef,
+      messageRef: event.messageRef
+    };
+    if (measured.succeeded) {
+      value.status = contract.value.onSuccess.status;
+      value.nextStep = structuredClone(contract.value.onSuccess.nextStep);
+      if (value.status === "completed" && value.openQuestions.length) {
+        return response("unavailable", "timeline-outcome-completion-questions-open");
+      }
+    }
+    const material = [scope.currentTaskId, scope.projectId, scope.portalRef, scope.threadRef,
+      contract.id, current.id, event.id, event.messageDigest].join("\0");
+    const recorded = await recordWorldAssertion({ root,
+      id: `assertion:timeline-continuation-${digest(material).slice(0, 32)}`,
+      subjectId: scope.currentTaskId, predicate: "task.continuation", value,
+      evidenceKind: "objective-measurement", evidenceId: event.id,
+      evidenceDigest: event.messageDigest, observedAt: new Date(event.at).toISOString(),
+      projectId: scope.projectId, groupId: null, privacy: "private", knowledgeKind: "task-state",
+      sessionRef: event.sessionRef, messageRef: event.messageRef,
+      supersedes: [current.id], requireActiveSupersedes: true,
+      reason: `The source-verified timeline result matched pre-existing contract ${contract.id}.`,
+      portalRef: scope.portalRef, threadRef: scope.threadRef, now });
+    return response(recorded.status === "duplicate" ? "duplicate" : "updated", null, recorded.assertion);
+  } catch {
+    return response("unavailable", "timeline-continuation-update-unavailable");
+  }
+}

package/agent-spine-plugin/src/lib/timeline-tool-guard.js

@@ -1,13 +1,17 @@
 import { canonicalPath } from "./paths.js";
 import { resolveHostSourceCatalog } from "./source-roots.js";
 import { authorizeSessionTimelineInvocation } from "./session-timeline.js";
-import { timelineInvocationRequest, timelineToolKind } from "./mcp-timeline-tools.js";
+import {
+  timelineInterpretationRequest, timelineInvocationRequest, timelineToolKind
+} from "./mcp-timeline-tools.js";
 import { gatewayEnvironmentContext, hookDeliveryId, hostFromInput, sessionId } from "./hook-context.js";
 import { blockedHookOutput } from "./hook-output.js";
 import { sessionTimelineBinding } from "./session-timeline-contract.js";
 import { resolvePrivateSessionTimelineEnrollment } from "./session-timeline-enrollment.js";
 import { timelineTransportDigest } from "./session-timeline-transport.js";
-import { runtimeHostForTimeline, timelineHostForRuntime, timelineHostHome } from "./session-timeline-provider.js";
+import {
+  crossProviderTimelineEnabled, runtimeHostForTimeline, timelineHostForRuntime, timelineHostHome
+} from "./session-timeline-provider.js";
 
 function plainObject(value) {
   return value && typeof value === "object" && !Array.isArray(value)
@@ -32,6 +36,8 @@ function gatewayMatchesEnrollment(gateway, binding) {
   ];
   return gateway.host === runtimeHostForTimeline(binding.host)
     && fields.slice(1).every(([gatewayField, bindingField]) => gateway[gatewayField] === binding[bindingField])
+    && (gateway.portalRef ?? null) === (binding.portalRef ?? null)
+    && (gateway.threadRef ?? null) === (binding.threadRef ?? null)
     && process.env.AGENTSPINE_USER_ID === binding.userId && process.env.AGENTSPINE_TENANT_ID === binding.tenantId;
 }
 
@@ -39,6 +45,7 @@ function bindingScope(binding, enrollment) {
   return { entityId: binding.entityId, userId: binding.userId, tenantId: binding.tenantId,
     projectId: binding.projectId, groupId: null, currentTaskId: binding.taskId,
     goalId: binding.goalId, goalStepId: binding.goalStepId,
+    portalRef: binding.portalRef ?? null, threadRef: binding.threadRef ?? null,
     timelineVisibility: enrollment.timelineVisibility };
 }
 
@@ -73,6 +80,8 @@ function matchesScopeBinding(args, binding) {
     && scopeClaimsMatch(args, ["taskId", "task_id", "currentTaskId", "current_task_id"], binding.taskId)
     && scopeClaimsMatch(args, ["goalId", "goal_id"], binding.goalId)
     && scopeClaimsMatch(args, ["goalStepId", "goal_step_id"], binding.goalStepId)
+    && scopeClaimsMatch(args, ["portalRef", "portal_ref"], binding.portalRef ?? null)
+    && scopeClaimsMatch(args, ["threadRef", "thread_ref"], binding.threadRef ?? null)
     && noScopeClaims(args, ["groupId", "group_id"]);
 }
 
@@ -90,7 +99,7 @@ function matchesHostBinding(input, binding) {
       "transportDigest", "transport_digest", "enrollmentDigest", "enrollment_digest"]);
 }
 
-function claimedScope(input) {
+function claimedScope(input, gateway) {
   const claim = (keys) => {
     const values = scopeValues(input, keys).filter((value) => !absent(value));
     return values.length && values.every((value) => value === values[0]) ? values[0] : null;
@@ -99,7 +108,8 @@ function claimedScope(input) {
     entityId: claim(["entityId", "entity_id"]), userId: claim(["userId", "user_id"]),
     tenantId: claim(["tenantId", "tenant_id"]), projectId: claim(["projectId", "project_id"]),
     groupId: claim(["groupId", "group_id"]), currentTaskId: claim(["taskId", "task_id", "currentTaskId", "current_task_id"]),
-    goalId: claim(["goalId", "goal_id"]), goalStepId: claim(["goalStepId", "goal_step_id"])
+    goalId: claim(["goalId", "goal_id"]), goalStepId: claim(["goalStepId", "goal_step_id"]),
+    portalRef: gateway?.portalRef ?? null, threadRef: gateway?.threadRef ?? null
   };
 }
 
@@ -113,10 +123,19 @@ async function matchesRoot(value, root) {
 function requestInput(tool, args) {
   if (tool === "index") return args.maxBytes === undefined ? {} : { maxBytes: args.maxBytes };
   if (args.at === undefined && args.query === undefined) return null;
+  if (tool === "capture" && !/^timeline-event:[a-f0-9]{32}$/.test(args.eventId || "")) return null;
   if (args.includePriorSessions !== undefined && typeof args.includePriorSessions !== "boolean") return null;
-  return { ...(args.at === undefined ? {} : { at: args.at }), ...(args.query === undefined ? {} : { query: args.query }),
+  if (args.includePriorProviders !== undefined && typeof args.includePriorProviders !== "boolean") return null;
+  if (args.includePriorProviders === true && args.includePriorSessions !== true) return null;
+  const interpretation = tool === "capture" && args.interpretation !== undefined
+    ? timelineInterpretationRequest(args.interpretation) : null;
+  if (tool === "capture" && args.interpretation !== undefined && !interpretation) return null;
+  return { ...(tool === "capture" ? { eventId: args.eventId,
+    ...(interpretation ? { interpretation } : {}) } : {}),
+    ...(args.at === undefined ? {} : { at: args.at }), ...(args.query === undefined ? {} : { query: args.query }),
     ...(args.windowSeconds === undefined ? {} : { windowSeconds: args.windowSeconds }),
-    ...(args.includePriorSessions === undefined ? {} : { includePriorSessions: args.includePriorSessions }) };
+    ...(args.includePriorSessions === undefined ? {} : { includePriorSessions: args.includePriorSessions }),
+    ...(args.includePriorProviders === undefined ? {} : { includePriorProviders: args.includePriorProviders }) };
 }
 
 function denied(reason) {
@@ -155,7 +174,7 @@ export async function runTimelineToolGuard(input) {
     const hostSession = sessionId(input);
     const gateway = gatewayEnvironmentContext();
     if (rawGroupClaim(input, gateway)) return denied("AgentSpine session timeline is unavailable for group-scoped activity.");
-    const provisionalBinding = sessionTimelineBinding({ host, sessionId: hostSession, scope: claimedScope(input) });
+    const provisionalBinding = sessionTimelineBinding({ host, sessionId: hostSession, scope: claimedScope(input, gateway) });
     const transportDigest = timelineTransportDigest({ root, binding: provisionalBinding });
     if (!transportDigest) {
       return denied("AgentSpine session timeline requires a locally configured per-session transport capability.");
@@ -179,11 +198,15 @@ export async function runTimelineToolGuard(input) {
     const scope = bindingScope(enrollment.binding, enrollment);
     const requestFields = requestInput(tool, input.tool_input);
     if (!requestFields) return denied("AgentSpine session timeline search needs an exact time or a concrete query.");
+    if (requestFields.includePriorProviders && !crossProviderTimelineEnabled(process.env)) {
+      return denied("AgentSpine cross-provider timeline recall is not enabled by this local host.");
+    }
     if (input.tool_input.host && input.tool_input.host !== host) return denied("Timeline provider binding mismatch.");
     const updatedInput = { ...requestFields, ...(["codex", "king"].includes(host) ? { host } : {}), root, sessionId: enrollment.binding.sessionId,
       entityId: enrollment.binding.entityId, userId: enrollment.binding.userId, tenantId: enrollment.binding.tenantId,
       projectId: enrollment.binding.projectId, taskId: enrollment.binding.taskId, groupId: null,
       goalId: enrollment.binding.goalId, goalStepId: enrollment.binding.goalStepId,
+      portalRef: enrollment.binding.portalRef ?? null, threadRef: enrollment.binding.threadRef ?? null,
       timelineVisibility: enrollment.timelineVisibility, enrollmentDigest: enrollment.enrollmentDigest };
     const request = timelineInvocationRequest(tool, updatedInput, root);
     const authorization = await authorizeSessionTimelineInvocation({