@wardby/cli 0.5.3 → 0.7.0

package/dist/providers/chat/fake.d.ts

@@ -0,0 +1,46 @@
+/**
+ * In-memory ChatProvider for tests: records every post/update, serves
+ * `channelInfo` from a settable map, and lets a test queue one error per
+ * method to be thrown on its next call.
+ */
+import type { ChatError, ChatMessage, ChatProvider } from "./types.js";
+export declare class FakeChatProvider implements ChatProvider {
+    readonly name: "slack";
+    readonly posts: Array<{
+        channelId: string;
+        ts: string;
+        msg: ChatMessage;
+        threadTs?: string;
+        broadcast?: boolean;
+    }>;
+    readonly updates: Array<{
+        channelId: string;
+        ts: string;
+        msg: ChatMessage;
+    }>;
+    readonly channels: Map<string, {
+        id: string;
+        name: string;
+        isPrivate: boolean;
+    }>;
+    private readonly queuedErrors;
+    private nextTs;
+    failNext(method: "postMessage" | "updateMessage" | "channelInfo" | "authTest", err: ChatError): void;
+    private consumeFailure;
+    postMessage(channelId: string, msg: ChatMessage, opts?: {
+        threadTs?: string;
+        broadcast?: boolean;
+    }): Promise<{
+        ts: string;
+    }>;
+    updateMessage(channelId: string, ts: string, msg: ChatMessage): Promise<void>;
+    channelInfo(channel: string): Promise<{
+        id: string;
+        name: string;
+        isPrivate: boolean;
+    } | null>;
+    authTest(): Promise<{
+        team: string;
+        botUserId: string;
+    }>;
+}

package/dist/providers/chat/fake.js

@@ -0,0 +1,39 @@
+export class FakeChatProvider {
+    name = "slack";
+    posts = [];
+    updates = [];
+    channels = new Map();
+    queuedErrors = {
+        postMessage: [],
+        updateMessage: [],
+        channelInfo: [],
+        authTest: [],
+    };
+    nextTs = 1;
+    failNext(method, err) {
+        this.queuedErrors[method].push(err);
+    }
+    consumeFailure(method) {
+        const err = this.queuedErrors[method].shift();
+        if (err)
+            throw err;
+    }
+    async postMessage(channelId, msg, opts = {}) {
+        this.consumeFailure("postMessage");
+        const ts = `${this.nextTs++}.000`;
+        this.posts.push({ channelId, ts, msg, threadTs: opts.threadTs, broadcast: opts.broadcast });
+        return { ts };
+    }
+    async updateMessage(channelId, ts, msg) {
+        this.consumeFailure("updateMessage");
+        this.updates.push({ channelId, ts, msg });
+    }
+    async channelInfo(channel) {
+        this.consumeFailure("channelInfo");
+        return this.channels.get(channel) ?? null;
+    }
+    async authTest() {
+        this.consumeFailure("authTest");
+        return { team: "fake", botUserId: "UFAKE" };
+    }
+}

package/dist/providers/chat/index.d.ts

@@ -0,0 +1,4 @@
+import type { ChatProviderRegistry } from "./types.js";
+export * from "./types.js";
+/** One provider per configured chat service; empty when Slack is not configured. */
+export declare function buildChatProviders(env?: NodeJS.ProcessEnv, fetchImpl?: typeof fetch): ChatProviderRegistry;

package/dist/providers/chat/index.js

@@ -0,0 +1,8 @@
+import { loadSlackConfig } from "../../config/providers.js";
+import { SlackChatProvider } from "./slack.js";
+export * from "./types.js";
+/** One provider per configured chat service; empty when Slack is not configured. */
+export function buildChatProviders(env = process.env, fetchImpl) {
+    const slack = loadSlackConfig(env);
+    return slack ? { slack: new SlackChatProvider(slack, fetchImpl) } : {};
+}

