@lore-co/opencode 0.1.17 → 0.1.18

package/dist/index.js

@@ -1,11 +1,19 @@
 import { createHash } from "node:crypto";
+import { homedir } from "node:os";
 import { isAbsolute, relative } from "node:path";
-import { GenericAgentAdapter, injectSharedMemory, } from "@lore-co/adapter-generic";
-import { redactSensitiveText, stripLoreInjectedContext, } from "@lore-co/core";
+import { GenericAgentAdapter, normalizeHostScope, toHostTask, injectSharedMemory, } from "@lore-co/adapter-generic";
+import { canonicalJson, formatExplanation, redactUnknown, redactSensitiveText, stripLoreInjectedContext, } from "@lore-co/core";
+import { ReliabilityStore, classifyRetryFailure, createIntegrationInvocationAttempt, recordLocalGuardMetric, recordLocalRetrievalMetric, } from "@lore-co/cli/reliability-store";
+import { writeInvocationAttemptBounded, writeInvocationCompletionBounded, } from "@lore-co/cli/invocation-health-writer";
+import { SignedSnapshotError, verifySignedSnapshot, } from "@lore-co/cli/signed-snapshot";
+import { CONTEXT_CACHE_MAX_STALE_MS, isContextTransportFailure, selectCachedContext, } from "@lore-co/cli/context-fallback";
 import { boundedTimeout, createBoundedFetch, resolveLoreCredentials, withTimeout, } from "./config.js";
 import { canonicalRepositoryScope, repositoryScopeFromWorktree, } from "./repository.js";
+import { OPENCODE_PLUGIN_VERSION } from "./version.js";
 export { DEFAULT_TIMEOUT_MS, MAX_CONFIG_BYTES, MAX_RESPONSE_BYTES, MAX_TIMEOUT_MS, MIN_TIMEOUT_MS, boundedTimeout, createBoundedFetch, resolveLoreCredentials, } from "./config.js";
 export { canonicalRepositoryScope, repositoryScopeFromWorktree, } from "./repository.js";
+export { OPENCODE_PLUGIN_VERSION } from "./version.js";
+export { OPENCODE_RELIABILITY_INTEGRATION, } from "@lore-co/core";
 export const MAX_CONTEXT_BYTES = 12_000;
 export const MAX_MESSAGE_BYTES = 100_000;
 export const MAX_SESSIONS = 256;
@@ -16,6 +24,9 @@ const MAX_METADATA_BYTES = 500;
 const MAX_PARTS_PER_MESSAGE = 200;
 const MAX_MESSAGE_SCAN = 20;
 const CONNECTOR = "lore-opencode-plugin";
+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;
 function utf8Length(value) {
     return Buffer.byteLength(value, "utf8");
 }
@@ -101,6 +112,83 @@ function contextText(value) {
     }
     return truncateUtf8(redactSensitiveText(value).text.trim(), MAX_CONTEXT_BYTES);
 }
