@vibesdotdev/storage 0.0.2 → 1.0.0-rc.3

package/dist/retention/roots.js

@@ -0,0 +1,223 @@
+/**
+ * What lives in a `.vibes` root, and how big it is.
+ *
+ * WHY MEASUREMENT IS PART OF THE FIX. A user with 11GB in a dotfolder had no
+ * command to see it, so the growth was invisible until the disk was. `du -sh`
+ * is not an answer for a shipped product: it does not know which of those
+ * directories are caches you can safely lose, which are irreplaceable memory,
+ * and which are one-shot artifacts nobody owns.
+ *
+ * The dispositions below encode that judgement once, so both the report and any
+ * reclaim can act on the same classification rather than each inventing one.
+ */
+import { CaughtFailureSchema, isCapabilityError } from '@vibesdotdev/kernel';
+import { getPathRoots, PROJECT_STATE_DIRNAME } from '@vibesdotdev/paths';
+import { hostEntryKind, hostFileSystemOf, hostStat } from "../host-files.js";
+/**
+ * How a directory should be treated when space is needed.
+ *
+ * - `cache`: rebuildable from a network or a build. Safe to drop.
+ * - `rotatable`: append-only output with a retention rule of its own.
+ * - `state`: live data the running system needs. Never touched by a sweep.
+ * - `precious`: irreplaceable if lost — memory, identity, keys.
+ * - `artifact`: a one-shot output of some past operation, owned by nobody.
+ */
+/**
+ * Known dispositions, by top-level name inside a vibes home.
+ *
+ * Anything not listed is reported as `state` — the conservative default. A new
+ * directory should show up in the report as untouchable rather than be silently
+ * swept because nobody classified it.
+ */
+/** How one known top-level directory is treated. */
+export const ROOT_DISPOSITIONS = {
+    deps: { disposition: 'cache', note: 'downloaded dependencies; refetchable' },
+    venv: { disposition: 'cache', note: 'python virtualenv; rebuildable' },
+    opentui: { disposition: 'cache', note: 'built TUI assets' },
+    catalog: { disposition: 'cache', note: 'content-addressed chunk cache' },
+    atlas: { disposition: 'cache', note: 'derived code index' },
+    hot: { disposition: 'cache' },
+    logs: { disposition: 'rotatable', note: 'process + daemon logs' },
+    archive: { disposition: 'artifact', note: 'one-shot migration output' },
+    'preserved-patches': { disposition: 'artifact' },
+    'session-patches': { disposition: 'artifact' },
+    data: { disposition: 'artifact', note: 'reconciliation and provider dumps' },
+    backups: { disposition: 'precious', note: 'snapshot history; rotation policy applies' },
+    presence: { disposition: 'precious', note: 'inner world — irreplaceable' },
+    secrets: { disposition: 'precious' },
+    certs: { disposition: 'precious' },
+    bridge: { disposition: 'state', note: 'desktop runtime binaries' },
+    vessel: { disposition: 'state' },
+    sessions: { disposition: 'state' },
+    storage: { disposition: 'state' },
+    pm: { disposition: 'state' }
+};
+/** Known top-level directories by name (a Map: a directory named like an Object member is not known). */
+const DISPOSITION_BY_NAME = new Map(Object.entries(ROOT_DISPOSITIONS));
+/** The declared bounds of a root measurement. */
+export const DEFAULT_MEASURE_BOUNDS = { maxDepth: 64, maxEntries: 2_000_000, concurrency: 16 };
+/** A database file at a root: `*.db` and its `-wal` / `-shm` companions. */
+const ROOT_DATABASE = /\.db(-wal|-shm)?$/;
+/**
+ * A directory's entries, or none when it vanished. The host lists a directory
+ * and then stats each file, so a file deleted between the two (temporary
+ * files churn under a live home) fails the whole listing with a confirmed
+ * absence: the listing is retried once, and a second absence means the
+ * directory itself is gone (it contributes 0). Any other failure propagates.
+ */
+async function listIfPresent(fs, path) {
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            return await fs.list(path);
+        }
+        catch (error) {
+            const failure = CaughtFailureSchema.parse(error);
+            // Only the host's "no such entry" is a vanished entry; any other failure propagates.
+            if (!(failure instanceof Error && 'code' in failure && failure.code === 'ENOENT'))
+                throw error;
+            if (attempt >= 1)
+                return [];
+        }
+    }
+}
+/** Bytes under one top-level directory, walked with bounded concurrency; links are never followed. */
+async function walkDirectoryBytes(fs, start, bounds, budget) {
+    let total = 0;
+    const queue = [{ path: start, depth: 0 }];
+    const listOne = async (dir) => {
+        if (budget.truncated)
+            return;
+        if (dir.depth > bounds.maxDepth) {
+            budget.truncated = { bound: 'depth', limit: bounds.maxDepth };
+            return;
+        }
+        const entries = await listIfPresent(fs, dir.path);
+        for (const entry of entries) {
+            budget.visited += 1;
+            if (budget.visited > bounds.maxEntries) {
+                budget.truncated = { bound: 'entries', limit: bounds.maxEntries };
+                return;
+            }
+            // A link (nested node_modules links are everywhere here) is neither
+            // counted nor followed into another tree or a cycle.
+            if (entry.kind === 'directory')
+                queue.push({ path: fs.join(dir.path, entry.name), depth: dir.depth + 1 });
+            else if (entry.kind === 'file')
+                total += entry.sizeBytes ?? 0;
+        }
+    };
+    while (queue.length > 0 && !budget.truncated) {
+        const batch = queue.splice(0, bounds.concurrency);
+        await Promise.all(batch.map(listOne));
+    }
+    return total;
+}
+/**
+ * Measure one vibes home through the runtime's filesystem kind, within the
+ * declared bounds (depth, entries, concurrency). A root that does not exist
+ * contributes 0; an entry that cannot be read is a failure, not a zero; a walk
+ * that reaches a bound is marked `truncated`.
+ */
+export async function measureRoot(runtime, root, bounds = DEFAULT_MEASURE_BOUNDS) {
+    const fs = await hostFileSystemOf(runtime, 'retention-filesystem-unavailable');
+    const entries = [];
+    const databases = [];
+    const budget = { visited: 0 };
+    if ((await hostEntryKind(fs, root)) !== 'directory')
+        return { root, entries, databases, totalBytes: 0 };
+    for (const entry of await listIfPresent(fs, root)) {
+        const path = fs.join(root, entry.name);
+        if (entry.kind === 'symlink')
+            continue;
+        if (entry.kind === 'directory') {
+            const known = DISPOSITION_BY_NAME.get(entry.name);
+            const measured = {
+                name: entry.name,
+                path,
+                disposition: known?.disposition ?? 'state',
+                bytes: await walkDirectoryBytes(fs, path, bounds, budget)
+            };
+            if (known?.note)
+                measured.note = known.note;
+            entries.push(measured);
+            continue;
+        }
+        // A `-wal` can dwarf its database and is invisible to a naive listing.
+        if (ROOT_DATABASE.test(entry.name))
+            databases.push({ path, bytes: entry.sizeBytes ?? 0 });
+        else
+            entries.push({ name: entry.name, path, disposition: 'state', bytes: entry.sizeBytes ?? 0 });
+    }
+    entries.sort((a, b) => b.bytes - a.bytes);
+    databases.sort((a, b) => b.bytes - a.bytes);
+    const totalBytes = entries.reduce((sum, e) => sum + e.bytes, 0) + databases.reduce((sum, d) => sum + d.bytes, 0);
+    const measured = { root, entries, databases, totalBytes };
+    if (budget.truncated)
+        measured.truncated = budget.truncated;
+    return measured;
+}
+/**
+ * The SQLite databases sitting at a root (`*.db`, never their `-wal` / `-shm`
+ * companions), for the reclaim pass: one listing, no walk. A root that does
+ * not exist has none; links are not databases.
+ */
+export async function listRootDatabases(runtime, root) {
+    const fs = await hostFileSystemOf(runtime, 'retention-filesystem-unavailable');
+    return (await listIfPresent(fs, root))
+        .filter((entry) => entry.kind === 'file' && entry.name.endsWith('.db'))
+        .map((entry) => fs.join(root, entry.name))
+        .sort();
+}
+/**
+ * Every vibes home this runtime writes to.
+ *
+ * There is more than one, and that is itself part of the problem: the
+ * machine's vibes home plus the bound workspace's own `.vibes` state
+ * directory, each with its own `external.db` / `awareness.db` / `sessions.db`.
+ * A sweep that runs against one leaves the others, so a report that shows only
+ * one is misleading. Both come from the runtime the caller hands in: the home
+ * from `paths/roots`, the workspace from `runtime/workspace-path`. An unbound
+ * host has no workspace-local root; any other failure propagates.
+ */
+export async function resolveVibesRoots(runtime) {
+    const roots = new Set([getPathRoots(runtime).vibesHome]);
+    let workspaceRoot;
+    try {
+        workspaceRoot = await runtime.context('runtime/workspace-path');
+    }
+    catch (error) {
+        const failure = CaughtFailureSchema.parse(error);
+        // The workspace context's own absence (`NOT_FOUND`, details.id the context): an unbound host.
+        if (failure instanceof Error &&
+            isCapabilityError(failure) &&
+            failure.code === 'NOT_FOUND' &&
+            failure.details !== undefined &&
+            failure.details.id === 'runtime/workspace-path') {
+            return [...roots];
+        }
+        throw error;
+    }
+    const fs = await hostFileSystemOf(runtime, 'retention-filesystem-unavailable');
+    const workspaceLocal = fs.join(workspaceRoot, PROJECT_STATE_DIRNAME);
+    // A link is not a state root (`hostStat` does not follow it).
+    if ((await hostStat(fs, workspaceLocal))?.kind === 'directory')
+        roots.add(workspaceLocal);
+    return [...roots];
+}
+/** SQLite files under a root, for the reclaim pass. Excludes -wal/-shm sidecars. */
+export function databasePaths(measured) {
+    return measured.databases.filter((d) => d.path.endsWith('.db')).map((d) => d.path);
+}
+export function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    const units = ['K', 'M', 'G', 'T'];
+    let value = bytes / 1024;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit += 1;
+    }
+    return `${value.toFixed(value >= 10 ? 0 : 1)}${units[unit]}`;
+}
+//# sourceMappingURL=roots.js.map