package/dist/providers/chat/slack.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Slack Web API client for workflow notifications: chat.postMessage,
+ * chat.update, conversations.info, auth.test. Plain fetch (JSON bodies for
+ * writes, form-encoded for reads), bot token. Every failure becomes a ChatError with a normalized code the
+ * dispatcher acts on; Slack's own error string is kept for the operator.
+ */
+import type { SlackConfig } from "../../config/providers.js";
+import { type ChatMessage, type ChatProvider } from "./types.js";
+export declare class SlackChatProvider implements ChatProvider {
+    private readonly config;
+    private readonly fetchImpl;
+    readonly name: "slack";
+    constructor(config: SlackConfig, fetchImpl?: typeof fetch);
+    /**
+     * `form` for read methods (conversations.info, auth.test): Slack accepts JSON
+     * bodies only on write methods and answers a read method's JSON body with
+     * invalid_arguments.
+     */
+    private call;
+    private messageBody;
+    postMessage(channelId: string, msg: ChatMessage, opts?: {
+        threadTs?: string;
+        broadcast?: boolean;
+    }): Promise<{
+        ts: string;
+    }>;
+    updateMessage(channelId: string, ts: string, msg: ChatMessage): Promise<void>;
+    channelInfo(channel: string): Promise<{
+        id: string;
+        name: string;
+        isPrivate: boolean;
+    } | null>;
+    authTest(): Promise<{
+        team: string;
+        botUserId: string;
+    }>;
+}

package/dist/providers/chat/slack.js

@@ -0,0 +1,105 @@
+import { ChatError } from "./types.js";
+const CHANNEL_UNREACHABLE = new Set(["channel_not_found", "not_in_channel", "is_archived"]);
+const AUTH_FAILED = new Set([
+    "invalid_auth",
+    "not_authed",
+    "token_revoked",
+    "token_expired",
+    "account_inactive",
+    "missing_scope",
+]);
+const TIMEOUT_MS = 10_000;
+function classify(slackError) {
+    if (CHANNEL_UNREACHABLE.has(slackError))
+        return "channel_unreachable";
+    if (AUTH_FAILED.has(slackError))
+        return "auth_failed";
+    if (slackError === "message_not_found")
+        return "message_not_found";
+    if (slackError === "ratelimited")
+        return "rate_limited";
+    return "transient";
+}
+export class SlackChatProvider {
+    config;
+    fetchImpl;
+    name = "slack";
+    constructor(config, fetchImpl = fetch) {
+        this.config = config;
+        this.fetchImpl = fetchImpl;
+    }
+    /**
+     * `form` for read methods (conversations.info, auth.test): Slack accepts JSON
+     * bodies only on write methods and answers a read method's JSON body with
+     * invalid_arguments.
+     */
+    async call(method, body, encoding = "json") {
+        let res;
+        try {
+            res = await this.fetchImpl(`${this.config.apiBaseUrl}/${method}`, {
+                method: "POST",
+                headers: {
+                    authorization: `Bearer ${this.config.botToken}`,
+                    "content-type": encoding === "json" ? "application/json; charset=utf-8" : "application/x-www-form-urlencoded",
+                },
+                body: encoding === "json"
+                    ? JSON.stringify(body)
+                    : new URLSearchParams(Object.fromEntries(Object.entries(body).map(([k, v]) => [k, String(v)]))).toString(),
+                signal: AbortSignal.timeout(TIMEOUT_MS),
+            });
+        }
+        catch (err) {
+            throw new ChatError("transient", err instanceof Error ? err.message : String(err));
+        }
+        if (res.status === 429) {
+            const seconds = Number(res.headers.get("retry-after") ?? "1");
+            throw new ChatError("rate_limited", "ratelimited", (Number.isFinite(seconds) && seconds > 0 ? seconds : 1) * 1000);
+        }
+        if (!res.ok)
+            throw new ChatError("transient", `http_${res.status}`);
+        const json = (await res.json().catch(() => ({ ok: false, error: "invalid_json" })));
+        if (json.ok !== true) {
+            const slackError = typeof json.error === "string" ? json.error : "unknown_error";
+            throw new ChatError(classify(slackError), slackError);
+        }
+        return json;
+    }
+    messageBody(msg) {
+        return {
+            text: msg.text,
+            ...(msg.blocks ? { blocks: msg.blocks } : {}),
+            ...(this.config.customize && msg.username ? { username: msg.username } : {}),
+            ...(this.config.customize && msg.iconEmoji ? { icon_emoji: msg.iconEmoji } : {}),
+        };
+    }
+    async postMessage(channelId, msg, opts = {}) {
+        const json = await this.call("chat.postMessage", {
+            channel: channelId,
+            ...this.messageBody(msg),
+            ...(opts.threadTs ? { thread_ts: opts.threadTs } : {}),
+            ...(opts.threadTs && opts.broadcast ? { reply_broadcast: true } : {}),
+            unfurl_links: false,
+            unfurl_media: false,
+        });
+        return { ts: String(json.ts) };
+    }
+    async updateMessage(channelId, ts, msg) {
+        await this.call("chat.update", { channel: channelId, ts, ...this.messageBody(msg) });
+    }
+    async channelInfo(channel) {
+        try {
+            const json = await this.call("conversations.info", { channel }, "form");
+            const c = json.channel;
+            return { id: c.id, name: c.name, isPrivate: c.is_private === true };
+        }
+        catch (err) {
+            if (err instanceof ChatError && err.code === "channel_unreachable")
+                return null;
+            throw err;
+        }
+    }
+    async authTest() {
+        const json = await this.call("auth.test", {}, "form");
+        return { team: String(json.team), botUserId: String(json.user_id) };
+    }
+}