+function objectValue(value) {
+    return typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value)
+        ? value
+        : null;
+}
+function contextRetrievalMetadata(value, payload) {
+    const metadata = objectValue(value);
+    const freshness = objectValue(metadata?.freshness);
+    const policy = objectValue(metadata?.policy);
+    const reasons = Array.isArray(metadata?.reasons)
+        ? metadata.reasons.filter((reason) => typeof reason === "string")
+        : [];
+    const source = metadata?.source;
+    const fallback = metadata?.fallback;
+    const live = source === "live" &&
+        freshness?.state === "fresh" &&
+        policy?.source === "live" &&
+        policy.loadedAt === payload.issuedAt &&
+        Date.now() < Date.parse(payload.validUntil);
+    const cached = source === "cache" &&
+        fallback === "cached_context" &&
+        metadata?.status === "degraded" &&
+        (freshness?.state === "fresh" || freshness?.state === "stale") &&
+        policy?.source === "cache" &&
+        policy.loadedAt === payload.asOf &&
+        reasons.includes("cached_context");
+    if (metadata?.contractVersion !== "reliability-v1" ||
+        metadata.operation !== "retrieval" ||
+        metadata.requestId !== payload.requestId ||
+        freshness?.asOf !== payload.asOf ||
+        freshness.validUntil !== payload.validUntil ||
+        policy?.version !== payload.policyVersion ||
+        policy.validUntil !== payload.validUntil ||
+        (!live && !cached)) {
+        return { valid: false };
+    }
+    if (cached) {
+        const ageMs = Math.max(0, Date.now() - Date.parse(payload.asOf));
+        const state = Date.now() < Date.parse(payload.validUntil) ? "fresh" : "stale";
+        return {
+            valid: true,
+            notice: `Lore used verified ${state} cached context (${ageLabel(ageMs)} old) because fresh context was unavailable.`,
+            metricOutcome: "cached_fallback",
+            cacheAgeMs: ageMs,
+        };
+    }
+    if (fallback === "live_lexical" &&
+        metadata?.status === "degraded" &&
+        reasons.includes("lexical_fallback")) {
+        return {
+            valid: true,
+            notice: "Lore used live lexical retrieval because semantic retrieval was unavailable.",
+            metricOutcome: "live_lexical_fallback",
+        };
+    }
+    const valid = fallback === "none" &&
+        metadata?.status === "ok" &&
+        reasons.length > 0;
+    return {
+        valid,
+        ...(valid ? { metricOutcome: "live_primary" } : {}),
+    };
+}
+function ageLabel(ageMs) {
+    if (ageMs < 60_000) {
+        return "less than a minute";
+    }
+    if (ageMs < 60 * 60_000) {
+        return `${Math.floor(ageMs / 60_000)}m`;
+    }
+    if (ageMs < 24 * 60 * 60_000) {
+        return `${Math.floor(ageMs / (60 * 60_000))}h`;
+    }
+    return `${Math.floor(ageMs / (24 * 60 * 60_000))}d`;
+}
 function scopeFromContext(context, repositoryScope) {
     const repo = boundedScopeValue(repositoryScope, MAX_SCOPE_BYTES);
     const relativePath = relative(context.worktree, context.directory);
@@ -179,7 +267,12 @@ export function formatGuardBlockMessage(verdict) {
     const shown = required.length > 0 ? required : verdict.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 === undefined
+                ? `Source: ${guardItemSource(item)}.`
+                : formatExplanation(item.explanation)}`,
+        ]),
         verdict.confirm === undefined
             ? "Ask the user to confirm before retrying."
             : `Ask the user to confirm; they can approve with: ${verdict.confirm.command}`,
@@ -193,10 +286,9 @@ export function formatGuardAssistContext(verdict) {
     const lines = ["Relevant Lore context:"];
     for (const item of verdict.items) {
         lines.push(`- ${item.content}`);
-    }
-    lines.push("", "Sources:");
-    for (const item of verdict.items) {
-        lines.push(`- ${guardItemSource(item)}`);
+        lines.push(`  ${item.explanation === undefined
+            ? `Source: ${guardItemSource(item)}.`
+            : formatExplanation(item.explanation)}`);
     }
     if (verdict.conflicts.length > 0) {
         lines.push("", "Conflicting Lore context (do not silently pick a winner):");
@@ -227,14 +319,18 @@ function pluginTimeout(options, env) {
 class LoreOpenCodeRuntime {
     #context;
     #adapter;
+    #store;
+    #workspaceId;
     #repositoryScope;
     #timeoutMs;
     #sessions = new Map();
-    constructor(context, adapter, timeoutMs, repositoryScope) {
+    constructor(context, adapter, timeoutMs, repositoryScope, store, workspaceId) {
         this.#context = context;
         this.#adapter = adapter;
         this.#timeoutMs = timeoutMs;
         this.#repositoryScope = repositoryScope;
+        this.#store = store;
+        this.#workspaceId = workspaceId;
     }
     hooks() {
         return {
@@ -260,7 +356,11 @@ class LoreOpenCodeRuntime {
                     blockMessage = await this.#guardBeforeTool(input, output);
                 }
                 catch {
-                    // Guard checks fail open; only a deliberate verdict may block.
+                    const state = this.#session(input.sessionID);
+                    if (state !== undefined) {
+                        state.guardContext =
+                            "Lore Guard is unavailable; this action is proceeding without a live policy decision.";
+                    }
                     return;
                 }
                 if (blockMessage !== undefined) {
@@ -276,6 +376,7 @@ class LoreOpenCodeRuntime {
                     }
                     else if (event.type === "session.deleted") {
                         this.#deleteSession(event.properties.info.id);
+                        await this.#clearPendingAssistant(event.properties.info.id);
                     }
                 }
                 catch {
@@ -326,6 +427,447 @@ class LoreOpenCodeRuntime {
             return undefined;
         }
     }
+    #contextNotice(state, notice) {
+        if (notice === undefined) {
+            return "";
+        }
+        if (notice.includes("cached context")) {
+            return notice;
+        }
+        const now = Date.now();
+        if (state.contextNotice?.text === notice &&
+            now - state.contextNotice.at < CONTEXT_NOTICE_COOLDOWN_MS) {
+            return "";
+        }
+        state.contextNotice = { text: notice, at: now };
+        return notice;
+    }
+    #pendingStateKey(sessionId) {
+        return `opencode:pending:${sessionId}`;
+    }
+    async #loadPendingAssistant(sessionId) {
+        const stored = await this.#store?.readState(this.#pendingStateKey(sessionId));
+        const value = objectValue(stored);
+        if (value === null ||
+            typeof value.id !== "string" ||
+            typeof value.content !== "string" ||
+            typeof value.timestamp !== "string" ||
+            typeof value.completedAt !== "number" ||
+            typeof value.fingerprint !== "string") {
+            return undefined;
+        }
+        return {
+            id: value.id,
+            content: value.content,
+            timestamp: value.timestamp,
+            completedAt: value.completedAt,
+            fingerprint: value.fingerprint,
+        };
+    }
+    async #savePendingAssistant(sessionId, pending) {
+        await this.#store?.writeState(this.#pendingStateKey(sessionId), pending);
+    }
+    async #clearPendingAssistant(sessionId) {
+        await this.#store?.deleteState(this.#pendingStateKey(sessionId));
+    }
+    async #snapshotKeys(refresh = false) {
+        const store = this.#store;
+        const workspaceId = this.#workspaceId;
+        const adapter = this.#adapter;
+        if (store === undefined || workspaceId === undefined) {
+            throw new Error("Lore connector has no workspace identity; reconnect Lore");
+        }
+        if (!refresh) {
+            const cached = await store.readPublicTrustKeys();
+            const refreshState = objectValue(await store.readState(TRUST_KEY_REFRESH_STATE_KEY));
+            const refreshedAt = typeof refreshState?.refreshedAt === "string"
+                ? Date.parse(refreshState.refreshedAt)
+                : Number.NaN;
+            if (cached.length > 0 &&
+                Number.isFinite(refreshedAt) &&
+                Date.now() - refreshedAt < TRUST_KEY_REFRESH_TTL_MS &&
+                refreshedAt <= Date.now() + 5 * 60_000) {
+                return { workspaceId, keys: cached };
+            }
+        }
+        if (adapter?.getSnapshotPublicKeys === undefined) {
+            throw new Error("Lore adapter does not support snapshot keys");
+        }
+        const keySet = await adapter.getSnapshotPublicKeys();
+        if (keySet.workspaceId !== workspaceId) {
+            throw new Error("Lore snapshot keys belong to a different workspace");
+        }
+        const keys = keySet.keys.map((key) => ({
+            ...key,
+            workspaceId,
+        }));
+        await store.writePublicTrustKeys(keys);
+        await store.writeState(TRUST_KEY_REFRESH_STATE_KEY, {
+            refreshedAt: new Date().toISOString(),
+        });
+        return { workspaceId, keys };
+    }
+    async #cachedSnapshotKeys() {
+        const store = this.#store;
+        const workspaceId = this.#workspaceId;
+        if (store === undefined || workspaceId === undefined) {
+            return null;
+        }
+        const [keys, refreshState] = await Promise.all([
+            store.readPublicTrustKeys(),
+            store.readState(TRUST_KEY_REFRESH_STATE_KEY),
+        ]);
+        const refreshedAt = typeof objectValue(refreshState)?.refreshedAt === "string"
+            ? Date.parse(String(objectValue(refreshState)?.refreshedAt))
+            : Number.NaN;
+        if (keys.length === 0 ||
+            !Number.isFinite(refreshedAt) ||
+            Date.now() - refreshedAt >= TRUST_KEY_REFRESH_TTL_MS ||
+            refreshedAt > Date.now() + 5 * 60_000) {
+            return null;
+        }
+        return { workspaceId, keys };
+    }
+    async #cachedContext(delivery) {
+        const store = this.#store;
+        const workspaceId = this.#workspaceId;
+        const keys = await this.#cachedSnapshotKeys();
+        if (store === undefined || workspaceId === undefined || keys === null) {
+            return null;
+        }
+        const candidates = [];
+        for (const record of (await store.listContextSnapshots()).records) {
+            const value = objectValue(record.value);
+            if (value === null || typeof value.compactJws !== "string") {
+                continue;
+            }
+            try {
+                candidates.push({
+                    cacheKey: record.cacheKey,
+                    compactJws: value.compactJws,
+                    payload: verifySignedSnapshot(value.compactJws, {
+                        workspaceId,
+                        kind: "context",
+                        keys,
+                        allowExpired: true,
+                    }).payload,
+                });
+            }
+            catch {
+                // One invalid cache entry must not hide another verified candidate.
+            }
+        }
+        const task = redactUnknown(toHostTask(delivery, "opencode")).value;
+        const taskValue = objectValue(task);
+        if (taskValue === null ||
+            typeof taskValue.task !== "string" ||
+            !objectValue(taskValue.scope)) {
+            return null;
+        }
+        const fallbackTask = {
+            workspaceId,
+            task: taskValue.task,
+            scope: taskValue.scope,
+            ...(Array.isArray(taskValue.files)
+                ? { files: taskValue.files.filter((item) => typeof item === "string") }
+                : {}),
+            ...(Array.isArray(taskValue.components)
+                ? {
+                    components: taskValue.components.filter((item) => typeof item === "string"),
+                }
+                : {}),
+            ...(Array.isArray(taskValue.symbols)
+                ? {
+                    symbols: taskValue.symbols.filter((item) => typeof item === "string"),
+                }
+                : {}),
+        };
+        const selected = selectCachedContext(candidates, fallbackTask);
+        if (selected === null) {
+            return null;
+        }
+        return {
+            context: contextText(selected.context),
+            notice: `Lore used verified ${selected.freshness.state} cached context (${ageLabel(selected.freshness.ageMs)} old) because live retrieval was unavailable.`,
+            metricOutcome: "cached_fallback",
+            cacheAgeMs: selected.freshness.ageMs,
+        };
+    }
+    async #verifySnapshot(compactJws, kind, allowExpired = false) {
+        const workspaceId = this.#workspaceId;
+        if (workspaceId === undefined) {
+            throw new Error("Lore connector has no workspace identity; reconnect Lore");
+        }
+        const verifyWith = (keys) => verifySignedSnapshot(compactJws, {
+            workspaceId,
+            kind,
+            keys,
+            allowExpired,
+        }).payload;
+        try {
+            return verifyWith(await this.#snapshotKeys());
+        }
+        catch (error) {
+            if (!(error instanceof SignedSnapshotError) ||
+                error.code !== "UNTRUSTED_KEY") {
+                throw error;
+            }
+            return verifyWith(await this.#snapshotKeys(true));
+        }
+    }
+    #captureCommitted(response, externalEventId, serverEventId) {
+        const acknowledgement = response.capture.acknowledgement;
+        return (acknowledgement?.state === "committed_server" &&
+            acknowledgement.durability === "workspace_database" &&
+            acknowledgement.replayPending === false &&
+            acknowledgement.idempotencyKey === externalEventId &&
+            acknowledgement.eventId === serverEventId);
+    }
+    async #persistContextSnapshot(compactJws, cacheKey, expectedRequest, eventId, receiptId) {
+        const payload = await this.#verifySnapshot(compactJws, "context", true);
+        const request = objectValue(payload.request);
+        if (request === null ||
+            canonicalJson(request) !== canonicalJson(expectedRequest) ||
+            payload.eventId !== eventId ||
+            payload.receiptId !== receiptId ||
+            typeof payload.context !== "string" ||
+            !Array.isArray(payload.memories) ||
+            !Array.isArray(payload.hits) ||
+            objectValue(payload.packing) === null) {
+            throw new Error("Lore context snapshot does not bind its request and delivery");
+        }
+        if (Date.now() - Date.parse(payload.validUntil) >
+            CONTEXT_CACHE_MAX_STALE_MS) {
+            return null;
+        }
+        await this.#store
+            ?.writeContextSnapshot(cacheKey, { compactJws })
+            .catch(() => undefined);
+        return payload;
+    }
+    async #enqueueCapture(kind, eventId, payload) {
+        if (this.#store === undefined) {
+            return null;
+        }
+        return (await this.#store.enqueue({
+            kind,
+            idempotencyKey: eventId,
+            payload,
+        })).entry;
+    }
+    async #flushCapture() {
+        const store = this.#store;
+        const adapter = this.#adapter;
+        if (store === undefined || adapter === undefined) {
+            return null;
+        }
+        const claimed = await store.claimNext({
+            workerId: `opencode:${process.pid}`,
+            kinds: ["opencode-turn", "opencode-observation"],
+        });
+        if (claimed === null || claimed.claim === undefined) {
+            return null;
+        }
+        try {
+            const payload = objectValue(claimed.payload);
+            if (payload === null) {
+                throw Object.assign(new Error("Invalid OpenCode outbox payload"), {
+                    incompatible: true,
+                });
+            }
+            let turn;
+            let signedContext;
+            let retrievalNotice;
+            if (claimed.kind === "opencode-turn") {
+                if (adapter.processTurnReliable === undefined) {
+                    throw Object.assign(new Error("Lore adapter has no reliable turn operation"), { incompatible: true });
+                }
+                const turnInput = payload;
+                turn = await adapter.processTurnReliable(turnInput, claimed.idempotencyKey);
+                if (!this.#captureCommitted(turn, claimed.idempotencyKey, turn.turn.event.id)) {
+                    throw Object.assign(new Error("Lore turn has no matching durable acknowledgement"), { incompatible: true });
+                }
+                const contextSnapshot = await this.#persistContextSnapshot(turn.contextSnapshot, claimed.idempotencyKey, objectValue(redactUnknown({
+                    connector: turnInput.connector,
+                    eventId: turnInput.eventId,
+                    sessionId: turnInput.sessionId,
+                    task: {
+                        agent: "opencode",
+                        scope: normalizeHostScope(turnInput),
+                        task: typeof turnInput.currentUser === "string"
+                            ? turnInput.currentUser
+                            : (turnInput.currentUser?.content ??
+                                turnInput.currentUserPrompt ??
+                                ""),
+                    },
+                }).value) ?? {}, turn.turn.event.id, turn.turn.receipt.id);
+                if (contextSnapshot === null) {
+                    retrievalNotice =
+                        "Lore context cache is too old to use; continuing without injected context.";
+                }
+                else {
+                    const metadata = contextRetrievalMetadata(turn.retrieval, contextSnapshot);
+                    if (metadata.valid) {
+                        signedContext = contextText(contextSnapshot.context);
+                        retrievalNotice = metadata.notice;
+                    }
+                    else {
+                        retrievalNotice =
+                            "Lore context could not be trusted; continuing without injected context.";
+                    }
+                }
+            }
+            else {
+                if (adapter.observeEventReliable === undefined) {
+                    throw Object.assign(new Error("Lore adapter has no reliable observation operation"), { incompatible: true });
+                }
+                const observed = await adapter.observeEventReliable(payload);
+                if (!this.#captureCommitted(observed, claimed.idempotencyKey, observed.observation.event.id)) {
+                    throw Object.assign(new Error("Lore observation has no matching durable acknowledgement"), { incompatible: true });
+                }
+            }
+            await store.acknowledgeClaim(claimed.claim.id);
+            return {
+                idempotencyKey: claimed.idempotencyKey,
+                ...(turn === undefined ? {} : { turn }),
+                ...(signedContext === undefined ? {} : { signedContext }),
+                ...(retrievalNotice === undefined ? {} : { retrievalNotice }),
+            };
+        }
+        catch (error) {
+            const classified = classifyRetryFailure(error);
+            const failure = objectValue(error);
+            const httpStatus = typeof failure?.httpStatus === "number"
+                ? failure.httpStatus
+                : typeof failure?.status === "number"
+                    ? failure.status
+                    : undefined;
+            await store.failClaim({
+                claimId: claimed.claim.id,
+                classification: error instanceof SignedSnapshotError
+                    ? "incompatible"
+                    : classified === "retryable" &&
+                        httpStatus !== 409 &&
+                        !isContextTransportFailure(error)
+                        ? "incompatible"
+                        : classified,
+                message: error instanceof Error ? error.message : "Lore upload failed",
+            });
+            return null;
+        }
+    }
+    async #prepareContextDelivery(delivery) {
+        const adapter = this.#adapter;
+        if (adapter === undefined) {
+            return undefined;
+        }
+        if (this.#store !== undefined && this.#workspaceId === undefined) {
+            return {
+                context: "",
+                notice: "Lore context is temporarily unavailable; continuing without injected context.",
+                metricOutcome: "failed",
+            };
+        }
+        if (this.#store !== undefined &&
+            this.#workspaceId !== undefined &&
+            adapter.prepareDeliveryReliable !== undefined) {
+            try {
+                const response = await adapter.prepareDeliveryReliable(delivery);
+                const expectedRequest = redactUnknown({
+                    connector: delivery.connector,
+                    eventId: delivery.eventId,
+                    sessionId: delivery.sessionId,
+                    task: toHostTask(delivery, "opencode"),
+                }).value;
+                const contextSnapshot = await this.#persistContextSnapshot(response.snapshot, delivery.eventId, objectValue(expectedRequest) ?? {}, response.delivery.event.id, response.delivery.receipt.id);
+                if (contextSnapshot === null) {
+                    return {
+                        context: "",
+                        notice: "Lore context cache is too old to use; continuing without injected context.",
+                        metricOutcome: "failed",
+                    };
+                }
+                const metadata = contextRetrievalMetadata(response.reliability, contextSnapshot);
+                if (!metadata.valid) {
+                    return {
+                        context: "",
+                        notice: "Lore context could not be trusted; continuing without injected context.",
+                        metricOutcome: "failed",
+                    };
+                }
+                return {
+                    context: contextText(contextSnapshot.context),
+                    ...(metadata.notice === undefined
+                        ? {}
+                        : { notice: metadata.notice }),
+                    ...(metadata.metricOutcome === undefined
+                        ? {}
+                        : { metricOutcome: metadata.metricOutcome }),
+                    ...(metadata.cacheAgeMs === undefined
+                        ? {}
+                        : { cacheAgeMs: metadata.cacheAgeMs }),
+                };
+            }
+            catch (error) {
+                if (isContextTransportFailure(error)) {
+                    const cached = await this.#cachedContext(delivery).catch(() => null);
+                    if (cached !== null) {
+                        return cached;
+                    }
+                    return {
+                        context: "",
+                        notice: "Lore context is temporarily unavailable; continuing without injected context.",
+                        metricOutcome: "failed",
+                    };
+                }
+                return {
+                    context: "",
+                    notice: "Lore context could not be trusted; continuing without injected context.",
+                    metricOutcome: "failed",
+                };
+            }
+        }
+        try {
+            const response = await adapter.prepareDelivery(delivery);
+            return { context: contextText(response.context) };
+        }
+        catch {
+            return {
+                context: "",
+                notice: "Lore context is temporarily unavailable; continuing without injected context.",
+            };
+        }
+    }
+    async #recordPreparedContextMetric(prepared) {
+        if (this.#store === undefined ||
+            prepared?.metricOutcome === undefined) {
+            return;
+        }
+        await recordLocalRetrievalMetric(this.#store, {
+            outcome: prepared.metricOutcome,
+            ...(prepared.cacheAgeMs === undefined
+                ? {}
+                : { cacheAgeMs: prepared.cacheAgeMs }),
+        }).catch(() => undefined);
+    }
+    async #checkGuard(input) {
+        const adapter = this.#adapter;
+        if (adapter === undefined) {
+            return undefined;
+        }
+        if (this.#store !== undefined &&
+            this.#workspaceId !== undefined &&
+            adapter.guardCheckReliable !== undefined) {
+            const response = await adapter.guardCheckReliable(input);
+            const payload = await this.#verifySnapshot(response.policySnapshot, "guard_policy");
+            if (payload.policyVersion !== response.policyVersion) {
+                throw new Error("Lore Guard snapshot does not bind the returned policy");
+            }
+            await this.#store.writePolicySnapshot("current", response.policySnapshot);
+            return response.check;
+        }
+        return adapter.guardCheck?.(input);
+    }
     async #captureAndDeliver(input, output) {
         if (this.#adapter === undefined) {
             return;
@@ -359,7 +901,8 @@ class LoreOpenCodeRuntime {
         }
     }
     async #processChatMessage(state, sessionId, messageId, content, timestamp, fingerprint, input) {
-        if (!state.active) {
+        const adapter = this.#adapter;
+        if (!state.active || adapter === undefined) {
             return;
         }
         if (state.lastChat?.fingerprint === fingerprint) {
@@ -375,10 +918,16 @@ class LoreOpenCodeRuntime {
         state.context = "";
         const scope = scopeFromContext(this.#context, this.#repositoryScope);
         const metadata = metadataFromChat(input, this.#context);
-        const pendingAssistant = state.pendingAssistant;
+        await this.#flushCapture();
+        const pendingAssistant = state.pendingAssistant ??
+            (await this.#loadPendingAssistant(sessionId));
+        if (state.pendingAssistant === undefined &&
+            pendingAssistant !== undefined) {
+            state.pendingAssistant = pendingAssistant;
+        }
         if (pendingAssistant !== undefined) {
             const eventId = stableEventId("turn", sessionId, pendingAssistant.fingerprint, fingerprint);
-            const processed = await this.#attempt(() => this.#adapter.processTurn({
+            const turnInput = {
                 connector: CONNECTOR,
                 eventId,
                 sessionId,
@@ -402,12 +951,69 @@ class LoreOpenCodeRuntime {
                     previousAssistantMessageId: pendingAssistant.id,
                     currentUserMessageId: messageId,
                 },
-            }, eventId));
-            if (processed === undefined || !state.active) {
+            };
+            let context = "";
+            let pendingDurable = false;
+            if (this.#store !== undefined &&
+                adapter.processTurnReliable !== undefined) {
+                try {
+                    await this.#enqueueCapture("opencode-turn", eventId, turnInput);
+                    pendingDurable = true;
+                    await this.#clearPendingAssistant(sessionId);
+                    const flushed = await this.#flushCapture();
+                    if (flushed?.idempotencyKey === eventId &&
+                        flushed.turn !== undefined) {
+                        await recordLocalRetrievalMetric(this.#store, {
+                            outcome: flushed.retrievalNotice?.includes("lexical")
+                                ? "live_lexical_fallback"
+                                : "live_primary",
+                        }).catch(() => undefined);
+                        context = [
+                            this.#contextNotice(state, flushed.retrievalNotice),
+                            flushed.signedContext,
+                        ]
+                            .filter((value) => value !== undefined && value !== "")
+                            .join("\n\n");
+                    }
+                    else {
+                        const prepared = await this.#prepareContextDelivery({
+                            connector: CONNECTOR,
+                            eventId: stableEventId("delivery", sessionId, eventId, content),
+                            sessionId,
+                            scope,
+                            task: content,
+                            limit: 10,
+                        });
+                        await this.#recordPreparedContextMetric(prepared);
+                        context = [
+                            "Lore saved this capture locally; server upload is pending.",
+                            this.#contextNotice(state, prepared?.notice),
+                            prepared?.context,
+                        ]
+                            .filter((value) => value !== undefined && value !== "")
+                            .join("\n\n");
+                    }
+                }
+                catch {
+                    context =
+                        "Lore could not acknowledge this capture locally. Run lore doctor.";
+                }
+            }
+            else {
+                const processed = await this.#attempt(() => adapter.processTurn(turnInput, eventId));
+                if (processed === undefined || !state.active) {
+                    return;
+                }
+                pendingDurable = true;
+                context = contextText(processed.context.text);
+            }
+            if (!state.active) {
                 return;
             }
-            const context = contextText(processed.context.text);
             state.context = context;
+            if (!pendingDurable) {
+                return;
+            }
             state.lastChat = { fingerprint, context };
             state.lastConsumedAssistant = {
                 completedAt: pendingAssistant.completedAt,
@@ -438,16 +1044,52 @@ class LoreOpenCodeRuntime {
             task: content,
             limit: 10,
         };
-        const [observed, prepared] = await Promise.all([
-            this.#attempt(() => this.#adapter.observeEvent(observation)),
-            this.#attempt(() => this.#adapter.prepareDelivery(delivery)),
-        ]);
+        let observed;
+        let preparedContext;
+        let captureNotice = "";
+        if (this.#store !== undefined &&
+            adapter.observeEventReliable !== undefined) {
+            try {
+                await this.#enqueueCapture("opencode-observation", observationId, observation);
+            }
+            catch {
+                captureNotice =
+                    "Lore could not acknowledge this capture locally. Run lore doctor.";
+            }
+            const [flushed, prepared] = await Promise.all([
+                this.#flushCapture(),
+                this.#prepareContextDelivery(delivery),
+            ]);
+            await this.#recordPreparedContextMetric(prepared);
+            observed =
+                flushed?.idempotencyKey === observationId ? flushed : undefined;
+            preparedContext = [
+                this.#contextNotice(state, prepared?.notice),
+                prepared?.context,
+            ]
+                .filter((value) => value !== undefined && value !== "")
+                .join("\n\n");
+            if (observed === undefined && captureNotice === "") {
+                captureNotice =
+                    "Lore saved this capture locally; server upload is pending.";
+            }
+        }
+        else {
+            const [legacyObserved, prepared] = await Promise.all([
+                this.#attempt(() => adapter.observeEvent(observation)),
+                this.#attempt(() => adapter.prepareDelivery(delivery)),
+            ]);
+            observed = legacyObserved;
+            preparedContext = contextText(prepared?.context);
+        }
         if (!state.active) {
             return;
         }
-        const context = contextText(prepared?.context);
+        const context = [captureNotice, preparedContext]
+            .filter((value) => value !== undefined && value !== "")
+            .join("\n\n");
         state.context = context;
-        if (observed !== undefined && prepared !== undefined) {
+        if (observed !== undefined && preparedContext !== undefined) {
             state.lastChat = { fingerprint, context };
         }
     }
@@ -479,7 +1121,8 @@ class LoreOpenCodeRuntime {
     }
     async #guardBeforeTool(input, output) {
         const adapter = this.#adapter;
-        if (adapter?.guardCheck === undefined) {
+        if (adapter?.guardCheck === undefined &&
+            adapter?.guardCheckReliable === undefined) {
             return undefined;
         }
         const sessionId = boundedIdentifier(input.sessionID);
@@ -500,11 +1143,21 @@ class LoreOpenCodeRuntime {
         const now = Date.now();
         if (state.guardMode?.mode === "off" &&
             now - state.guardMode.checkedAt < GUARD_MODE_TTL_MS) {
+            if (this.#store !== undefined) {
+                await recordLocalGuardMetric(this.#store, {
+                    outcome: "reused_decision",
+                }).catch(() => undefined);
+            }
             return undefined;
         }
         const key = guardKey(trigger);
         const lastSeen = state.guardKeys?.get(key);
         if (lastSeen !== undefined && now - lastSeen < GUARD_KEY_COOLDOWN_MS) {
+            if (this.#store !== undefined) {
+                await recordLocalGuardMetric(this.#store, {
+                    outcome: "reused_decision",
+                }).catch(() => undefined);
+            }
             return undefined;
         }
         const scope = scopeFromContext(this.#context, this.#repositoryScope);
@@ -517,18 +1170,36 @@ class LoreOpenCodeRuntime {
             return relativePath.startsWith("..") ? file : relativePath;
         })
             .map((file) => truncateUtf8(file, MAX_PATH_BYTES));
-        const verdict = await this.#attempt(() => adapter.guardCheck({
-            connector: CONNECTOR,
-            sessionId,
-            action: trigger.action,
-            tool: input.tool,
-            ...(scope.repo === undefined ? {} : { repo: scope.repo }),
-            ...(scope.path === undefined ? {} : { path: scope.path }),
-            ...(files === undefined ? {} : { files }),
-            ...(trigger.command === undefined
-                ? {}
-                : { command: truncateUtf8(trigger.command, MAX_PATH_BYTES) }),
-        }));
+        const startedAt = Date.now();
+        let verdict;
+        try {
+            verdict = await withTimeout(this.#timeoutMs, () => this.#checkGuard({
+                connector: CONNECTOR,
+                sessionId,
+                action: trigger.action,
+                tool: input.tool,
+                ...(scope.repo === undefined ? {} : { repo: scope.repo }),
+                ...(scope.path === undefined ? {} : { path: scope.path }),
+                ...(files === undefined ? {} : { files }),
+                ...(trigger.command === undefined
+                    ? {}
+                    : { command: truncateUtf8(trigger.command, MAX_PATH_BYTES) }),
+            }));
+        }
+        catch (error) {
+            if (this.#store !== undefined) {
+                await recordLocalGuardMetric(this.#store, {
+                    outcome: "failed",
+                }).catch(() => undefined);
+            }
+            throw error;
+        }
+        if (this.#store !== undefined) {
+            await recordLocalGuardMetric(this.#store, {
+                outcome: verdict === undefined ? "failed" : "live_check",
+                durationMs: Math.max(0, Date.now() - startedAt),
+            }).catch(() => undefined);
+        }
         if (verdict === undefined || !state.active) {
             return undefined;
         }
@@ -644,13 +1315,15 @@ class LoreOpenCodeRuntime {
                     fingerprint === state.pendingAssistant.fingerprint))) {
             return;
         }
-        state.pendingAssistant = {
+        const pendingAssistant = {
             id: assistantId,
             content: assistantContent,
             timestamp: isoTimestamp(completedAt),
             completedAt,
             fingerprint,
         };
+        await this.#savePendingAssistant(sessionId, pendingAssistant);
+        state.pendingAssistant = pendingAssistant;
     }
     #deleteSession(sessionId) {
         const state = this.#sessions.get(sessionId);
@@ -666,18 +1339,40 @@ class LoreOpenCodeRuntime {
         this.#sessions.delete(sessionId);
     }
 }
+function effectiveHome(dependencies) {
+    return (dependencies.home ??
+        (dependencies.env ?? process.env).HOME ??
+        homedir());
+}
 async function createAdapter(dependencies, timeoutMs) {
     if (dependencies.adapter !== undefined) {
-        return dependencies.adapter;
+        if (dependencies.workspaceId === undefined) {
+            return {
+                adapter: dependencies.adapter,
+                store: undefined,
+                invocationWorkspaceKey: undefined,
+                workspaceId: undefined,
+            };
+        }
+        const store = new ReliabilityStore(dependencies.workspaceId, {
+            home: effectiveHome(dependencies),
+        });
+        await store.initialize();
+        return {
+            adapter: dependencies.adapter,
+            store,
+            invocationWorkspaceKey: dependencies.workspaceId,
+            workspaceId: dependencies.workspaceId,
+        };
     }
     try {
         const env = dependencies.env ?? process.env;
         const credentials = await resolveLoreCredentials({
             env,
-            ...(dependencies.home === undefined ? {} : { home: dependencies.home }),
+            home: effectiveHome(dependencies),
         });
         const fetchImplementation = dependencies.fetch ?? globalThis.fetch;
-        return new GenericAgentAdapter({
+        const adapter = new GenericAgentAdapter({
             id: "opencode",
             baseUrl: credentials.apiUrl,
             headers: {
@@ -685,20 +1380,99 @@ async function createAdapter(dependencies, timeoutMs) {
             },
             fetch: createBoundedFetch(fetchImplementation, timeoutMs),
         });
+        let workspaceId = credentials.workspaceId;
+        let keySet;
+        let legacyServer = false;
+        if (workspaceId === undefined) {
+            try {
+                keySet = await adapter.getSnapshotPublicKeys();
+                workspaceId = keySet.workspaceId;
+            }
+            catch (error) {
+                legacyServer =
+                    objectValue(error)?.status === 404;
+                // Captures can still queue under a credential-scoped fallback.
+            }
+        }
+        if (legacyServer) {
+            return {
+                adapter,
+                store: undefined,
+                invocationWorkspaceKey: undefined,
+                workspaceId: undefined,
+            };
+        }
+        const credentialStoreKey = `credential-${createHash("sha256")
+            .update(`${credentials.apiUrl}\0${credentials.token}`)
+            .digest("hex")
+            .slice(0, 32)}`;
+        const storeKey = workspaceId ?? credentialStoreKey;
+        const store = new ReliabilityStore(storeKey, {
+            home: effectiveHome(dependencies),
+        });
+        await store.initialize();
+        if (workspaceId !== undefined) {
+            const credentialStore = new ReliabilityStore(credentialStoreKey, {
+                home: effectiveHome(dependencies),
+            });
+            await credentialStore.transferPendingTo(store);
+        }
+        if (keySet !== undefined && workspaceId !== undefined) {
+            await store.writePublicTrustKeys(keySet.keys.map((key) => ({
+                ...key,
+                workspaceId,
+            })));
+            await store.writeState(TRUST_KEY_REFRESH_STATE_KEY, {
+                refreshedAt: new Date().toISOString(),
+            });
+        }
+        return {
+            adapter,
+            store,
+            invocationWorkspaceKey: storeKey,
+            workspaceId,
+        };
     }
     catch {
-        return undefined;
+        return {
+            adapter: undefined,
+            store: undefined,
+            invocationWorkspaceKey: undefined,
+            workspaceId: undefined,
+        };
     }
 }
 export function createLoreOpenCodePlugin(dependencies = {}) {
     return async (context, options) => {
         const env = dependencies.env ?? process.env;
         const timeoutMs = pluginTimeout(options, env);
-        const adapter = await createAdapter(dependencies, timeoutMs);
+        const runtime = await createAdapter(dependencies, timeoutMs);
+        const invocation = runtime.invocationWorkspaceKey === undefined
+            ? null
+            : createIntegrationInvocationAttempt("plugin/opencode", { runtimeVersion: OPENCODE_PLUGIN_VERSION });
+        const invocationRecorded = runtime.invocationWorkspaceKey === undefined || invocation === null
+            ? false
+            : await writeInvocationAttemptBounded(runtime.invocationWorkspaceKey, invocation, { home: effectiveHome(dependencies) }).catch(() => false);
         const repositoryScope = dependencies.repositoryScope === undefined
             ? await repositoryScopeFromWorktree(context.worktree)
             : canonicalRepositoryScope(dependencies.repositoryScope);
-        return new LoreOpenCodeRuntime(context, adapter, timeoutMs, repositoryScope).hooks();
+        try {
+            const hooks = new LoreOpenCodeRuntime(context, runtime.adapter, timeoutMs, repositoryScope, runtime.store, runtime.workspaceId).hooks();
+            if (runtime.invocationWorkspaceKey !== undefined &&
+                invocation !== null &&
+                invocationRecorded) {
+                await writeInvocationCompletionBounded(runtime.invocationWorkspaceKey, invocation, { success: true }, { home: effectiveHome(dependencies) }).catch(() => undefined);
+            }
+            return hooks;
+        }
+        catch (error) {
+            if (runtime.invocationWorkspaceKey !== undefined &&
+                invocation !== null &&
+                invocationRecorded) {
+                await writeInvocationCompletionBounded(runtime.invocationWorkspaceKey, invocation, { success: false, failureCode: "runtime_error" }, { home: effectiveHome(dependencies) }).catch(() => undefined);
+            }
+            throw error;
+        }
     };
 }
 export const LoreOpenCodePlugin = createLoreOpenCodePlugin();