@lore-co/cli 0.1.16 → 0.1.18

package/dist/runtime.js

@@ -1,15 +1,17 @@
 import { createHash, randomUUID } from "node:crypto";
-import { access, chmod, mkdir, readFile, readdir, rename, rm, stat, writeFile, } from "node:fs/promises";
-import { constants as fsConstants } from "node:fs";
+import { access, chmod, mkdir, readFile, stat, } from "node:fs/promises";
+import { constants as fsConstants, realpathSync } from "node:fs";
 import { execFile as execFileCallback } from "node:child_process";
 import { dirname, parse, relative, resolve } from "node:path";
 import { homedir } from "node:os";
-import { pathToFileURL } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { promisify } from "node:util";
 import { boundedUtf8Text, repositoryScopeFromGitRoot, } from "./repository.js";
-const RUNTIME_VERSION = typeof __LORE_VERSION__ === "string" && __LORE_VERSION__ !== ""
-    ? __LORE_VERSION__
-    : "0.1.16";
+import { ReliabilityStore, ReliabilityStoreError, atomicWriteJson as durableAtomicWriteJson, classifyRetryFailure, createIntegrationInvocationAttempt, durableUnlink, recordLocalGuardMetric, recordLocalRetrievalMetric, } from "./reliability-store.js";
+import { writeInvocationAttemptBounded, writeInvocationCompletionBounded, } from "./invocation-health-writer.js";
+import { SignedSnapshotError, verifySignedSnapshot, } from "./signed-snapshot.js";
+import { CONTEXT_CACHE_MAX_STALE_MS, isContextTransportFailure, selectCachedContext, } from "./context-fallback.js";
+import { RUNTIME_VERSION } from "./runtime-version.js";
 const IS_STANDALONE_RUNTIME = typeof __LORE_STANDALONE__ === "boolean" && __LORE_STANDALONE__;
 export const COMMAND_HOOK_AGENT_NAMES = [
     "codex",
@@ -22,11 +24,33 @@ function isCommandHookAgent(value) {
     return typeof value === "string" && COMMAND_HOOK_AGENTS.has(value);
 }
 const MAX_STDIN_BYTES = 1024 * 1024;
+const MAX_RESPONSE_BYTES = 2 * 1024 * 1024;
 const MAX_CONTEXT_CHARS = 12_000;
 const PENDING_ASSISTANT_MAX_AGE_MS = 24 * 60 * 60 * 1_000;
-const MAX_QUEUE_ITEMS = 100;
 const MAX_GIT_DIFF_BYTES = 256 * 1024;
 const MAX_GIT_FILES = 100;
+const RELIABILITY_V1_MEDIA_TYPE = "application/vnd.lore.reliability-v1+json";
+const TRUST_KEY_REFRESH_TTL_MS = 60 * 60_000;
+const TRUST_KEY_REFRESH_STATE_KEY = "snapshot-trust-keys";
+const CONTEXT_NOTICE_COOLDOWN_MS = 15 * 60_000;
+const RELIABILITY_REASON_CODES = new Set([
+    "live_success",
+    "idempotent_replay",
+    "semantic_unavailable",
+    "lexical_fallback",
+    "live_unavailable",
+    "cached_context",
+    "cached_policy",
+    "no_usable_cache",
+    "capture_queued",
+    "local_persistence_failed",
+    "governed_rule",
+    "policy_unavailable",
+    "policy_expired",
+    "user_override",
+    "invalid_response",
+    "integration_unsupported",
+]);
 const NON_SECRET_TOKEN_VALUES = new Set([
     "available",
     "configured",
@@ -81,6 +105,18 @@ export async function readLineageMetadata(home, environment = process.env) {
 function isObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function canonicalJson(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => canonicalJson(item)).join(",")}]`;
+    }
+    if (isObject(value)) {
+        return `{${Object.keys(value)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value) ?? "null";
+}
 function stringField(value) {
     return typeof value === "string" && value.trim() !== ""
         ? value
@@ -181,6 +217,48 @@ function normalizeHookInput(input, agent, environment) {
         sessionId,
     };
 }
+class InvalidHookInputError extends Error {
+    constructor() {
+        super("Hook input does not match the configured agent event");
+        this.name = "InvalidHookInputError";
+    }
+}
+function validHookInput(input, agent, eventName) {
+    const recognized = agent === "polytoken"
+        ? eventName === "UserPromptSubmit" || eventName === "AssistantResponse"
+        : agent === "cursor"
+            ? eventName === "UserPromptSubmit" ||
+                eventName === "AssistantResponse" ||
+                eventName === "PreToolUse" ||
+                eventName === "SessionEnd"
+            : eventName === "UserPromptSubmit" ||
+                eventName === "PreToolUse" ||
+                eventName === "Stop" ||
+                eventName === "SessionEnd";
+    if (!recognized) {
+        return false;
+    }
+    if (eventName === "UserPromptSubmit") {
+        return stringField(input.prompt) !== undefined;
+    }
+    if (eventName === "Stop" || eventName === "AssistantResponse") {
+        return stringField(input.last_assistant_message) !== undefined;
+    }
+    if (eventName === "PreToolUse") {
+        const toolName = stringField(input.tool_name);
+        if (toolName === undefined || !isObject(input.tool_input)) {
+            return false;
+        }
+        if (GUARD_EDIT_TOOLS.has(toolName)) {
+            return true;
+        }
+        if (GUARD_SHELL_TOOLS.has(toolName)) {
+            return stringField(input.tool_input.command) !== undefined;
+        }
+        return true;
+    }
+    return true;
+}
 function sha256(value) {
     return createHash("sha256").update(value).digest("hex");
 }
@@ -227,22 +305,16 @@ export function redactSecrets(text) {
     })
         .replace(/\b((?:set-)?cookie\s*:\s*)[^\r\n]+/giu, (_match, prefix) => `${prefix}[REDACTED:AUTHORIZATION]`);
 }