package/dist/providers/chat/types.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Host-neutral chat surface for outbound workflow notifications. Slack is
+ * the first (and only) implementation (./slack.ts). wardby only ever posts
+ * or updates messages here — it never reads channel history or listens for
+ * events.
+ */
+export declare const CHAT_PROVIDERS: readonly ["slack"];
+export type ChatProviderName = (typeof CHAT_PROVIDERS)[number];
+export type ChatErrorCode = "rate_limited" | "channel_unreachable" | "auth_failed" | "message_not_found" | "transient";
+export declare class ChatError extends Error {
+    readonly code: ChatErrorCode;
+    readonly slackError: string;
+    readonly retryAfterMs?: number | undefined;
+    constructor(code: ChatErrorCode, slackError: string, retryAfterMs?: number | undefined);
+}
+export interface ChatMessage {
+    text: string;
+    blocks?: unknown[];
+    username?: string;
+    iconEmoji?: string;
+}
+export interface ChatProvider {
+    readonly name: ChatProviderName;
+    postMessage(channelId: string, msg: ChatMessage, opts?: {
+        threadTs?: string;
+        broadcast?: boolean;
+    }): Promise<{
+        ts: string;
+    }>;
+    updateMessage(channelId: string, ts: string, msg: ChatMessage): Promise<void>;
+    /** null when the bot cannot see the channel; throws ChatError("auth_failed") on missing scope. */
+    channelInfo(channel: string): Promise<{
+        id: string;
+        name: string;
+        isPrivate: boolean;
+    } | null>;
+    authTest(): Promise<{
+        team: string;
+        botUserId: string;
+    }>;
+}
+export type ChatProviderRegistry = Partial<Record<ChatProviderName, ChatProvider>>;

package/dist/providers/chat/types.js

@@ -0,0 +1,19 @@
+/**
+ * Host-neutral chat surface for outbound workflow notifications. Slack is
+ * the first (and only) implementation (./slack.ts). wardby only ever posts
+ * or updates messages here — it never reads channel history or listens for
+ * events.
+ */
+export const CHAT_PROVIDERS = ["slack"];
+export class ChatError extends Error {
+    code;
+    slackError;
+    retryAfterMs;
+    constructor(code, slackError, retryAfterMs) {
+        super(`chat_error:${code}:${slackError}`);
+        this.code = code;
+        this.slackError = slackError;
+        this.retryAfterMs = retryAfterMs;
+        this.name = "ChatError";
+    }
+}