package/dist/retention/roots.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"roots.js","sourceRoot":"","sources":["../../src/retention/roots.ts"],"names":[],"mappings":"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"}

package/dist/retention/scratch-custody.d.ts

@@ -0,0 +1,40 @@
+import * as z from 'zod/v4';
+export declare const ScratchCustodyInputSchema: z.ZodObject<{
+    root: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strip>;
+export declare const ScratchCustodyReceiptSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"held">;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"claimed">;
+    token: z.ZodString;
+    expiresAt: z.ZodNumber;
+}, z.core.$strip>], "status">;
+export declare const ScratchCustodySchema: z.ZodObject<{
+    acquire: z.ZodFunction<z.ZodTuple<readonly [z.ZodObject<{
+        root: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strip>], null>, z.ZodPromise<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"held">;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"claimed">;
+        token: z.ZodString;
+        expiresAt: z.ZodNumber;
+    }, z.core.$strip>], "status">>>;
+    release: z.ZodFunction<z.ZodTuple<readonly [z.ZodString], null>, z.ZodPromise<z.ZodVoid>>;
+}, z.core.$strip>;
+export type ScratchCustody = z.infer<typeof ScratchCustodySchema>;
+export declare const scratchCustodyKind: import("@vibesdotdev/kernel").RuntimeKindDescriptorRecord<{
+    acquire: z.core.$InferOuterFunctionType<z.ZodTuple<readonly [z.ZodObject<{
+        root: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strip>], null>, z.ZodPromise<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"held">;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"claimed">;
+        token: z.ZodString;
+        expiresAt: z.ZodNumber;
+    }, z.core.$strip>], "status">>>;
+    release: z.core.$InferOuterFunctionType<z.ZodTuple<readonly [z.ZodString], null>, z.ZodPromise<z.ZodVoid>>;
+}>;
+//# sourceMappingURL=scratch-custody.d.ts.map