-async function atomicWriteJson(path, value, mode = 0o600) {
+async function atomicWriteJson(path, value) {
     await mkdir(dirname(path), { recursive: true, mode: 0o700 });
-    const temporaryPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
-    await writeFile(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, {
-        encoding: "utf8",
-        mode,
-        flag: "wx",
-    });
-    await rename(temporaryPath, path);
-    await chmod(path, mode);
+    await chmod(dirname(path), 0o700);
+    await durableAtomicWriteJson(path, value);
 }
 async function readRuntimeConfig(home) {
     try {
         const parsed = JSON.parse(await readFile(resolve(loreDirectory(home), "config.json"), "utf8"));
         if (!isObject(parsed) ||
-            parsed.version !== 1 ||
+            (parsed.version !== 1 && parsed.version !== 2) ||
             typeof parsed.apiUrl !== "string" ||
             typeof parsed.token !== "string" ||
             !Array.isArray(parsed.agents)) {
@@ -259,10 +331,15 @@ async function readRuntimeConfig(home) {
             /^https?:\/\//u.test(parsed.dashboardUrl)
             ? parsed.dashboardUrl.replace(/\/+$/u, "")
             : undefined;
+        const workspaceId = typeof parsed.workspaceId === "string" &&
+            /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu.test(parsed.workspaceId)
+            ? parsed.workspaceId
+            : undefined;
         return {
-            version: 1,
+            version: parsed.version,
             apiUrl: parsed.apiUrl,
             ...(dashboardUrl === undefined ? {} : { dashboardUrl }),
+            ...(workspaceId === undefined ? {} : { workspaceId }),
             token: parsed.token,
             agents,
             ...(timeoutMs === undefined ? {} : { timeoutMs }),
@@ -291,11 +368,10 @@ async function savePending(input, agent, sessionId, now, home) {
         capturedAt: now.toISOString(),
     });
 }
-async function consumePending(agent, sessionId, home) {
+async function readPending(agent, sessionId, home) {
     const path = pendingPath(agent, sessionId, home);
     try {
         const parsed = JSON.parse(await readFile(path, "utf8"));
-        await rm(path, { force: true });
         if (!isObject(parsed) ||
             parsed.agent !== agent ||
             parsed.sessionId !== sessionId ||
@@ -323,6 +399,9 @@ async function consumePending(agent, sessionId, home) {
         return null;
     }
 }
+async function clearPending(agent, sessionId, home) {
+    await durableUnlink(pendingPath(agent, sessionId, home), true);
+}
 function normalizedRepositoryPath(value) {
     const parts = [];
     for (const part of value.replaceAll("\\", "/").split("/")) {
@@ -539,6 +618,50 @@ function observationsUrl(apiUrl) {
 function contextDeliveriesUrl(apiUrl) {
     return `${apiUrl.replace(/\/+$/u, "")}/v1/context/deliveries`;
 }
+class RuntimeHttpError extends Error {
+    httpStatus;
+    constructor(message, httpStatus) {
+        super(message);
+        this.name = "RuntimeHttpError";
+        this.httpStatus = httpStatus;
+    }
+}
+async function boundedResponseJson(response) {
+    const declaredLength = response.headers.get("content-length");
+    if (declaredLength !== null &&
+        Number.isFinite(Number(declaredLength)) &&
+        Number(declaredLength) > MAX_RESPONSE_BYTES) {
+        await response.body?.cancel();
+        throw new Error("Lore response exceeds the reliability size limit");
+    }
+    if (response.body === null) {
+        return null;
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let bytes = 0;
+    try {
+        for (;;) {
+            const chunk = await reader.read();
+            if (chunk.done) {
+                break;
+            }
+            bytes += chunk.value.byteLength;
+            if (bytes > MAX_RESPONSE_BYTES) {
+                await reader.cancel();
+                throw new Error("Lore response exceeds the reliability size limit");
+            }
+            chunks.push(chunk.value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    if (bytes === 0) {
+        return null;
+    }
+    return JSON.parse(Buffer.concat(chunks.map((chunk) => Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)), bytes).toString("utf8"));
+}
 function boundedContext(value) {
     return Array.from(value.trim()).slice(0, MAX_CONTEXT_CHARS).join("");
 }
@@ -638,11 +761,276 @@ function deliveryFromResponse(value) {
         delivered,
     };
 }
-async function postTurn(config, request, fetchImplementation) {
+class IncompatibleReliabilityError extends Error {
+    incompatible = true;
+}
+async function protocolResponseJson(response) {
+    try {
+        return await boundedResponseJson(response);
+    }
+    catch (error) {
+        if (isContextTransportFailure(error)) {
+            throw error;
+        }
+        throw new IncompatibleReliabilityError("Lore response is not valid bounded JSON");
+    }
+}
+function deliveryFromSignedContext(payload, expectedRequest) {
+    const request = isObject(payload.request) ? payload.request : null;
+    if (request === null ||
+        canonicalJson(request) !== canonicalJson(expectedRequest) ||
+        typeof payload.eventId !== "string" ||
+        typeof payload.receiptId !== "string" ||
+        typeof payload.context !== "string" ||
+        !Array.isArray(payload.memories) ||
+        !Array.isArray(payload.hits) ||
+        !isObject(payload.packing)) {
+        throw new IncompatibleReliabilityError("Lore context snapshot does not bind the request or signed delivery");
+    }
+    return deliveryFromResponse({
+        context: payload.context,
+        receipt: { id: payload.receiptId },
+        memories: payload.memories,
+        hits: payload.hits,
+    });
+}
+function retrievalReliability(value, payload) {
+    const metadata = isObject(value) ? value : null;
+    const freshness = isObject(metadata?.freshness)
+        ? metadata.freshness
+        : null;
+    const policy = isObject(metadata?.policy) ? metadata.policy : null;
+    const reasons = Array.isArray(metadata?.reasons)
+        ? metadata.reasons.filter((reason) => typeof reason === "string")
+        : [];
+    const policySource = policy?.source;
+    const policyLoadedAt = policy?.loadedAt;
+    const policyValidUntil = policy?.validUntil;
+    if (metadata === null ||
+        metadata.contractVersion !== "reliability-v1" ||
+        Object.keys(metadata).length !== 9 ||
+        metadata.operation !== "retrieval" ||
+        !(metadata.requestId === null ||
+            typeof metadata.requestId === "string") ||
+        !["ok", "degraded", "failed"].includes(String(metadata.status)) ||
+        !["live", "cache", "none"].includes(String(metadata.source)) ||
+        !["none", "live_lexical", "cached_context"].includes(String(metadata.fallback)) ||
+        freshness === null ||
+        Object.keys(freshness).length !== 4 ||
+        !["fresh", "stale", "unknown"].includes(String(freshness.state)) ||
+        typeof freshness.asOf !== "string" ||
+        freshness.asOf !== payload.asOf ||
+        typeof freshness.ageMs !== "number" ||
+        !Number.isSafeInteger(freshness.ageMs) ||
+        freshness.ageMs < 0 ||
+        typeof freshness.validUntil !== "string" ||
+        freshness.validUntil !== payload.validUntil ||
+        policy === null ||
+        Object.keys(policy).length !== 4 ||
+        !["live", "cache", "none"].includes(String(policySource)) ||
+        (policy.version !== null && typeof policy.version !== "string") ||
+        (policy.version !== null && policy.version !== payload.policyVersion) ||
+        !((policySource === "none" &&
+            policy.version === null &&
+            policyLoadedAt === null &&
+            policyValidUntil === null) ||
+            (["live", "cache"].includes(String(policySource)) &&
+                typeof policy.version === "string" &&
+                typeof policyLoadedAt === "string" &&
+                Number.isFinite(Date.parse(policyLoadedAt)) &&
+                (policyValidUntil === null ||
+                    (typeof policyValidUntil === "string" &&
+                        Number.isFinite(Date.parse(policyValidUntil)))) &&
+                policyValidUntil === payload.validUntil &&
+                policyLoadedAt ===
+                    (policySource === "cache" ? payload.asOf : payload.issuedAt))) ||
+        !Array.isArray(metadata.reasons) ||
+        reasons.length === 0 ||
+        reasons.length > 8 ||
+        reasons.length !== metadata.reasons.length ||
+        new Set(reasons).size !== reasons.length ||
+        reasons.some((reason) => !RELIABILITY_REASON_CODES.has(reason)) ||
+        (metadata.requestId !== null &&
+            metadata.requestId !== payload.requestId) ||
+        (metadata.source === "live" && freshness.state !== "fresh") ||
+        (metadata.source === "live" && policySource !== "live") ||
+        (metadata.source === "cache" &&
+            (metadata.fallback !== "cached_context" ||
+                policySource !== "cache" ||
+                typeof policyValidUntil !== "string" ||
+                !["fresh", "stale"].includes(String(freshness.state)))) ||
+        (metadata.fallback === "live_lexical" &&
+            (metadata.source !== "live" ||
+                metadata.status !== "degraded" ||
+                !reasons.includes("lexical_fallback"))) ||
+        (metadata.fallback === "cached_context" &&
+            !reasons.includes("cached_context")) ||
+        (metadata.status === "ok" && metadata.fallback !== "none")
+        || (metadata.status === "degraded" && metadata.fallback === "none")
+        || (metadata.status === "failed" &&
+            (metadata.source !== "none" || metadata.fallback !== "none"))) {
+        throw new IncompatibleReliabilityError("Lore retrieval reliability metadata is invalid");
+    }
+    const cached = metadata.source === "cache";
+    const nowMs = Date.now();
+    return {
+        status: metadata.status,
+        source: metadata.source,
+        fallback: metadata.fallback,
+        reasons,
+        freshness: {
+            state: cached
+                ? nowMs < Date.parse(payload.validUntil)
+                    ? "fresh"
+                    : "stale"
+                : freshness.state,
+            asOf: payload.asOf,
+            ageMs: cached
+                ? Math.max(0, nowMs - Date.parse(payload.asOf))
+                : freshness.ageMs,
+            validUntil: payload.validUntil,
+        },
+        policyVersion: typeof policy.version === "string" ? policy.version : null,
+    };
+}
+function reliabilityWorkspaceKey(config) {
+    return (config.workspaceId ??
+        credentialReliabilityWorkspaceKey(config));
+}
+function credentialReliabilityWorkspaceKey(config) {
+    return `credential-${sha256(`${config.apiUrl}\0${config.token}`).slice(0, 32)}`;
+}
+function runtimeAccept(config) {
+    return config.version === 2
+        ? RELIABILITY_V1_MEDIA_TYPE
+        : "application/json";
+}
+async function runtimeStore(config, home) {
+    const store = new ReliabilityStore(reliabilityWorkspaceKey(config), {
+        ...(home === undefined ? {} : { home }),
+    });
+    await store.initialize();
+    await store.migrateLegacyQueue(queueDirectory(home));
+    if (config.workspaceId !== undefined) {
+        const credentialStore = new ReliabilityStore(credentialReliabilityWorkspaceKey(config), { ...(home === undefined ? {} : { home }) });
+        await credentialStore.transferPendingTo(store).catch(() => undefined);
+    }
+    return store;
+}
+function publicKeySet(value) {
+    if (!isObject(value) ||
+        typeof value.workspaceId !== "string" ||
+        !Array.isArray(value.keys)) {
+        throw new IncompatibleReliabilityError("Lore public key response is invalid");
+    }
+    const keys = value.keys.map((candidate) => {
+        if (!isObject(candidate) ||
+            typeof candidate.kid !== "string" ||
+            candidate.kty !== "OKP" ||
+            candidate.crv !== "Ed25519" ||
+            candidate.alg !== "EdDSA" ||
+            candidate.use !== "sig" ||
+            typeof candidate.x !== "string" ||
+            typeof candidate.notBefore !== "string" ||
+            !(candidate.retiredAt === null ||
+                typeof candidate.retiredAt === "string")) {
+            throw new IncompatibleReliabilityError("Lore public key response contains an invalid key");
+        }
+        return {
+            workspaceId: value.workspaceId,
+            kid: candidate.kid,
+            kty: "OKP",
+            crv: "Ed25519",
+            alg: "EdDSA",
+            use: "sig",
+            x: candidate.x,
+            notBefore: candidate.notBefore,
+            retiredAt: candidate.retiredAt,
+        };
+    });
+    if (keys.length === 0) {
+        throw new IncompatibleReliabilityError("Lore public key response is empty");
+    }
+    return { workspaceId: value.workspaceId, keys };
+}
+async function refreshTrustKeys(config, store, fetchImplementation) {
+    const response = await fetchImplementation(`${config.apiUrl.replace(/\/+$/u, "")}/v1/workspace/identity/keys`, {
+        headers: {
+            accept: RELIABILITY_V1_MEDIA_TYPE,
+            authorization: `Bearer ${config.token}`,
+            "user-agent": `lore-cli/${RUNTIME_VERSION}`,
+        },
+        signal: AbortSignal.timeout(config.timeoutMs ?? 2_500),
+    });
+    if (!response.ok) {
+        throw new RuntimeHttpError(`Lore key discovery failed with HTTP ${response.status}`, response.status);
+    }
+    const keys = publicKeySet(await protocolResponseJson(response));
+    if (config.workspaceId !== undefined &&
+        keys.workspaceId !== config.workspaceId) {
+        throw new IncompatibleReliabilityError("Lore public keys belong to a different workspace");
+    }
+    if (store.workspaceId === keys.workspaceId) {
+        await store.writePublicTrustKeys(keys.keys.map((key) => ({
+            ...key,
+            workspaceId: keys.workspaceId,
+        })));
+        await store.writeState(TRUST_KEY_REFRESH_STATE_KEY, {
+            refreshedAt: new Date().toISOString(),
+        });
+    }
+    return keys;
+}
+async function pinnedKeys(config, store, fetchImplementation) {
+    const keys = await store.readPublicTrustKeys();
+    const refreshState = await store.readState(TRUST_KEY_REFRESH_STATE_KEY);
+    const refreshedAt = isObject(refreshState)
+        ? refreshState.refreshedAt
+        : undefined;
+    const refreshedAtMs = typeof refreshedAt === "string" ? Date.parse(refreshedAt) : Number.NaN;
+    if (keys.length > 0 &&
+        Number.isFinite(refreshedAtMs) &&
+        Date.now() - refreshedAtMs < TRUST_KEY_REFRESH_TTL_MS &&
+        refreshedAtMs <= Date.now() + 5 * 60_000) {
+        return { workspaceId: store.workspaceId, keys };
+    }
+    return refreshTrustKeys(config, store, fetchImplementation);
+}
+async function verifySnapshot(compactJws, kind, config, store, fetchImplementation, allowExpired = false) {
+    const verifyWith = (keys) => verifySignedSnapshot(compactJws, {
+        workspaceId: keys.workspaceId,
+        kind,
+        keys,
+        allowExpired,
+    }).payload;
+    try {
+        return verifyWith(await pinnedKeys(config, store, fetchImplementation));
+    }
+    catch (error) {
+        if (!(error instanceof SignedSnapshotError) ||
+            error.code !== "UNTRUSTED_KEY") {
+            throw error;
+        }
+        return verifyWith(await refreshTrustKeys(config, store, fetchImplementation));
+    }
+}
+function committedAcknowledgement(value, externalEventId, serverEventId) {
+    if (!isObject(value) || !isObject(value.acknowledgement)) {
+        return false;
+    }
+    const acknowledgement = value.acknowledgement;
+    return (acknowledgement.state === "committed_server" &&
+        acknowledgement.durability === "workspace_database" &&
+        acknowledgement.replayPending === false &&
+        acknowledgement.eventId === serverEventId &&
+        acknowledgement.idempotencyKey === externalEventId);
+}
+async function postTurn(config, request, fetchImplementation, store) {
     const { idempotencyKey, ...body } = request;
     const response = await fetchImplementation(turnsUrl(config.apiUrl), {
         method: "POST",
         headers: {
+            accept: runtimeAccept(config),
             authorization: `Bearer ${config.token}`,
             "content-type": "application/json",
             "idempotency-key": idempotencyKey,
@@ -652,18 +1040,70 @@ async function postTurn(config, request, fetchImplementation) {
         signal: AbortSignal.timeout(config.timeoutMs ?? 2_500),
     });
     if (!response.ok) {
-        throw new Error(`Lore turn request failed with HTTP ${response.status}`);
-    }
-    const text = await response.text();
-    if (text.trim() === "") {
-        return emptyDelivery();
+        throw new RuntimeHttpError(`Lore turn request failed with HTTP ${response.status}`, response.status);
+    }
+    const value = await protocolResponseJson(response);
+    if (config.version === 1) {
+        return deliveryFromResponse(value);
+    }
+    if (!isObject(value) ||
+        !isObject(value.turn) ||
+        !isObject(value.capture) ||
+        typeof value.contextSnapshot !== "string" ||
+        !isObject(value.turn.event) ||
+        typeof value.turn.event.id !== "string" ||
+        !isObject(value.retrieval) ||
+        !committedAcknowledgement(value.capture, request.eventId, value.turn.event.id)) {
+        throw new IncompatibleReliabilityError("Lore turn response has no matching durable acknowledgement");
+    }
+    const payload = await verifySnapshot(value.contextSnapshot, "context", config, store, fetchImplementation, true);
+    if (payload.eventId !== value.turn.event.id ||
+        !isObject(value.turn.receipt) ||
+        payload.receiptId !== value.turn.receipt.id) {
+        throw new IncompatibleReliabilityError("Lore turn snapshot does not bind the returned event and receipt");
+    }
+    const reliability = retrievalReliability(value.retrieval, payload);
+    if (Date.now() - Date.parse(payload.validUntil) >
+        CONTEXT_CACHE_MAX_STALE_MS) {
+        return {
+            ...emptyDelivery(),
+            reliability: {
+                status: "failed",
+                source: "none",
+                fallback: "none",
+                reasons: ["no_usable_cache"],
+                freshness: {
+                    state: "unknown",
+                    asOf: null,
+                    ageMs: null,
+                    validUntil: null,
+                },
+                policyVersion: null,
+            },
+        };
     }
-    return deliveryFromResponse(JSON.parse(text));
+    await store
+        .writeContextSnapshot(request.eventId, {
+        compactJws: value.contextSnapshot,
+    })
+        .catch(() => undefined);
+    const delivery = deliveryFromSignedContext(payload, {
+        connector: request.connector,
+        eventId: request.eventId,
+        sessionId: request.sessionId,
+        task: {
+            agent: request.agent,
+            ...(request.scope === undefined ? {} : { scope: request.scope }),
+            task: request.currentUser.content,
+        },
+    });
+    return { ...delivery, reliability };
 }
-async function postPromptObservation(config, request, fetchImplementation) {
+async function postPromptObservation(config, request, fetchImplementation, _store) {
     const response = await fetchImplementation(observationsUrl(config.apiUrl), {
         method: "POST",
         headers: {
+            accept: runtimeAccept(config),
             authorization: `Bearer ${config.token}`,
             "content-type": "application/json",
             "idempotency-key": request.idempotencyKey,
@@ -695,71 +1135,254 @@ async function postPromptObservation(config, request, fetchImplementation) {
         signal: AbortSignal.timeout(config.timeoutMs ?? 2_500),
     });
     if (!response.ok) {
-        throw new Error(`Lore prompt observation failed with HTTP ${response.status}`);
+        throw new RuntimeHttpError(`Lore prompt observation failed with HTTP ${response.status}`, response.status);
+    }
+    const value = await protocolResponseJson(response);
+    if (config.version === 1) {
+        return;
+    }
+    if (!isObject(value) ||
+        !isObject(value.observation) ||
+        !isObject(value.observation.event) ||
+        typeof value.observation.event.id !== "string" ||
+        !committedAcknowledgement(value.capture, request.eventId, value.observation.event.id)) {
+        throw new IncompatibleReliabilityError("Lore observation response has no matching durable acknowledgement");
     }
-    await response.body?.cancel();
 }
-async function getPromptContext(config, agent, sessionId, sourceEventId, prompt, gitContext, fetchImplementation) {
+async function getPromptContext(config, agent, sessionId, sourceEventId, prompt, gitContext, fetchImplementation, store) {
+    const deliveryEventId = deterministicUuid(`lore-context\0${sourceEventId}`);
+    const deliveryRequest = {
+        connector: "lore-cli",
+        eventId: deliveryEventId,
+        sessionId,
+        task: {
+            agent,
+            ...(gitContext.scope === undefined
+                ? {}
+                : { scope: gitContext.scope }),
+            task: redactSecrets(prompt),
+            ...(gitContext.diff === undefined ? {} : { diff: gitContext.diff }),
+            ...(gitContext.files === undefined
+                ? {}
+                : { files: gitContext.files }),
+        },
+    };
     const response = await fetchImplementation(contextDeliveriesUrl(config.apiUrl), {
         method: "POST",
         headers: {
+            accept: runtimeAccept(config),
             authorization: `Bearer ${config.token}`,
             "content-type": "application/json",
             "user-agent": `lore-cli/${RUNTIME_VERSION}`,
         },
-        body: JSON.stringify({
-            connector: "lore-cli",
-            eventId: deterministicUuid(`lore-context\0${sourceEventId}`),
-            sessionId,
-            task: {
-                agent,
-                task: redactSecrets(prompt),
-                ...(gitContext.scope === undefined
-                    ? {}
-                    : { scope: gitContext.scope }),
-                ...(gitContext.diff === undefined ? {} : { diff: gitContext.diff }),
-                ...(gitContext.files === undefined
-                    ? {}
-                    : { files: gitContext.files }),
-            },
-        }),
+        body: JSON.stringify(deliveryRequest),
         signal: AbortSignal.timeout(config.timeoutMs ?? 2_500),
     });
     if (!response.ok) {
-        throw new Error(`Lore context request failed with HTTP ${response.status}`);
+        throw new RuntimeHttpError(`Lore context request failed with HTTP ${response.status}`, response.status);
+    }
+    const value = await protocolResponseJson(response);
+    if (config.version === 1) {
+        return deliveryFromResponse(value);
+    }
+    if (!isObject(value) ||
+        !isObject(value.delivery) ||
+        !isObject(value.reliability) ||
+        typeof value.snapshot !== "string" ||
+        !isObject(value.delivery.event) ||
+        typeof value.delivery.event.id !== "string" ||
+        !isObject(value.delivery.receipt) ||
+        typeof value.delivery.receipt.id !== "string") {
+        throw new IncompatibleReliabilityError("Lore context response has no signed reliability snapshot");
+    }
+    const payload = await verifySnapshot(value.snapshot, "context", config, store, fetchImplementation, true);
+    if (payload.eventId !== value.delivery.event.id ||
+        payload.receiptId !== value.delivery.receipt.id) {
+        throw new IncompatibleReliabilityError("Lore context snapshot does not bind the returned event and receipt");
+    }
+    const reliability = retrievalReliability(value.reliability, payload);
+    if (Date.now() - Date.parse(payload.validUntil) >
+        CONTEXT_CACHE_MAX_STALE_MS) {
+        return {
+            ...emptyDelivery(),
+            reliability: {
+                status: "failed",
+                source: "none",
+                fallback: "none",
+                reasons: ["no_usable_cache"],
+                freshness: {
+                    state: "unknown",
+                    asOf: null,
+                    ageMs: null,
+                    validUntil: null,
+                },
+                policyVersion: null,
+            },
+        };
     }
-    const text = await response.text();
-    if (text.trim() === "") {
-        return emptyDelivery();
+    await store
+        .writeContextSnapshot(sourceEventId, { compactJws: value.snapshot })
+        .catch(() => undefined);
+    return {
+        ...deliveryFromSignedContext(payload, deliveryRequest),
+        reliability,
+    };
+}
+async function cachedSnapshotKeys(config, store, now) {
+    if (config.workspaceId === undefined || store.workspaceId !== config.workspaceId) {
+        return null;
+    }
+    const [keys, refreshState] = await Promise.all([
+        store.readPublicTrustKeys(),
+        store.readState(TRUST_KEY_REFRESH_STATE_KEY),
+    ]);
+    const refreshedAt = isObject(refreshState)
+        ? refreshState.refreshedAt
+        : undefined;
+    const refreshedAtMs = typeof refreshedAt === "string" ? Date.parse(refreshedAt) : Number.NaN;
+    if (keys.length === 0 ||
+        !Number.isFinite(refreshedAtMs) ||
+        now.getTime() - refreshedAtMs >= TRUST_KEY_REFRESH_TTL_MS ||
+        refreshedAtMs > now.getTime() + 5 * 60_000) {
+        return null;
     }
-    return deliveryFromResponse(JSON.parse(text));
+    return { workspaceId: config.workspaceId, keys };
 }
-function queueDirectory(home) {
-    return resolve(loreDirectory(home), "queue");
+async function getCachedPromptContext(config, prompt, gitContext, store, now) {
+    const keys = await cachedSnapshotKeys(config, store, now);
+    if (keys === null || config.workspaceId === undefined) {
+        return null;
+    }
+    const scan = await store.listContextSnapshots();
+    const candidates = [];
+    for (const record of scan.records) {
+        const value = isObject(record.value) ? record.value : null;
+        if (value === null || typeof value.compactJws !== "string") {
+            continue;
+        }
+        try {
+            const payload = verifySignedSnapshot(value.compactJws, {
+                workspaceId: config.workspaceId,
+                kind: "context",
+                keys,
+                allowExpired: true,
+                now,
+            }).payload;
+            candidates.push({
+                cacheKey: record.cacheKey,
+                compactJws: value.compactJws,
+                payload,
+            });
+        }
+        catch {
+            // One invalid cache entry must not hide another verified candidate.
+        }
+    }
+    const task = {
+        workspaceId: config.workspaceId,
+        task: redactSecrets(prompt),
+        ...(gitContext.scope === undefined ? {} : { scope: gitContext.scope }),
+        ...(gitContext.files === undefined ? {} : { files: gitContext.files }),
+    };
+    const selected = selectCachedContext(candidates, task, now);
+    if (selected === null) {
+        return null;
+    }
+    return {
+        context: selected.context,
+        learned: [],
+        delivered: [],
+        reliability: {
+            status: "degraded",
+            source: "cache",
+            fallback: "cached_context",
+            reasons: ["live_unavailable", "cached_context"],
+            freshness: selected.freshness,
+            policyVersion: selected.payload.policyVersion,
+        },
+    };
 }
-async function trimQueue(home) {
-    const directory = queueDirectory(home);
-    let entries;
+async function getPromptContextWithFallback(config, agent, sessionId, sourceEventId, prompt, gitContext, fetchImplementation, store, now) {
     try {
-        entries = (await readdir(directory))
-            .filter((entry) => entry.endsWith(".json"))
-            .sort();
+        return await getPromptContext(config, agent, sessionId, sourceEventId, prompt, gitContext, fetchImplementation, store);
     }
-    catch {
-        return;
+    catch (error) {
+        if (isContextTransportFailure(error)) {
+            const cached = await getCachedPromptContext(config, prompt, gitContext, store, now).catch(() => null);
+            if (cached !== null) {
+                return cached;
+            }
+        }
+        return {
+            ...emptyDelivery(),
+            reliability: {
+                status: "failed",
+                source: "none",
+                fallback: "none",
+                reasons: [
+                    ...(isContextTransportFailure(error) ? ["live_unavailable"] : []),
+                    isContextTransportFailure(error)
+                        ? "no_usable_cache"
+                        : "invalid_response",
+                ],
+                freshness: {
+                    state: "unknown",
+                    asOf: null,
+                    ageMs: null,
+                    validUntil: null,
+                },
+                policyVersion: null,
+            },
+        };
     }
-    const excess = entries.length - MAX_QUEUE_ITEMS + 1;
-    if (excess <= 0) {
-        return;
+}
+function formatAge(ageMs) {
+    if (ageMs === null || ageMs < 60_000) {
+        return "less than a minute";
+    }
+    if (ageMs < 60 * 60_000) {
+        return `${Math.floor(ageMs / 60_000)}m`;
     }
-    await Promise.all(entries
-        .slice(0, excess)
-        .map(async (entry) => rm(resolve(directory, entry), { force: true })));
+    if (ageMs < 24 * 60 * 60_000) {
+        return `${Math.floor(ageMs / (60 * 60_000))}h`;
+    }
+    return `${Math.floor(ageMs / (24 * 60 * 60_000))}d`;
+}
+async function retrievalNotice(delivery, sessionId, store, now) {
+    const reliability = delivery.reliability;
+    if (reliability === undefined || reliability.status === "ok") {
+        return undefined;
+    }
+    if (reliability.fallback === "cached_context") {
+        return `Lore used verified ${reliability.freshness.state} cached context (${formatAge(reliability.freshness.ageMs)} old) because live retrieval was unavailable.`;
+    }
+    const notice = reliability.fallback === "live_lexical"
+        ? "Lore used live lexical retrieval because semantic retrieval was unavailable."
+        : reliability.reasons.includes("invalid_response")
+            ? "Lore context could not be trusted; continuing without injected context."
+            : "Lore context is temporarily unavailable; continuing without injected context.";
+    const key = `context-notice:${sessionId}`;
+    const previous = await store.readState(key).catch(() => null);
+    if (isObject(previous) &&
+        previous.notice === notice &&
+        typeof previous.at === "string" &&
+        now.getTime() - Date.parse(previous.at) < CONTEXT_NOTICE_COOLDOWN_MS) {
+        return undefined;
+    }
+    await store
+        .writeState(key, { notice, at: now.toISOString() }, now)
+        .catch(() => undefined);
+    return notice;
+}
+function queueDirectory(home) {
+    return resolve(loreDirectory(home), "queue");
 }
-async function enqueue(request, home) {
-    await trimQueue(home);
-    const path = resolve(queueDirectory(home), `${request.request.idempotencyKey}.json`);
-    await atomicWriteJson(path, request);
+async function enqueueCapture(store, queued) {
+    return (await store.enqueue({
+        kind: queued.kind,
+        idempotencyKey: queued.request.eventId,
+        payload: queued,
+    })).entry;
 }
 function isTurnRequest(value) {
     return (isObject(value) &&
@@ -799,38 +1422,57 @@ function queuedRequest(value) {
     }
     return null;
 }
-async function retryOne(config, fetchImplementation, home) {
-    const directory = queueDirectory(home);
-    let first;
-    try {
-        first = (await readdir(directory))
-            .filter((entry) => entry.endsWith(".json"))
-            .sort()[0];
-    }
-    catch {
-        return;
-    }
-    if (first === undefined) {
-        return;
+async function flushOne(config, fetchImplementation, store) {
+    const claimed = await store.claimNext({
+        workerId: `native-hook:${process.pid}`,
+        kinds: ["turn", "prompt"],
+    });
+    if (claimed === null || claimed.claim === undefined) {
+        return null;
     }
-    const path = resolve(directory, first);
     try {
-        const parsed = JSON.parse(await readFile(path, "utf8"));
-        const queued = queuedRequest(parsed);
+        const queued = queuedRequest(claimed.payload);
         if (queued === null) {
-            await rm(path, { force: true });
-            return;
+            const failed = await store.failClaim({
+                claimId: claimed.claim.id,
+                classification: "incompatible",
+                message: "Durable capture payload is incompatible",
+            });
+            return {
+                idempotencyKey: claimed.idempotencyKey,
+                state: failed.state === "auth-blocked" ? "auth-blocked" : "dead",
+            };
         }
+        let delivery;
         if (queued.kind === "turn") {
-            await postTurn(config, queued.request, fetchImplementation);
+            delivery = await postTurn(config, queued.request, fetchImplementation, store);
         }
         else {
-            await postPromptObservation(config, queued.request, fetchImplementation);
+            await postPromptObservation(config, queued.request, fetchImplementation, store);
         }
-        await rm(path, { force: true });
+        await store.acknowledgeClaim(claimed.claim.id);
+        return {
+            idempotencyKey: claimed.idempotencyKey,
+            state: "acknowledged",
+            ...(delivery === undefined ? {} : { delivery }),
+        };
     }
-    catch {
-        // Retry on a later prompt. Hook failures are deliberately invisible.
+    catch (error) {
+        const failed = await store.failClaim({
+            claimId: claimed.claim.id,
+            classification: error instanceof SignedSnapshotError
+                ? "incompatible"
+                : classifyRetryFailure(error),
+            message: error instanceof Error ? error.message : "Lore upload failed",
+        });
+        return {
+            idempotencyKey: claimed.idempotencyKey,
+            state: failed.state === "auth-blocked"
+                ? "auth-blocked"
+                : failed.state === "dead"
+                    ? "dead"
+                    : "ready",
+        };
     }
 }
 function receiptMessage(config, agent, delivery) {
@@ -979,6 +1621,7 @@ function guardResultFromResponse(value) {
             }
             const scope = isObject(item.scope) ? item.scope : {};
             const source = isObject(item.source) ? item.source : {};
+            const explanation = guardExplanationFromValue(item.explanation);
             return [
                 {
                     content: redactSecrets(item.content),
@@ -992,6 +1635,7 @@ function guardResultFromResponse(value) {
                     ...(typeof source.agent === "string"
                         ? { sourceAgent: source.agent }
                         : {}),
+                    ...(explanation === undefined ? {} : { explanation }),
                 },
             ];
         })
@@ -1013,6 +1657,33 @@ function guardResultFromResponse(value) {
         conflictSummaries,
     };
 }
+function guardExplanationFromValue(value) {
+    if (!isObject(value) ||
+        typeof value.summary !== "string" ||
+        !isObject(value.provenance) ||
+        typeof value.provenance.agent !== "string" ||
+        typeof value.status !== "string" ||
+        !isObject(value.freshness) ||
+        typeof value.freshness.updatedAt !== "string") {
+        return undefined;
+    }
+    const scope = isObject(value.scope) ? value.scope : {};
+    const scopeParts = [
+        typeof scope.organization === "string"
+            ? `org ${scope.organization}`
+            : undefined,
+        typeof scope.project === "string" ? `project ${scope.project}` : undefined,
+        typeof scope.repo === "string" ? `repo ${scope.repo}` : undefined,
+        typeof scope.path === "string" ? `path ${scope.path}` : undefined,
+        typeof scope.component === "string"
+            ? `component ${scope.component}`
+            : undefined,
+    ].filter((part) => part !== undefined);
+    const session = typeof value.provenance.sessionId === "string"
+        ? ` session ${value.provenance.sessionId}`
+        : "";
+    return `Why: ${redactSecrets(value.summary)} Source: ${value.provenance.agent}${session}. Scope: ${scopeParts.join(" · ") || "workspace-wide"}. Status: ${value.status}. Updated: ${value.freshness.updatedAt.slice(0, 10)}.`;
+}
 function guardItemSource(item) {
     const scope = item.repo !== undefined
         ? `${item.repo} repo`
@@ -1027,10 +1698,7 @@ function guardAssistContext(result) {
     const lines = ["Relevant Lore context:"];
     for (const item of result.items) {
         lines.push(`- ${item.content}`);
-    }
-    lines.push("", "Sources:");
-    for (const item of result.items) {
-        lines.push(`- ${guardItemSource(item)}`);
+        lines.push(`  ${item.explanation ?? `Source: ${guardItemSource(item)}.`}`);
     }
     if (result.conflictSummaries.length > 0) {
         lines.push("", "Conflicting Lore context (do not silently pick a winner):");
@@ -1045,17 +1713,21 @@ function guardConfirmationReason(result) {
     const shown = required.length > 0 ? required : result.items;
     const lines = [
         "Lore Guard: this action conflicts with a required rule.",
-        ...shown.map((item) => `- ${item.content} (${guardItemSource(item)})`),
+        ...shown.flatMap((item) => [
+            `- ${item.content}`,
+            `  ${item.explanation ?? `Source: ${guardItemSource(item)}.`}`,
+        ]),
     ];
     lines.push(result.confirmCommand === undefined
         ? "Ask the user to confirm before proceeding."
         : `Approve here to proceed, or the user can run: ${result.confirmCommand}`);
     return boundedContext(lines.join("\n"));
 }
-async function postGuardCheck(config, request, fetchImplementation) {
+async function postGuardCheck(config, request, fetchImplementation, store) {
     const response = await fetchImplementation(guardCheckUrl(config.apiUrl), {
         method: "POST",
         headers: {
+            accept: runtimeAccept(config),
             authorization: `Bearer ${config.token}`,
             "content-type": "application/json",
             "user-agent": `lore-cli/${RUNTIME_VERSION}`,
@@ -1064,9 +1736,26 @@ async function postGuardCheck(config, request, fetchImplementation) {
         signal: AbortSignal.timeout(Math.min(config.timeoutMs ?? GUARD_TIMEOUT_MS, GUARD_TIMEOUT_MS)),
     });
     if (!response.ok) {
-        throw new Error(`Lore guard check failed with HTTP ${response.status}`);
-    }
-    return guardResultFromResponse(JSON.parse(await response.text()));
+        throw new RuntimeHttpError(`Lore guard check failed with HTTP ${response.status}`, response.status);
+    }
+    const value = await protocolResponseJson(response);
+    if (config.version === 1) {
+        return guardResultFromResponse(value);
+    }
+    if (!isObject(value) ||
+        !isObject(value.check) ||
+        typeof value.policyVersion !== "string" ||
+        typeof value.policySnapshot !== "string") {
+        throw new IncompatibleReliabilityError("Lore Guard response has no signed policy snapshot");
+    }
+    const payload = await verifySnapshot(value.policySnapshot, "guard_policy", config, store, fetchImplementation);
+    if (payload.policyVersion !== value.policyVersion ||
+        (config.workspaceId !== undefined &&
+            payload.workspaceId !== config.workspaceId)) {
+        throw new IncompatibleReliabilityError("Lore Guard snapshot does not bind the returned policy");
+    }
+    await store.writePolicySnapshot("current", value.policySnapshot);
+    return guardResultFromResponse(value.check);
 }
 async function handleGuardEvent(input, agent, config, sessionId, options, now) {
     if (agent === "polytoken") {
@@ -1081,10 +1770,12 @@ async function handleGuardEvent(input, agent, config, sessionId, options, now) {
     if (trigger === null) {
         return undefined;
     }
+    const store = await runtimeStore(config, options.home);
     const state = await readGuardState(agent, sessionId, options.home);
     if (state.mode === "off" &&
         state.modeCheckedAt !== undefined &&
         now.getTime() - Date.parse(state.modeCheckedAt) < GUARD_MODE_TTL_MS) {
+        await recordLocalGuardMetric(store, { outcome: "reused_decision" }, now).catch(() => undefined);
         return undefined;
     }
     const cwd = stringField(input.cwd);
@@ -1112,24 +1803,38 @@ async function handleGuardEvent(input, agent, config, sessionId, options, now) {
     const cachedAt = state.keys[key];
     if (cachedAt !== undefined &&
         now.getTime() - Date.parse(cachedAt) < GUARD_KEY_COOLDOWN_MS) {
+        await recordLocalGuardMetric(store, { outcome: "reused_decision" }, now).catch(() => undefined);
         return undefined;
     }
-    const result = await postGuardCheck(config, {
-        connector: "lore-cli",
-        agent,
-        sessionId,
-        action: trigger.action,
-        tool: toolName,
-        ...(scope?.repo === undefined ? {} : { repo: scope.repo }),
-        ...(scope?.path === undefined ? {} : { path: scope.path }),
-        ...(files.length === 0 ? {} : { files }),
-        ...(trigger.command === undefined
-            ? {}
-            : { command: redactSecrets(trigger.command).slice(0, 10_000) }),
-    }, options.fetch ?? globalThis.fetch);
+    const startedAt = Date.now();
+    let result;
+    try {
+        result = await postGuardCheck(config, {
+            connector: "lore-cli",
+            agent,
+            sessionId,
+            action: trigger.action,
+            tool: toolName,
+            ...(scope?.repo === undefined ? {} : { repo: scope.repo }),
+            ...(scope?.path === undefined ? {} : { path: scope.path }),
+            ...(files.length === 0 ? {} : { files }),
+            ...(trigger.command === undefined
+                ? {}
+                : { command: redactSecrets(trigger.command).slice(0, 10_000) }),
+        }, options.fetch ?? globalThis.fetch, store);
+    }
+    catch (error) {
+        await recordLocalGuardMetric(store, { outcome: "failed" }, now).catch(() => undefined);
+        throw error;
+    }
     if (result === null) {
-        return undefined;
+        await recordLocalGuardMetric(store, { outcome: "failed" }, now).catch(() => undefined);
+        throw new IncompatibleReliabilityError("Lore Guard response is invalid");
     }
+    await recordLocalGuardMetric(store, {
+        outcome: "live_check",
+        durationMs: Math.max(0, Date.now() - startedAt),
+    }, now).catch(() => undefined);
     state.mode = result.mode;
     state.modeCheckedAt = now.toISOString();
     if (!result.requiresConfirmation) {
@@ -1174,14 +1879,16 @@ async function handleGuardEvent(input, agent, config, sessionId, options, now) {
 }
 export async function handleHookEvent(value, agent, options = {}) {
     if (!isObject(value)) {
-        return undefined;
+        throw new InvalidHookInputError();
     }
     const normalized = normalizeHookInput(value, agent, options.environment ?? process.env);
     const input = normalized.input;
     const eventName = normalized.eventName;
     const sessionId = normalized.sessionId;
-    if (eventName === undefined || sessionId === undefined) {
-        return undefined;
+    if (eventName === undefined ||
+        sessionId === undefined ||
+        !validHookInput(input, agent, eventName)) {
+        throw new InvalidHookInputError();
     }
     const config = await readRuntimeConfig(options.home);
     if (config === null || !config.agents.includes(agent)) {
@@ -1203,20 +1910,65 @@ export async function handleHookEvent(value, agent, options = {}) {
             return await handleGuardEvent(input, agent, config, sessionId, options, now);
         }
         catch {
-            // Guard checks fail open: never stall or break a tool call.
-            return undefined;
+            const warning = "Lore Guard is unavailable; this action is proceeding without a live policy decision.";
+            if (agent === "cursor") {
+                return {
+                    userMessage: warning,
+                    agentMessage: warning,
+                };
+            }
+            return {
+                hookSpecificOutput: {
+                    hookEventName: "PreToolUse",
+                    additionalContext: warning,
+                },
+            };
         }
     }
-    if (eventName !== "UserPromptSubmit") {
-        return undefined;
-    }
     const fetchImplementation = options.fetch ?? globalThis.fetch;
-    await retryOne(config, fetchImplementation, options.home);
-    const pending = await consumePending(agent, sessionId, options.home);
     const prompt = stringField(input.prompt);
     if (prompt === undefined) {
-        return undefined;
+        throw new InvalidHookInputError();
+    }
+    const notices = [];
+    let store;
+    try {
+        store = await runtimeStore(config, options.home);
+    }
+    catch (error) {
+        const detail = error instanceof ReliabilityStoreError &&
+            error.code === "CAPACITY_EXCEEDED"
+            ? "the local outbox is full"
+            : "local durable storage is unavailable";
+        notices.push(`Lore could not acknowledge this capture because ${detail}. Run lore doctor.`);
+        const notice = notices.join(" ");
+        return agent === "polytoken"
+            ? { outcome: "accept", additional_context: notice }
+            : agent === "cursor"
+                ? {
+                    continue: true,
+                    hookSpecificOutput: {
+                        hookEventName: "UserPromptSubmit",
+                        additionalContext: notice,
+                    },
+                }
+                : { systemMessage: notice };
     }
+    const noticeForFlush = (result) => {
+        if (result?.state === "auth-blocked") {
+            notices.push("Lore retained a capture locally, but upload is blocked by authentication. Run lore connect again.");
+        }
+        else if (result?.state === "dead") {
+            notices.push("Lore retained a capture as a dead letter because the server response was incompatible. Run lore doctor.");
+        }
+    };
+    try {
+        noticeForFlush(await flushOne(config, fetchImplementation, store));
+    }
+    catch {
+        notices.push("Lore retained queued captures locally, but replay could not run. Run lore doctor.");
+    }
+    const pending = await readPending(agent, sessionId, options.home);
     const lineage = await readLineageMetadata(options.home, options.environment ?? process.env);
     let delivery = emptyDelivery();
     if (pending !== null) {
@@ -1224,26 +1976,61 @@ export async function handleHookEvent(value, agent, options = {}) {
         if (request === null) {
             return undefined;
         }
+        let enqueued = false;
         try {
-            delivery = await postTurn(config, request, fetchImplementation);
+            await enqueueCapture(store, { kind: "turn", request });
+            enqueued = true;
+            await clearPending(agent, sessionId, options.home);
         }
-        catch {
+        catch (error) {
+            notices.push(error instanceof ReliabilityStoreError &&
+                error.code === "CAPACITY_EXCEEDED"
+                ? "Lore could not acknowledge this capture because the local outbox is full. Run lore status."
+                : "Lore could not acknowledge this capture because local persistence failed. Run lore doctor.");
+        }
+        if (enqueued) {
             try {
-                await enqueue({ kind: "turn", request }, options.home);
+                const flushed = await flushOne(config, fetchImplementation, store);
+                noticeForFlush(flushed);
+                if (flushed?.idempotencyKey === request.eventId &&
+                    flushed.state === "acknowledged" &&
+                    flushed.delivery !== undefined) {
+                    delivery = flushed.delivery;
+                }
+                else {
+                    notices.push("Lore saved this capture locally; server upload is pending.");
+                }
             }
             catch {
-                // The connector must fail open even when its local queue is unavailable.
+                notices.push("Lore saved this capture locally; server upload is pending.");
             }
+        }
+        if (delivery.context === "") {
             try {
-                delivery = await getPromptContext(config, agent, sessionId, request.eventId, prompt, {
+                delivery = await getPromptContextWithFallback(config, agent, sessionId, request.eventId, prompt, {
                     ...(request.scope === undefined ? {} : { scope: request.scope }),
                     learningScope: request.learningScope,
                     ...(request.diff === undefined ? {} : { diff: request.diff }),
                     ...(request.files === undefined ? {} : { files: request.files }),
-                }, fetchImplementation);
+                }, fetchImplementation, store, now);
             }
             catch {
-                return undefined;
+                delivery = {
+                    ...emptyDelivery(),
+                    reliability: {
+                        status: "failed",
+                        source: "none",
+                        fallback: "none",
+                        reasons: ["invalid_response"],
+                        freshness: {
+                            state: "unknown",
+                            asOf: null,
+                            ageMs: null,
+                            validUntil: null,
+                        },
+                        policyVersion: null,
+                    },
+                };
             }
         }
     }
@@ -1253,45 +2040,99 @@ export async function handleHookEvent(value, agent, options = {}) {
         if (observation === null) {
             return undefined;
         }
+        let enqueued = false;
         try {
-            await postPromptObservation(config, observation, fetchImplementation);
+            await enqueueCapture(store, { kind: "prompt", request: observation });
+            enqueued = true;
         }
-        catch {
+        catch (error) {
+            notices.push(error instanceof ReliabilityStoreError &&
+                error.code === "CAPACITY_EXCEEDED"
+                ? "Lore could not acknowledge this capture because the local outbox is full. Run lore status."
+                : "Lore could not acknowledge this capture because local persistence failed. Run lore doctor.");
+        }
+        if (enqueued) {
             try {
-                await enqueue({ kind: "prompt", request: observation }, options.home);
+                const flushed = await flushOne(config, fetchImplementation, store);
+                noticeForFlush(flushed);
+                if (flushed?.idempotencyKey !== observation.eventId ||
+                    flushed.state !== "acknowledged") {
+                    notices.push("Lore saved this capture locally; server upload is pending.");
+                }
             }
             catch {
-                // The connector must fail open even when its local queue is unavailable.
+                notices.push("Lore saved this capture locally; server upload is pending.");
             }
         }
         try {
-            delivery = await getPromptContext(config, agent, sessionId, observation.eventId, prompt, gitContext, fetchImplementation);
+            delivery = await getPromptContextWithFallback(config, agent, sessionId, observation.eventId, prompt, gitContext, fetchImplementation, store, now);
         }
         catch {
-            return undefined;
+            delivery = {
+                ...emptyDelivery(),
+                reliability: {
+                    status: "failed",
+                    source: "none",
+                    fallback: "none",
+                    reasons: ["invalid_response"],
+                    freshness: {
+                        state: "unknown",
+                        asOf: null,
+                        ageMs: null,
+                        validUntil: null,
+                    },
+                    policyVersion: null,
+                },
+            };
         }
     }
+    const reliability = delivery.reliability;
+    await recordLocalRetrievalMetric(store, {
+        outcome: reliability?.fallback === "cached_context"
+            ? "cached_fallback"
+            : reliability?.fallback === "live_lexical"
+                ? "live_lexical_fallback"
+                : reliability?.status === "failed" ||
+                    reliability?.source === "none"
+                    ? "failed"
+                    : "live_primary",
+        ...(reliability?.freshness.ageMs === undefined
+            ? {}
+            : { cacheAgeMs: reliability.freshness.ageMs }),
+    }, now).catch(() => undefined);
+    const contextReliabilityNotice = await retrievalNotice(delivery, sessionId, store, now);
+    if (contextReliabilityNotice !== undefined) {
+        notices.push(contextReliabilityNotice);
+    }
+    const uniqueNotices = [...new Set(notices)];
+    const reliabilityNotice = uniqueNotices.length === 0 ? undefined : uniqueNotices.join(" ");
+    const receipt = receiptMessage(config, agent, delivery);
     const systemMessage = agent === "cursor" || agent === "polytoken"
         ? undefined
-        : receiptMessage(config, agent, delivery);
-    if (delivery.context === "" && systemMessage === undefined) {
+        : [receipt, reliabilityNotice].filter(Boolean).join(" · ") || undefined;
+    const injectedContext = agent === "cursor" || agent === "polytoken"
+        ? [delivery.context, reliabilityNotice]
+            .filter((entry) => entry !== undefined && entry !== "")
+            .join("\n\n")
+        : delivery.context;
+    if (injectedContext === "" && systemMessage === undefined) {
         return undefined;
     }
     if (agent === "polytoken") {
         return {
             outcome: "accept",
-            additional_context: delivery.context,
+            additional_context: injectedContext,
         };
     }
     return {
         ...(agent === "cursor" ? { continue: true } : {}),
         ...(systemMessage === undefined ? {} : { systemMessage }),
-        ...(delivery.context === ""
+        ...(injectedContext === ""
             ? {}
             : {
                 hookSpecificOutput: {
                     hookEventName: "UserPromptSubmit",
-                    additionalContext: delivery.context,
+                    additionalContext: injectedContext,
                 },
             }),
     };
@@ -1312,25 +2153,73 @@ function parseAgent(args) {
     const value = index < 0 ? undefined : args[index + 1];
     return isCommandHookAgent(value) ? value : null;
 }
+function nativeIntegrationId(agent) {
+    return `native/${agent}`;
+}
+async function beginHookInvocation(agent) {
+    const config = await readRuntimeConfig();
+    if (config === null || !config.agents.includes(agent)) {
+        return null;
+    }
+    const workspaceKey = reliabilityWorkspaceKey(config);
+    const home = homeDirectory();
+    const attempt = createIntegrationInvocationAttempt(nativeIntegrationId(agent), { runtimeVersion: RUNTIME_VERSION });
+    const recorded = await writeInvocationAttemptBounded(workspaceKey, attempt, { home, standalone: IS_STANDALONE_RUNTIME });
+    return recorded ? { workspaceKey, home, attempt } : null;
+}
+async function finishHookInvocation(tracker, outcome) {
+    if (tracker === null) {
+        return;
+    }
+    await writeInvocationCompletionBounded(tracker.workspaceKey, tracker.attempt, outcome, { home: tracker.home, standalone: IS_STANDALONE_RUNTIME }).catch(() => false);
+}
 export async function runHook(args = process.argv.slice(2)) {
     const agent = parseAgent(args);
     if (agent === null) {
         return;
     }
+    const tracker = await beginHookInvocation(agent).catch(() => null);
+    let input;
+    try {
+        input = await readStdin();
+    }
+    catch {
+        await finishHookInvocation(tracker, {
+            success: false,
+            failureCode: "invalid_input",
+        });
+        return;
+    }
     try {
-        const result = await handleHookEvent(await readStdin(), agent);
+        const result = await handleHookEvent(input, agent);
         if (result !== undefined) {
             process.stdout.write(`${JSON.stringify(result)}\n`);
         }
-    }
-    catch {
+        await finishHookInvocation(tracker, { success: true });
+    }
+    catch (error) {
+        await finishHookInvocation(tracker, {
+            success: false,
+            failureCode: error instanceof InvalidHookInputError
+                ? "invalid_input"
+                : "runtime_error",
+        });
         // Native hooks must never block or add error noise to an agent session.
     }
 }
 const entryPath = process.argv[1];
+const isRuntimeEntrypoint = entryPath !== undefined &&
+    (() => {
+        try {
+            return (realpathSync(resolve(entryPath)) ===
+                realpathSync(fileURLToPath(import.meta.url)));
+        }
+        catch {
+            return import.meta.url === pathToFileURL(resolve(entryPath)).href;
+        }
+    })();
 if (!IS_STANDALONE_RUNTIME &&
-    entryPath !== undefined &&
-    import.meta.url === pathToFileURL(resolve(entryPath)).href) {
+    isRuntimeEntrypoint) {
     void runHook();
 }
 //# sourceMappingURL=runtime.js.map