package/dist/providers/coding-proxy/dependency-cache/eviction.d.ts

@@ -0,0 +1,29 @@
+import type { BlobStore } from "../../storage/types.js";
+import type { DependencyCacheStore, EvictionRow } from "./store.js";
+/** How often the proxy runs an eviction pass. */
+export declare const DEFAULT_EVICTION_INTERVAL_MS: number;
+export interface EvictionLimits {
+    maxAgeMs: number;
+    repoCapBytes: number;
+    totalCapBytes: number;
+}
+/** The snapshots to evict, in the order to evict them. */
+export declare function selectEvictions(rows: readonly EvictionRow[], limits: EvictionLimits, now: Date): EvictionRow[];
+export interface EvictionOptions {
+    store: DependencyCacheStore;
+    blobs: Pick<BlobStore, "delete">;
+    limits: EvictionLimits;
+    now?: () => Date;
+}
+/** One eviction pass; `ran` is false when another holder had the lock. */
+export declare function runEviction(options: EvictionOptions): Promise<{
+    ran: boolean;
+    deleted: number;
+    failed: number;
+}>;
+/** Runs an eviction pass every `intervalMs` (the first one interval after start). */
+export declare function startEviction(options: EvictionOptions & {
+    intervalMs?: number;
+}): {
+    stop(): void;
+};

package/dist/providers/coding-proxy/dependency-cache/eviction.js

@@ -0,0 +1,87 @@
+/**
+ * Dependency cache eviction: a periodic pass inside the proxy, coordinated
+ * across replicas by a Postgres advisory lock (the store's
+ * withEvictionLock). It removes snapshots past the maximum age (by creation,
+ * so every snapshot is rebuilt at least that often), then the least recently
+ * used beyond each repository's cap, then beyond the total cap. A blob is
+ * deleted before its row, so a failed blob delete leaves the row for the next
+ * pass to retry rather than an orphaned blob.
+ */
+import { logger } from "../../../core/logger.js";
+const evictionLog = logger.child({ module: "dependency-cache" });
+/** How often the proxy runs an eviction pass. */
+export const DEFAULT_EVICTION_INTERVAL_MS = 60 * 60_000;
+const leastRecentlyUsed = (a, b) => a.lastUsedAt.getTime() - b.lastUsedAt.getTime() || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+/** The snapshots to evict, in the order to evict them. */
+export function selectEvictions(rows, limits, now) {
+    const cutoff = now.getTime() - limits.maxAgeMs;
+    const evicted = rows
+        .filter((row) => row.createdAt.getTime() <= cutoff)
+        .sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime() || leastRecentlyUsed(a, b));
+    let kept = rows.filter((row) => row.createdAt.getTime() > cutoff);
+    const byRepository = new Map();
+    for (const row of kept)
+        byRepository.set(row.repository, [...(byRepository.get(row.repository) ?? []), row]);
+    const overRepoCap = new Set();
+    for (const repoRows of byRepository.values()) {
+        let total = repoRows.reduce((sum, row) => sum + row.sizeBytes, 0);
+        for (const row of [...repoRows].sort(leastRecentlyUsed)) {
+            if (total <= limits.repoCapBytes)
+                break;
+            evicted.push(row);
+            overRepoCap.add(row.id);
+            total -= row.sizeBytes;
+        }
+    }
+    kept = kept.filter((row) => !overRepoCap.has(row.id));
+    let total = kept.reduce((sum, row) => sum + row.sizeBytes, 0);
+    for (const row of [...kept].sort(leastRecentlyUsed)) {
+        if (total <= limits.totalCapBytes)
+            break;
+        evicted.push(row);
+        total -= row.sizeBytes;
+    }
+    return evicted;
+}
+/** One eviction pass; `ran` is false when another holder had the lock. */
+export async function runEviction(options) {
+    const result = { ran: false, deleted: 0, failed: 0 };
+    result.ran = await options.store.withEvictionLock(async () => {
+        const rows = await options.store.listForEviction();
+        for (const row of selectEvictions(rows, options.limits, (options.now ?? (() => new Date()))())) {
+            try {
+                await options.blobs.delete(row.blobKey);
+            }
+            catch (error) {
+                result.failed += 1;
+                evictionLog.warn({ event: "dependency_cache.evict_blob_failed", snapshotId: row.id, err: error }, "dependency cache: a snapshot's blob could not be deleted; the next pass retries");
+                continue;
+            }
+            await options.store.delete(row.id);
+            result.deleted += 1;
+        }
+    });
+    return result;
+}
+/** Runs an eviction pass every `intervalMs` (the first one interval after start). */
+export function startEviction(options) {
+    let running = false;
+    const timer = setInterval(() => {
+        if (running)
+            return;
+        running = true;
+        runEviction(options)
+            .then((result) => {
+            if (result.deleted > 0 || result.failed > 0)
+                evictionLog.info({ event: "dependency_cache.evicted", deleted: result.deleted, failed: result.failed }, "dependency cache eviction pass");
+        })
+            .catch((error) => {
+            evictionLog.warn({ event: "dependency_cache.evict_failed", err: error }, "dependency cache eviction failed");
+        })
+            .finally(() => {
+            running = false;
+        });
+    }, options.intervalMs ?? DEFAULT_EVICTION_INTERVAL_MS);
+    timer.unref();
+    return { stop: () => clearInterval(timer) };
+}