package/dist/retention/scratch-custody.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratch-custody.d.ts","sourceRoot":"","sources":["../../src/retention/scratch-custody.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAG5B,eAAO,MAAM,yBAAyB;;;iBAAiE,CAAC;AACxG,eAAO,MAAM,2BAA2B;;;;;;6BAGtC,CAAC;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;iBAG/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAE7B,CAAC"}

package/dist/retention/scratch-custody.js

@@ -0,0 +1,15 @@
+import * as z from 'zod/v4';
+import { createRuntimeKind, RuntimeDescriptorSchema } from '@vibesdotdev/kernel';
+export const ScratchCustodyInputSchema = z.object({ root: z.string().min(1), path: z.string().min(1) });
+export const ScratchCustodyReceiptSchema = z.discriminatedUnion('status', [
+    z.object({ status: z.literal('held') }),
+    z.object({ status: z.literal('claimed'), token: z.string().uuid(), expiresAt: z.number().int().positive() })
+]);
+export const ScratchCustodySchema = z.object({
+    acquire: z.function({ input: [ScratchCustodyInputSchema], output: z.promise(ScratchCustodyReceiptSchema) }),
+    release: z.function({ input: [z.string().uuid()], output: z.promise(z.void()) })
+});
+export const scratchCustodyKind = createRuntimeKind({
+    id: 'storage/scratch-custody', descriptorSchema: RuntimeDescriptorSchema
+});
+//# sourceMappingURL=scratch-custody.js.map