package/dist/providers/coding-proxy/dependency-cache/key.d.ts

@@ -0,0 +1,33 @@
+/** The only ecosystem the cache serves today. */
+export declare const DEPENDENCY_CACHE_ECOSYSTEM = "npm";
+/** Lockfile hashes one session may hold (plans beyond this are not recorded). */
+export declare const MAX_DEPENDENCY_CACHE_LOCK_HASHES = 8;
+export declare function sha256Hex(data: string | Uint8Array): string;
+/** JSON with object keys sorted, so equal values always serialize alike. */
+export declare function canonicalJson(value: unknown): string;
+export declare function isLockHash(value: string): boolean;
+/**
+ * The project folder relative to the repository root, or null when it is not
+ * acceptable: "." (or absent) is the root; otherwise 1-3 plain segments, none
+ * empty, none starting with a dot, none named node_modules.
+ */
+export declare function parseProjectPath(raw: string | null | undefined): string | null;
+export interface SnapshotKeyParts {
+    repository: string;
+    projectPath: string;
+    lockHash: string;
+    workerImage: string;
+}
+export interface SnapshotKey extends SnapshotKeyParts {
+    ecosystem: string;
+    /** The opaque id a worker downloads the derived key by: sha256 of the canonical identity tuple. */
+    keyId: string;
+}
+export declare function deriveSnapshotKey(parts: SnapshotKeyParts): SnapshotKey;
+/**
+ * A fresh blob key for one upload of `key`. Each upload writes its own object
+ * (the random suffix), so a concurrent or refused upload can never replace
+ * the bytes of a snapshot already committed; a row always names the exact
+ * object its sha256 and size describe.
+ */
+export declare function newBlobKey(key: SnapshotKey): string;

package/dist/providers/coding-proxy/dependency-cache/key.js