package/dist/retention/scratch-custody.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratch-custody.js","sourceRoot":"","sources":["../../src/retention/scratch-custody.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,iBAAiB,EAAE,uBAAuB,EAA0B,MAAM,qBAAqB,CAAC;AAEzG,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;AACxG,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,CAAC,kBAAkB,CAAC,QAAQ,EAAE;IACzE,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;IACvC,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC;CAC5G,CAAC,CAAC;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5C,OAAO,EAAE,CAAC,CAAC,QAAQ,CAAC,EAAE,KAAK,EAAE,CAAC,yBAAyB,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,2BAA2B,CAAC,EAAE,CAAC;IAC3G,OAAO,EAAE,CAAC,CAAC,QAAQ,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC;CAChF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,kBAAkB,GAAG,iBAAiB,CAAoC;IACtF,EAAE,EAAE,yBAAyB,EAAE,gBAAgB,EAAE,uBAAuB;CACxE,CAAC,CAAC"}

package/dist/retention/startup-sweep.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Explicit capacity-aware retention sweep.
+ *
+ * Host activation does not call this operation. Callers must deliberately
+ * choose retention; the Workers schedule is disabled by default. The stamp is
+ * written before a sweep so an interrupted pass respects its declared interval.
+ */
+import { sweepDeclaredRetention, type RetentionRuntime } from './sweep.ts';
+import { type CapacityReader, type VolumeCapacity } from './capacity.ts';
+/**
+ * Once every six hours. Matched to the same cadence the file-access enforcer
+ * already used, so the two do not need separate reasoning. While the volume is
+ * low on capacity the debounce drops to `LOW_CAPACITY_SWEEP_INTERVAL_MS`.
+ */
+export declare const STARTUP_SWEEP_INTERVAL_MS: number;
+/**
+ * Epoch ms of the last sweep, or 0 when there has never been one (no stamp
+ * file) or the stamp is unreadable as a number. Any other read failure throws.
+ * Read through the runtime's host filesystem kind.
+ */
+export declare function readSweepStamp(runtime: RetentionRuntime, stampPath: string): Promise<number>;
+/**
+ * Write the stamp. A stamp that cannot be written means sweeping more often
+ * than intended — wasteful, not wrong — so the failure is reported to the
+ * runtime's Logging with its cause rather than failing activation.
+ */
+export declare function writeSweepStamp(runtime: RetentionRuntime, stampPath: string, at: number): Promise<void>;
+export declare function sweepIsDue(lastAt: number, now: number, intervalMs: number): boolean;
+export interface StartupSweepOptions {
+    runtime: RetentionRuntime;
+    /** Directory holding the stamp. Defaults to the runtime's `vibesHome` path root. */
+    stampDir?: string;
+    intervalMs?: number;
+    now?: number;
+    /** Run even if the stamp says it is not due. */
+    force?: boolean;
+    /** Reads the stamp volume's capacity. Defaults to the host filesystem's `volumeCapacity`; tests plant a volume. */
+    readCapacity?: CapacityReader;
+}
+/**
+ * The debounce that applies given the volume's capacity: the declared interval
+ * on a healthy volume, never longer than `LOW_CAPACITY_SWEEP_INTERVAL_MS` on a
+ * low one.
+ */
+export declare function effectiveSweepIntervalMs(intervalMs: number, capacity: VolumeCapacity | undefined): number;
+/**
+ * Run a retention sweep if one is due, gated by time and by disk capacity.
+ *
+ * Returns the sweep result, or `null` when it was skipped (not due, not a
+ * consumer host, no records). A stamp or capacity read that fails refuses
+ * `UNAVAILABLE retention-preflight-failed` before anything is stamped; a sweep
+ * that fails after the stamp refuses `INTERNAL retention-sweep-failed`; each
+ * carries its cause. The caller owns the decision to run this operation and
+ * receives any refusal.
+ */
+export declare function runStartupSweepIfDue(options: StartupSweepOptions): Promise<Awaited<ReturnType<typeof sweepDeclaredRetention>> | null>;
+//# sourceMappingURL=startup-sweep.d.ts.map