@@ -0,0 +1,86 @@
+/**
+ * Dependency cache keys, derived only on the proxy. A worker names nothing
+ * in a key except its project folder (validated here); the lock hash comes
+ * from a lockfile plan the proxy approved, and the repository and image come
+ * from the run's own records.
+ *
+ * The agent's package policy is not part of a key. A snapshot's contents
+ * depend only on the lockfile and the image (`npm ci --ignore-scripts`
+ * installs exactly the lockfile's integrity-checked packages), and every
+ * restore already requires the proxy to have approved this run's lockfile
+ * under the restoring agent's current policy (the plan gate,
+ * `dependencyCacheLockHashes`). So a snapshot built under another policy, or
+ * by another agent on the same repository, restores only when today's policy
+ * approves the same lockfile.
+ */
+import { createHash, randomUUID } from "node:crypto";
+/** The only ecosystem the cache serves today. */
+export const DEPENDENCY_CACHE_ECOSYSTEM = "npm";
+/** Lockfile hashes one session may hold (plans beyond this are not recorded). */
+export const MAX_DEPENDENCY_CACHE_LOCK_HASHES = 8;
+const LOCK_HASH = /^[0-9a-f]{64}$/;
+/** A project-path segment: no leading dot (no `.`, `..` or dot-folder), no
+ *  separators, whitespace or control characters. */
+const PROJECT_SEGMENT = /^[A-Za-z0-9_@+-][A-Za-z0-9._@+-]{0,99}$/;
+const MAX_PROJECT_SEGMENTS = 3;
+export function sha256Hex(data) {
+    return createHash("sha256").update(data).digest("hex");
+}
+function canonical(value) {
+    if (Array.isArray(value))
+        return value.map((item) => (item === undefined ? null : canonical(item)));
+    if (value !== null && typeof value === "object") {
+        const record = value;
+        // Code-unit order (the default sort), never locale order: the hash must
+        // be the same on every host.
+        return Object.fromEntries(Object.keys(record)
+            .filter((key) => record[key] !== undefined)
+            .sort()
+            .map((key) => [key, canonical(record[key])]));
+    }
+    return value;
+}
+/** JSON with object keys sorted, so equal values always serialize alike. */
+export function canonicalJson(value) {
+    return JSON.stringify(canonical(value)) ?? "null";
+}
+export function isLockHash(value) {
+    return LOCK_HASH.test(value);
+}
+/**
+ * The project folder relative to the repository root, or null when it is not
+ * acceptable: "." (or absent) is the root; otherwise 1-3 plain segments, none
+ * empty, none starting with a dot, none named node_modules.
+ */
+export function parseProjectPath(raw) {
+    if (raw === undefined || raw === null || raw === ".")
+        return ".";
+    const segments = raw.split("/");
+    if (segments.length > MAX_PROJECT_SEGMENTS)
+        return null;
+    for (const segment of segments) {
+        if (!PROJECT_SEGMENT.test(segment) || segment === "node_modules")
+            return null;
+    }
+    return raw;
+}
+export function deriveSnapshotKey(parts) {
+    const identity = {
+        ecosystem: DEPENDENCY_CACHE_ECOSYSTEM,
+        repository: parts.repository,
+        projectPath: parts.projectPath,
+        lockHash: parts.lockHash,
+        workerImage: parts.workerImage,
+    };
+    return { ...identity, keyId: sha256Hex(canonicalJson(identity)) };
+}
+/**
+ * A fresh blob key for one upload of `key`. Each upload writes its own object
+ * (the random suffix), so a concurrent or refused upload can never replace
+ * the bytes of a snapshot already committed; a row always names the exact
+ * object its sha256 and size describe.
+ */
+export function newBlobKey(key) {
+    return (`dependency-cache/${key.ecosystem}/${sha256Hex(key.repository)}/${sha256Hex(key.projectPath).slice(0, 16)}/` +
+        `${key.lockHash}-${sha256Hex(key.workerImage).slice(0, 16)}-${randomUUID()}.tgz`);
+}

package/dist/providers/coding-proxy/dependency-cache/model-request-seal.d.ts

@@ -0,0 +1,18 @@
+import type { DependencyCacheStore } from "./store.js";
+/**
+ * Seals a run's dependency-cache session on its first model request: the agent exists from that
+ * request on, so the cache's pre-agent phase is over whatever the worker did (or failed to do).
+ * The workers run the cache before they create the agent (Codex: driver.ts runs it before
+ * startThread; Claude Code: driver.ts calls the prepare tool before createQuery), so no model
+ * request precedes it. The seal is idempotent and conditional (only an unsealed session of a run
+ * with the cache on), remembered per run in this process so it costs one write per run per proxy
+ * replica, and never fails the model request: a database error is logged and retried on the
+ * run's next request.
+ */
+export declare class ModelRequestSeal {
+    private readonly store;
+    private readonly now;
+    private readonly sealed;
+    constructor(store: Pick<DependencyCacheStore, "sealForModelRequest">, now?: () => Date);
+    onModelRequest(runId: string): Promise<void>;
+}