package/dist/retention/startup-sweep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"startup-sweep.d.ts","sourceRoot":"","sources":["../../src/retention/startup-sweep.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAOH,OAAO,EAAE,sBAAsB,EAAE,KAAK,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC3E,OAAO,EAKN,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,MAAM,eAAe,CAAC;AAEvB;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,QAAqB,CAAC;AAI5D;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAMlG;AAED;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAa7G;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAKnF;AAED,MAAM,WAAW,mBAAmB;IACnC,OAAO,EAAE,gBAAgB,CAAC;IAC1B,oFAAoF;IACpF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,gDAAgD;IAChD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,mHAAmH;IACnH,YAAY,CAAC,EAAE,cAAc,CAAC;CAC9B;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,SAAS,GAAG,MAAM,CAGzG;AAED;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,mBAAmB,GAC1B,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC,GAAG,IAAI,CAAC,CAuDpE"}

package/dist/retention/startup-sweep.js

@@ -0,0 +1,137 @@
+/**
+ * Explicit capacity-aware retention sweep.
+ *
+ * Host activation does not call this operation. Callers must deliberately
+ * choose retention; the Workers schedule is disabled by default. The stamp is
+ * written before a sweep so an interrupted pass respects its declared interval.
+ */
+import { getLogger } from '@vibesdotdev/logging';
+import { getPathRoots } from '@vibesdotdev/paths';
+import { CapabilityError, CaughtFailureSchema, valueFreeFailure } from '@vibesdotdev/kernel';
+import { hostFileSystemOf, hostReadTextIfPresent } from "../host-files.js";
+import { sweepDeclaredRetention } from "./sweep.js";
+import { hostCapacityReader, isCapacityLow, LOW_CAPACITY_SWEEP_INTERVAL_MS, readCapacityIfPresent } from "./capacity.js";
+/**
+ * Once every six hours. Matched to the same cadence the file-access enforcer
+ * already used, so the two do not need separate reasoning. While the volume is
+ * low on capacity the debounce drops to `LOW_CAPACITY_SWEEP_INTERVAL_MS`.
+ */
+export const STARTUP_SWEEP_INTERVAL_MS = 6 * 60 * 60 * 1000;
+const STAMP_FILENAME = '.retention-sweep';
+/**
+ * Epoch ms of the last sweep, or 0 when there has never been one (no stamp
+ * file) or the stamp is unreadable as a number. Any other read failure throws.
+ * Read through the runtime's host filesystem kind.
+ */
+export async function readSweepStamp(runtime, stampPath) {
+    const fs = await hostFileSystemOf(runtime, 'retention-filesystem-unavailable');
+    const text = await hostReadTextIfPresent(fs, stampPath);
+    if (text === undefined)
+        return 0;
+    const parsed = Number(text.trim());
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+/**
+ * Write the stamp. A stamp that cannot be written means sweeping more often
+ * than intended — wasteful, not wrong — so the failure is reported to the
+ * runtime's Logging with its cause rather than failing activation.
+ */
+export async function writeSweepStamp(runtime, stampPath, at) {
+    const logger = getLogger('storage:retention', runtime);
+    try {
+        const fs = await hostFileSystemOf(runtime, 'retention-filesystem-unavailable');
+        await fs.mkdir(fs.dirname(stampPath), { recursive: true });
+        await fs.writeFile(stampPath, String(at));
+    }
+    catch (error) {
+        logger.warn('Retention sweep stamp could not be written; sweeps may run more often than intended', {
+            reason: 'retention-stamp-unwritable',
+            stampPath,
+            error: valueFreeFailure(CaughtFailureSchema.parse(error))
+        });
+    }
+}
+export function sweepIsDue(lastAt, now, intervalMs) {
+    // A stamp from the future (clock moved backwards) must not park the sweep
+    // indefinitely.
+    if (lastAt > now)
+        return true;
+    return now - lastAt >= intervalMs;
+}
+/**
+ * The debounce that applies given the volume's capacity: the declared interval
+ * on a healthy volume, never longer than `LOW_CAPACITY_SWEEP_INTERVAL_MS` on a
+ * low one.
+ */
+export function effectiveSweepIntervalMs(intervalMs, capacity) {
+    if (!capacity || !isCapacityLow(capacity))
+        return intervalMs;
+    return Math.min(intervalMs, LOW_CAPACITY_SWEEP_INTERVAL_MS);
+}
+/**
+ * Run a retention sweep if one is due, gated by time and by disk capacity.
+ *
+ * Returns the sweep result, or `null` when it was skipped (not due, not a
+ * consumer host, no records). A stamp or capacity read that fails refuses
+ * `UNAVAILABLE retention-preflight-failed` before anything is stamped; a sweep
+ * that fails after the stamp refuses `INTERNAL retention-sweep-failed`; each
+ * carries its cause. The caller owns the decision to run this operation and
+ * receives any refusal.
+ */
+export async function runStartupSweepIfDue(options) {
+    const runtime = options.runtime;
+    const logger = getLogger('storage:retention', runtime);
+    // Cloud hosts do not own a consumer-local `.vibes`; their tables have their
+    // own operational retention.
+    if (runtime.scope?.hardware !== 'consumer')
+        return null;
+    if (!runtime.hasKind('storage/record'))
+        return null;
+    const now = options.now ?? Date.now();
+    const intervalMs = options.intervalMs ?? STARTUP_SWEEP_INTERVAL_MS;
+    let stampDir;
+    let stampPath;
+    let capacity;
+    let lastAt = 0;
+    try {
+        const fs = await hostFileSystemOf(runtime, 'retention-filesystem-unavailable');
+        stampDir = options.stampDir ?? getPathRoots(runtime).vibesHome;
+        stampPath = fs.join(stampDir, STAMP_FILENAME);
+        capacity = await readCapacityIfPresent(stampDir, options.readCapacity ?? hostCapacityReader(runtime));
+        if (!options.force)
+            lastAt = await readSweepStamp(runtime, stampPath);
+    }
+    catch (error) {
+        throw new CapabilityError('The startup retention sweep could not read its stamp or volume capacity; nothing was swept.', 'UNAVAILABLE', {
+            reason: 'retention-preflight-failed',
+            retryable: true,
+            cause: CaughtFailureSchema.parse(error)
+        });
+    }
+    const low = capacity !== undefined && isCapacityLow(capacity);
+    if (!options.force && !sweepIsDue(lastAt, now, effectiveSweepIntervalMs(intervalMs, capacity))) {
+        return null;
+    }
+    if (low && !sweepIsDue(lastAt, now, intervalMs)) {
+        logger.warn('Disk capacity is low; running retention out of cycle', {
+            reason: 'storage-capacity-low',
+            stampDir,
+            freeBytes: capacity.freeBytes,
+            totalBytes: capacity.totalBytes
+        });
+    }
+    // Stamp first: a sweep that dies mid-run costs one interval, not a DELETE in
+    // front of every subsequent command.
+    await writeSweepStamp(runtime, stampPath, now);
+    try {
+        return await sweepDeclaredRetention({ runtime, now });
+    }
+    catch (error) {
+        throw new CapabilityError('The startup retention sweep failed after its stamp was written.', 'INTERNAL', {
+            reason: 'retention-sweep-failed',
+            retryable: true,
+            cause: CaughtFailureSchema.parse(error)
+        });
+    }
+}
+//# sourceMappingURL=startup-sweep.js.map

package/dist/retention/startup-sweep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"startup-sweep.js","sourceRoot":"","sources":["../../src/retention/startup-sweep.ts"],"names":[],"mappings":"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"}