package/dist/providers/coding-proxy/dependency-cache/model-request-seal.js

@@ -0,0 +1,40 @@
+import { logger } from "../../../core/logger.js";
+const sealLog = logger.child({ module: "dependency-cache" });
+/** Runs remembered as sealed per proxy process; the oldest are forgotten past this (a re-seal is a no-op write). */
+const MAX_REMEMBERED_RUNS = 10_000;
+/**
+ * Seals a run's dependency-cache session on its first model request: the agent exists from that
+ * request on, so the cache's pre-agent phase is over whatever the worker did (or failed to do).
+ * The workers run the cache before they create the agent (Codex: driver.ts runs it before
+ * startThread; Claude Code: driver.ts calls the prepare tool before createQuery), so no model
+ * request precedes it. The seal is idempotent and conditional (only an unsealed session of a run
+ * with the cache on), remembered per run in this process so it costs one write per run per proxy
+ * replica, and never fails the model request: a database error is logged and retried on the
+ * run's next request.
+ */
+export class ModelRequestSeal {
+    store;
+    now;
+    sealed = new Set();
+    constructor(store, now = () => new Date()) {
+        this.store = store;
+        this.now = now;
+    }
+    async onModelRequest(runId) {
+        if (this.sealed.has(runId))
+            return;
+        try {
+            await this.store.sealForModelRequest(runId, this.now());
+        }
+        catch (error) {
+            sealLog.warn({ event: "dependency_cache.model_seal_failed", runId, err: error }, "dependency cache: seal on the run's model request failed");
+            return;
+        }
+        this.sealed.add(runId);
+        if (this.sealed.size > MAX_REMEMBERED_RUNS) {
+            const oldest = this.sealed.values().next().value;
+            if (oldest !== undefined)
+                this.sealed.delete(oldest);
+        }
+    }
+}

package/dist/providers/coding-proxy/dependency-cache/prisma-store.d.ts

@@ -0,0 +1,25 @@
+import { type PrismaClient } from "#prisma";
+import type { DependencyCacheSessionState } from "../registry/store.js";
+import { type DependencyCacheStore, type EvictionRow, type NewSnapshot, type SnapshotIdentity, type SnapshotRow, type SnapshotScope } from "./store.js";
+export declare class PrismaDependencyCacheStore implements DependencyCacheStore {
+    private readonly db;
+    constructor(db: PrismaClient);
+    session(runId: string): Promise<DependencyCacheSessionState | null>;
+    seal(runId: string, now: Date): Promise<void>;
+    sealForModelRequest(runId: string, now: Date): Promise<void>;
+    findByIdentity(identity: SnapshotIdentity): Promise<SnapshotRow | null>;
+    findNearest(scope: SnapshotScope, excludeLockHash: string): Promise<SnapshotRow | null>;
+    hasUploaded(runId: string, ecosystem: string, projectPath: string): Promise<boolean>;
+    insert(snapshot: NewSnapshot): Promise<"inserted" | "exists">;
+    touch(id: string, now: Date): Promise<void>;
+    delete(id: string): Promise<void>;
+    deleteIfBlob(id: string, blobKey: string): Promise<boolean>;
+    listForEviction(): Promise<EvictionRow[]>;
+    /**
+     * A transaction-scoped advisory lock: Postgres releases it when the
+     * transaction ends, so a crashed proxy never leaves it held. The work runs
+     * on the ordinary client (each delete commits at once); the transaction
+     * only holds the lock.
+     */
+    withEvictionLock(work: () => Promise<void>): Promise<boolean>;
+}