package/dist/retention/storage.retention-sweep.descriptor.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Storage Retention Sweep Job Descriptor
+ *
+ * The generic enforcer for every `retention:` policy a `storage/record`
+ * declares. See `sweep.ts` for why this is generic rather than one job per
+ * table.
+ */
+export declare const storageRetentionSweepJobDescriptor: {
+    kind: "workers/job";
+    id: string;
+    name: string;
+    description: string;
+    queue: string;
+    dispatch: "background";
+    type: "scheduled";
+    schedule: string;
+    scheduleEnabled: boolean;
+    retries: {
+        maxAttempts: number;
+        backoff: "exponential";
+        delay: number;
+    };
+    isolation: "inline";
+    hardware: readonly ["consumer"];
+    schemas: {
+        input: import("zod/v4").ZodObject<{
+            dryRun: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+            recordId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            now: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
+            reclaim: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+        }, import("zod/v4/core").$strip>;
+        output: import("zod/v4").ZodObject<{
+            success: import("zod/v4").ZodBoolean;
+            dryRun: import("zod/v4").ZodBoolean;
+            examined: import("zod/v4").ZodNumber;
+            undeclared: import("zod/v4").ZodArray<import("zod/v4").ZodString>;
+            records: import("zod/v4").ZodArray<import("zod/v4").ZodObject<{
+                recordId: import("zod/v4").ZodString;
+                tableName: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                deletedByAge: import("zod/v4").ZodNumber;
+                deletedByCount: import("zod/v4").ZodNumber;
+                skipped: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                error: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+            totalDeleted: import("zod/v4").ZodNumber;
+            reclaimedBytes: import("zod/v4").ZodNumber;
+            tmp: import("zod/v4").ZodOptional<import("zod/v4").ZodObject<{
+                roots: import("zod/v4").ZodArray<import("zod/v4").ZodObject<{
+                    root: import("zod/v4").ZodString;
+                    scanned: import("zod/v4").ZodNumber;
+                    deleted: import("zod/v4").ZodNumber;
+                    bytesReclaimed: import("zod/v4").ZodNumber;
+                    candidates: import("zod/v4").ZodArray<import("zod/v4").ZodObject<{
+                        path: import("zod/v4").ZodString;
+                        bytes: import("zod/v4").ZodNumber;
+                        modifiedAt: import("zod/v4").ZodNumber;
+                    }, import("zod/v4/core").$strip>>;
+                    candidateBytes: import("zod/v4").ZodNumber;
+                    kept: import("zod/v4").ZodArray<import("zod/v4").ZodObject<{
+                        path: import("zod/v4").ZodString;
+                        reason: import("zod/v4").ZodString;
+                    }, import("zod/v4/core").$strip>>;
+                    skipped: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                    failure: import("zod/v4").ZodOptional<import("zod/v4").ZodObject<{
+                        name: import("zod/v4").ZodString;
+                        code: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                        reason: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                    }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$strip>>;
+                deleted: import("zod/v4").ZodNumber;
+                bytesReclaimed: import("zod/v4").ZodNumber;
+                candidates: import("zod/v4").ZodNumber;
+                candidateBytes: import("zod/v4").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
+            error: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        }, import("zod/v4/core").$strip>;
+    };
+    tags: string[];
+    enabled: true;
+};
+export default storageRetentionSweepJobDescriptor;
+//# sourceMappingURL=storage.retention-sweep.descriptor.d.ts.map

package/dist/retention/storage.retention-sweep.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.retention-sweep.descriptor.d.ts","sourceRoot":"","sources":["../../src/retention/storage.retention-sweep.descriptor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAQH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiC7C,CAAC;AAEH,eAAe,kCAAkC,CAAC"}

package/dist/retention/storage.retention-sweep.descriptor.js

@@ -0,0 +1,42 @@
+/**
+ * Storage Retention Sweep Job Descriptor
+ *
+ * The generic enforcer for every `retention:` policy a `storage/record`
+ * declares. See `sweep.ts` for why this is generic rather than one job per
+ * table.
+ */
+import { createRuntimeAsset } from '@vibesdotdev/kernel';
+import { RetentionSweepJobInputSchema, RetentionSweepJobOutputSchema } from "./storage.retention-sweep.schema.js";
+export const storageRetentionSweepJobDescriptor = createRuntimeAsset({
+    kind: 'workers/job',
+    id: 'storage.retention-sweep',
+    name: 'Storage Retention Sweep',
+    description: 'Enforce every retention policy declared on a storage/record descriptor',
+    // Workers derives a consumer for this declared queue. Reclaim must not
+    // wait behind occupied awareness/maintenance execution slots.
+    queue: 'storage-retention-jobs',
+    dispatch: 'background',
+    type: 'scheduled',
+    // 03:30, before the awareness jobs at 04:10/04:40 and after the queue clean
+    // at 03:15. Row removal first, reclaim afterwards.
+    schedule: '30 3 * * *',
+    // Automatic deletion is opt-in; the job remains available for explicit runs.
+    scheduleEnabled: false,
+    retries: {
+        maxAttempts: 2,
+        backoff: 'exponential',
+        delay: 5_000
+    },
+    isolation: 'inline',
+    // Consumer-only: this bounds a laptop's `.vibes`. Cloud tables have their
+    // own operational retention and are not this job's to touch.
+    hardware: ['consumer'],
+    schemas: {
+        input: RetentionSweepJobInputSchema,
+        output: RetentionSweepJobOutputSchema
+    },
+    tags: ['storage', 'retention', 'housekeeping'],
+    enabled: true
+});
+export default storageRetentionSweepJobDescriptor;
+//# sourceMappingURL=storage.retention-sweep.descriptor.js.map

package/dist/retention/storage.retention-sweep.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.retention-sweep.descriptor.js","sourceRoot":"","sources":["../../src/retention/storage.retention-sweep.descriptor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EACN,4BAA4B,EAC5B,6BAA6B,EAC7B,MAAM,qCAAqC,CAAC;AAE7C,MAAM,CAAC,MAAM,kCAAkC,GAAG,kBAAkB,CAAC;IACpE,IAAI,EAAE,aAAa;IACnB,EAAE,EAAE,yBAAyB;IAC7B,IAAI,EAAE,yBAAyB;IAC/B,WAAW,EAAE,wEAAwE;IAErF,uEAAuE;IACvE,8DAA8D;IAC9D,KAAK,EAAE,wBAAwB;IAC/B,QAAQ,EAAE,YAAqB;IAC/B,IAAI,EAAE,WAAoB;IAC1B,4EAA4E;IAC5E,mDAAmD;IACnD,QAAQ,EAAE,YAAY;IACtB,6EAA6E;IAC7E,eAAe,EAAE,KAAK;IACtB,OAAO,EAAE;QACR,WAAW,EAAE,CAAC;QACd,OAAO,EAAE,aAAsB;QAC/B,KAAK,EAAE,KAAK;KACZ;IACD,SAAS,EAAE,QAAiB;IAC5B,0EAA0E;IAC1E,6DAA6D;IAC7D,QAAQ,EAAE,CAAC,UAAU,CAAU;IAE/B,OAAO,EAAE;QACR,KAAK,EAAE,4BAA4B;QACnC,MAAM,EAAE,6BAA6B;KACrC;IAED,IAAI,EAAE,CAAC,SAAS,EAAE,WAAW,EAAE,cAAc,CAAC;IAC9C,OAAO,EAAE,IAAI;CACb,CAAC,CAAC;AAEH,eAAe,kCAAkC,CAAC"}