@vibesdotdev/storage 0.0.1 → 1.0.0-rc.3

package/dist/backup/backup.plugin.d.ts

@@ -0,0 +1,276 @@
+/**
+ * Backup Plugin
+ *
+ * Snapshot infrastructure for irreplaceable agent data.
+ *
+ * Registers:
+ *  - `backup/target` + `backup/recovery-plan` runtime kinds
+ *  - `backup.snapshot` storage record (provenance log)
+ *  - 4 default targets (presence.inner, presence.identity, awareness.bus, storage.records)
+ *  - `backup.snapshot` worker job
+ */
+export { registerBackupChannels } from "./channels/backup.channel.ts";
+/** The plugins a host must have registered before backup composes. */
+export declare const BACKUP_PLUGIN_DEPENDENCIES: readonly ["@vibesdotdev/paths", "@vibesdotdev/storage/adapters/localdb"];
+export declare const backupKinds: readonly [import("@vibesdotdev/kernel").RuntimeKindDescriptorRecord<{}>, import("@vibesdotdev/kernel").RuntimeKindDescriptorRecord<{}>, import("@vibesdotdev/kernel").RuntimeKindDescriptorRecord<{}>];
+export declare const backupDescriptors: readonly [{
+    kind: "docs/topic";
+    id: string;
+    title: string;
+    summary: string;
+    body: {
+        type: "markdown";
+        sourceType: "raw";
+        source: string;
+    };
+    parent: string;
+    order: number;
+    tags: string[];
+    surfaces: readonly ["cli", "in-app"];
+    hardware: readonly ["consumer", "cloud"];
+    enabled: boolean;
+}, import("../index.ts").StorageRecordDescriptorInput, {
+    kind: "backup/target";
+    id: string;
+    name: string;
+    owner: string;
+    source: {
+        kind: "file" | "directory" | "sqlite";
+        path: string;
+        sidecars: string[];
+        required: boolean;
+        agentHomes?: {
+            root: string;
+            marker: string;
+        } | undefined;
+    };
+    rotation: {
+        keepDaily: number;
+        keepWeekly: number;
+        keepMonthly: number;
+        keepForever: boolean;
+    };
+    verify: {
+        requiredTables: string[];
+        minRows?: number | undefined;
+    };
+    tags: string[];
+    enabled: boolean;
+    description?: string | undefined;
+    destinationDir?: string | undefined;
+    preflight?: string[] | undefined;
+}, {
+    kind: "backup/target";
+    id: string;
+    name: string;
+    owner: string;
+    source: {
+        kind: "file" | "directory" | "sqlite";
+        path: string;
+        sidecars: string[];
+        required: boolean;
+        agentHomes?: {
+            root: string;
+            marker: string;
+        } | undefined;
+    };
+    rotation: {
+        keepDaily: number;
+        keepWeekly: number;
+        keepMonthly: number;
+        keepForever: boolean;
+    };
+    verify: {
+        requiredTables: string[];
+        minRows?: number | undefined;
+    };
+    tags: string[];
+    enabled: boolean;
+    description?: string | undefined;
+    destinationDir?: string | undefined;
+    preflight?: string[] | undefined;
+}, {
+    kind: "backup/target";
+    id: string;
+    name: string;
+    owner: string;
+    source: {
+        kind: "file" | "directory" | "sqlite";
+        path: string;
+        sidecars: string[];
+        required: boolean;
+        agentHomes?: {
+            root: string;
+            marker: string;
+        } | undefined;
+    };
+    rotation: {
+        keepDaily: number;
+        keepWeekly: number;
+        keepMonthly: number;
+        keepForever: boolean;
+    };
+    verify: {
+        requiredTables: string[];
+        minRows?: number | undefined;
+    };
+    tags: string[];
+    enabled: boolean;
+    description?: string | undefined;
+    destinationDir?: string | undefined;
+    preflight?: string[] | undefined;
+}, {
+    kind: "backup/target";
+    id: string;
+    name: string;
+    owner: string;
+    source: {
+        kind: "file" | "directory" | "sqlite";
+        path: string;
+        sidecars: string[];
+        required: boolean;
+        agentHomes?: {
+            root: string;
+            marker: string;
+        } | undefined;
+    };
+    rotation: {
+        keepDaily: number;
+        keepWeekly: number;
+        keepMonthly: number;
+        keepForever: boolean;
+    };
+    verify: {
+        requiredTables: string[];
+        minRows?: number | undefined;
+    };
+    tags: string[];
+    enabled: boolean;
+    description?: string | undefined;
+    destinationDir?: string | undefined;
+    preflight?: string[] | undefined;
+}, {
+    kind: "workers/job";
+    id: string;
+    name: string;
+    description: string;
+    queue: string;
+    dispatch: "background";
+    type: "progress";
+    retries: {
+        maxAttempts: number;
+        backoff: "exponential";
+        delay: number;
+    };
+    isolation: "inline";
+    hardware: readonly ["consumer"];
+    schemas: {
+        input: import("zod/v4").ZodObject<{
+            targetId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            skipHash: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+            dryRun: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+        }, import("zod/v4/core").$strip>;
+        output: import("zod/v4").ZodObject<{
+            success: import("zod/v4").ZodBoolean;
+            targetsAttempted: import("zod/v4").ZodNumber;
+            targetsSucceeded: import("zod/v4").ZodNumber;
+            targetsFailed: import("zod/v4").ZodNumber;
+            targetsEmpty: import("zod/v4").ZodDefault<import("zod/v4").ZodNumber>;
+            results: import("zod/v4").ZodArray<import("zod/v4").ZodObject<{
+                targetId: import("zod/v4").ZodString;
+                snapshotId: import("zod/v4").ZodString;
+                status: import("zod/v4").ZodEnum<{
+                    success: "success";
+                    failed: "failed";
+                    pending: "pending";
+                    verified: "verified";
+                    pruned: "pruned";
+                    empty: "empty";
+                }>;
+                files: import("zod/v4").ZodArray<import("zod/v4").ZodObject<{
+                    path: import("zod/v4").ZodString;
+                    bytes: import("zod/v4").ZodNumber;
+                    sha256: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                    source: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+                rowCount: import("zod/v4").ZodNullable<import("zod/v4").ZodNumber>;
+                durationMs: import("zod/v4").ZodNumber;
+                error: import("zod/v4").ZodNullable<import("zod/v4").ZodString>;
+                home: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+                notices: import("zod/v4").ZodDefault<import("zod/v4").ZodArray<import("zod/v4").ZodObject<{
+                    preflight: import("zod/v4").ZodString;
+                    code: import("zod/v4").ZodString;
+                    reason: import("zod/v4").ZodString;
+                    message: import("zod/v4").ZodString;
+                }, import("zod/v4/core").$strip>>>;
+                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>>;
+            rotation: import("zod/v4").ZodDefault<import("zod/v4").ZodArray<import("zod/v4").ZodObject<{
+                targetId: import("zod/v4").ZodString;
+                home: import("zod/v4").ZodNullable<import("zod/v4").ZodString>;
+                destDir: import("zod/v4").ZodString;
+                applied: import("zod/v4").ZodBoolean;
+                kept: import("zod/v4").ZodNumber;
+                prunedSnapshots: import("zod/v4").ZodNumber;
+                pruneBytes: import("zod/v4").ZodNumber;
+                staleStaging: import("zod/v4").ZodNumber;
+                stagingBytes: import("zod/v4").ZodNumber;
+                skipped: import("zod/v4").ZodArray<import("zod/v4").ZodObject<{
+                    snapshotId: import("zod/v4").ZodString;
+                    reason: import("zod/v4").ZodString;
+                }, import("zod/v4/core").$strip>>;
+                failures: import("zod/v4").ZodDefault<import("zod/v4").ZodArray<import("zod/v4").ZodObject<{
+                    path: import("zod/v4").ZodString;
+                    reason: import("zod/v4").ZodString;
+                }, import("zod/v4/core").$strip>>>;
+                error: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            }, import("zod/v4/core").$strip>>>;
+            error: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        }, import("zod/v4/core").$strip>;
+    };
+    tags: string[];
+    enabled: true;
+}, {
+    kind: "config/manifest";
+    id: string;
+    name: string;
+    namespace: string;
+    description: string;
+    tier: string;
+    category: string;
+    schema: import("zod/v4").ZodObject<{
+        backupCron: import("zod/v4").ZodDefault<import("zod/v4").ZodString>;
+    }, import("zod/v4/core").$strip>;
+    fields: {
+        backupCron: {
+            ui: {
+                label: string;
+                description: string;
+                component: string;
+                group: string;
+            };
+        };
+    };
+    groups: {
+        id: string;
+        label: string;
+    }[];
+    allowedAdapters: string[];
+    defaultAdapter: string;
+    scope: string;
+    customTables: boolean;
+    version: number;
+    internal: boolean;
+    context: {
+        surfaces: string[];
+    };
+    enabled: true;
+}];
+export declare const backupLoaders: readonly [import("@vibesdotdev/kernel").AssetLoader];
+declare const _default: import("@vibesdotdev/kernel").RuntimePlugin;
+export default _default;
+//# sourceMappingURL=backup.plugin.d.ts.map

package/dist/backup/backup.plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backup.plugin.d.ts","sourceRoot":"","sources":["../../src/backup/backup.plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAoBH,OAAO,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAEtE,sEAAsE;AACtE,eAAO,MAAM,0BAA0B,0EAG7B,CAAC;AAEX,eAAO,MAAM,WAAW,wMAA2E,CAAC;AAEpG,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcpB,CAAC;AAEX,eAAO,MAAM,aAAa,sDAMhB,CAAC;;AAEX,wBAqBG"}

package/dist/backup/backup.plugin.js

@@ -0,0 +1,72 @@
+/**
+ * Backup Plugin
+ *
+ * Snapshot infrastructure for irreplaceable agent data.
+ *
+ * Registers:
+ *  - `backup/target` + `backup/recovery-plan` runtime kinds
+ *  - `backup.snapshot` storage record (provenance log)
+ *  - 4 default targets (presence.inner, presence.identity, awareness.bus, storage.records)
+ *  - `backup.snapshot` worker job
+ */
+import { createRuntimePlugin, loader } from "@vibesdotdev/kernel";
+import { backupTargetKind } from "./kinds/backup-target.kind.js";
+import { backupRecoveryPlanKind } from "./kinds/backup-recovery-plan.kind.js";
+import { backupPreflightKind } from "./kinds/backup-preflight.kind.js";
+import backupSnapshotRecordDescriptor from "./storage/snapshot.record.descriptor.js";
+import backupDisasterRecoveryDocsDescriptor from "./docs/backup.disaster-recovery.docs.descriptor.js";
+import presenceInnerTargetDescriptor from "./targets/presence-inner.target.descriptor.js";
+import presenceIdentityTargetDescriptor from "./targets/presence-identity.target.descriptor.js";
+import awarenessBusTargetDescriptor from "./targets/awareness-bus.target.descriptor.js";
+import storageRecordsTargetDescriptor from "./targets/storage-records.target.descriptor.js";
+import backupSnapshotJobDescriptor from "./jobs/backup.snapshot.descriptor.js";
+import storageBackupConfigDescriptor from "./config/storage.backup.config.descriptor.js";
+import { registerBackupChannels } from "./channels/backup.channel.js";
+export { registerBackupChannels } from "./channels/backup.channel.js";
+/** The plugins a host must have registered before backup composes. */
+export const BACKUP_PLUGIN_DEPENDENCIES = [
+    "@vibesdotdev/paths",
+    "@vibesdotdev/storage/adapters/localdb",
+];
+export const backupKinds = [backupTargetKind, backupRecoveryPlanKind, backupPreflightKind];
+export const backupDescriptors = [
+    // Discoverability
+    backupDisasterRecoveryDocsDescriptor,
+    // Storage (provenance)
+    backupSnapshotRecordDescriptor,
+    // Default targets
+    presenceInnerTargetDescriptor,
+    presenceIdentityTargetDescriptor,
+    awarenessBusTargetDescriptor,
+    storageRecordsTargetDescriptor,
+    // Worker
+    backupSnapshotJobDescriptor,
+    // Settings (daily snapshot cron); held until `config/manifest` registers.
+    storageBackupConfigDescriptor,
+];
+export const backupLoaders = [
+    loader("backup.snapshot", { kind: "workers/job" }, () => import("./jobs/backup.snapshot.impl.js")),
+];
+export default createRuntimePlugin({
+    id: "backup",
+    name: "Backup",
+    description: "Snapshot infrastructure plus declarative disaster-recovery contracts and drill evidence",
+    // Snapshots read and write consumer-local files and keep provenance in
+    // localdb (`backup.db`); a host without both cannot run them.
+    dependencies: [...BACKUP_PLUGIN_DEPENDENCIES],
+    kinds: [...backupKinds],
+    descriptors: [...backupDescriptors],
+    loaders: [...backupLoaders],
+    onActivate: async (runtime) => {
+        // Register the daily snapshot channel's global os/channels row so a PM
+        // scheduler fires it once a day. Activation owns side effects; import and
+        // registration stay declarative. A host without the os plugin has no
+        // channel scheduler, so there is nothing to schedule on; the hosts that
+        // schedule (the PM daemon) compose os. Configuration never fails this:
+        // the schedule falls back to the declared default and reports why.
+        if (!runtime.hasPlugin("os"))
+            return;
+        await registerBackupChannels(runtime);
+    },
+});
+//# sourceMappingURL=backup.plugin.js.map

package/dist/backup/backup.plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backup.plugin.js","sourceRoot":"","sources":["../../src/backup/backup.plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElE,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AAC9E,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,8BAA8B,MAAM,yCAAyC,CAAC;AACrF,OAAO,oCAAoC,MAAM,oDAAoD,CAAC;AAEtG,OAAO,6BAA6B,MAAM,+CAA+C,CAAC;AAC1F,OAAO,gCAAgC,MAAM,kDAAkD,CAAC;AAChG,OAAO,4BAA4B,MAAM,8CAA8C,CAAC;AACxF,OAAO,8BAA8B,MAAM,gDAAgD,CAAC;AAE5F,OAAO,2BAA2B,MAAM,sCAAsC,CAAC;AAC/E,OAAO,6BAA6B,MAAM,8CAA8C,CAAC;AAEzF,OAAO,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAEtE,OAAO,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAEtE,sEAAsE;AACtE,MAAM,CAAC,MAAM,0BAA0B,GAAG;IACxC,oBAAoB;IACpB,uCAAuC;CAC/B,CAAC;AAEX,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,gBAAgB,EAAE,sBAAsB,EAAE,mBAAmB,CAAU,CAAC;AAEpG,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,kBAAkB;IAClB,oCAAoC;IACpC,uBAAuB;IACvB,8BAA8B;IAC9B,kBAAkB;IAClB,6BAA6B;IAC7B,gCAAgC;IAChC,4BAA4B;IAC5B,8BAA8B;IAC9B,SAAS;IACT,2BAA2B;IAC3B,0EAA0E;IAC1E,6BAA6B;CACrB,CAAC;AAEX,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,MAAM,CACJ,iBAAiB,EACjB,EAAE,IAAI,EAAE,aAAa,EAAE,EACvB,GAAG,EAAE,CAAC,MAAM,CAAC,gCAAgC,CAAC,CAC/C;CACO,CAAC;AAEX,eAAe,mBAAmB,CAAC;IACjC,EAAE,EAAE,QAAQ;IACZ,IAAI,EAAE,QAAQ;IACd,WAAW,EACT,yFAAyF;IAC3F,uEAAuE;IACvE,8DAA8D;IAC9D,YAAY,EAAE,CAAC,GAAG,0BAA0B,CAAC;IAC7C,KAAK,EAAE,CAAC,GAAG,WAAW,CAAC;IACvB,WAAW,EAAE,CAAC,GAAG,iBAAiB,CAAC;IACnC,OAAO,EAAE,CAAC,GAAG,aAAa,CAAC;IAC3B,UAAU,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;QAC5B,uEAAuE;QACvE,0EAA0E;QAC1E,qEAAqE;QACrE,wEAAwE;QACxE,uEAAuE;QACvE,mEAAmE;QACnE,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC;YAAE,OAAO;QACrC,MAAM,sBAAsB,CAAC,OAAO,CAAC,CAAC;IACxC,CAAC;CACF,CAAC,CAAC"}

package/dist/backup/channels/backup.channel.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Backup channel registration.
+ *
+ * Registers `backup.daily` with os/channels as a `user` channel: one global
+ * row, fired once per occurrence across every runtime that schedules it. Fires
+ * `vibes backup now` on the `storage.backup` manifest's `backupCron` (default
+ * `30 3 * * *`) so snapshots happen even when the agent isn't actively in
+ * session.
+ */
+import { type RuntimeRef } from "@vibesdotdev/kernel";
+import type { ChannelRegistryRuntime } from "@vibesdotdev/os/channels";
+/** The activating runtime: its channel state, its config client and its Logging. */
+type BackupChannelRuntime = RuntimeRef & ChannelRegistryRuntime;
+/**
+ * Register the daily backup channel (its global row, the operator's on/off
+ * kept). Never fails on configuration: the schedule always registers (see
+ * {@link resolveBackupCron}).
+ */
+export declare function registerBackupChannels(runtime: BackupChannelRuntime): Promise<void>;
+export {};
+//# sourceMappingURL=backup.channel.d.ts.map

package/dist/backup/channels/backup.channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backup.channel.d.ts","sourceRoot":"","sources":["../../../src/backup/channels/backup.channel.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAA0D,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAG9G,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAkBvE,oFAAoF;AACpF,KAAK,oBAAoB,GAAG,UAAU,GAAG,sBAAsB,CAAC;AAkDhE;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAuBf"}

package/dist/backup/channels/backup.channel.js

@@ -0,0 +1,89 @@
+/**
+ * Backup channel registration.
+ *
+ * Registers `backup.daily` with os/channels as a `user` channel: one global
+ * row, fired once per occurrence across every runtime that schedules it. Fires
+ * `vibes backup now` on the `storage.backup` manifest's `backupCron` (default
+ * `30 3 * * *`) so snapshots happen even when the agent isn't actively in
+ * session.
+ */
+import { CapabilityError, CaughtFailureSchema, valueFreeFailure } from "@vibesdotdev/kernel";
+import { getLogger } from "@vibesdotdev/logging";
+import { getVibesClient } from "@vibesdotdev/kernel/client";
+import { STORAGE_BACKUP_CONFIG_MANIFEST_ID, StorageBackupConfigSchema, } from "../config/storage.backup.config.descriptor.js";
+// reverse-edge wall: system may depend on storage — resolve registerChannel at call time
+async function loadRegisterChannel() {
+    const mod = await import("@vibesdotdev/os/channels");
+    return mod.registerChannel;
+}
+/** The manifest's declared default (`30 3 * * *`): pure data, no config or storage read. */
+const DECLARED_BACKUP_CRON = StorageBackupConfigSchema.parse({}).backupCron;
+async function readBackupCron(runtime) {
+    const config = await getVibesClient("config", runtime);
+    const settings = await config.read({
+        id: STORAGE_BACKUP_CONFIG_MANIFEST_ID,
+        schema: StorageBackupConfigSchema,
+    });
+    return settings.backupCron;
+}
+/**
+ * The cron backup.daily schedules on. A host whose config owner cannot read
+ * `storage.backup` (no path roots, no local adapter) still schedules the
+ * snapshot on the manifest's declared default, and the refusal is reported
+ * with its cause: losing the schedule loses data, so a config read never
+ * decides whether backups run, only when.
+ */
+async function resolveBackupCron(runtime) {
+    const read = await readBackupCronOrRefusal(runtime);
+    if (!(read instanceof CapabilityError))
+        return read;
+    getLogger("storage:backup", runtime).warn(read.message, {
+        reason: read.reason,
+        manifestId: STORAGE_BACKUP_CONFIG_MANIFEST_ID,
+        cron: DECLARED_BACKUP_CRON,
+        failure: valueFreeFailure(read),
+    });
+    return DECLARED_BACKUP_CRON;
+}
+/** The configured cron, or the typed refusal (its cause kept) when it cannot be read. */
+async function readBackupCronOrRefusal(runtime) {
+    try {
+        return await readBackupCron(runtime);
+    }
+    catch (error) {
+        return new CapabilityError("The storage.backup schedule could not be read; backup.daily uses the declared default.", "UNAVAILABLE", {
+            reason: "backup-cron-unresolved",
+            details: { manifestId: STORAGE_BACKUP_CONFIG_MANIFEST_ID, cron: DECLARED_BACKUP_CRON },
+            cause: CaughtFailureSchema.parse(error),
+        });
+    }
+}
+/**
+ * Register the daily backup channel (its global row, the operator's on/off
+ * kept). Never fails on configuration: the schedule always registers (see
+ * {@link resolveBackupCron}).
+ */
+export async function registerBackupChannels(runtime) {
+    // Read when the channel registers, never at import.
+    const backupCron = await resolveBackupCron(runtime);
+    const registerChannel = await loadRegisterChannel();
+    await registerChannel(runtime, {
+        id: "backup.daily",
+        owner: "backup",
+        name: "Daily Backup Snapshot",
+        description: "Runs daily snapshots for all enabled backup/target descriptors",
+        schedule: { type: "cron", expression: backupCron },
+        handler: {
+            type: "agent",
+            command: "vibes",
+            args: ["backup", "now"],
+        },
+        scope: "agent",
+        // One snapshot per user per day, however many runtimes register it.
+        placement: "user",
+        maxParallel: 1,
+        skipIfBusy: true,
+        enabled: true,
+    });
+}
+//# sourceMappingURL=backup.channel.js.map

package/dist/backup/channels/backup.channel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backup.channel.js","sourceRoot":"","sources":["../../../src/backup/channels/backup.channel.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,gBAAgB,EAAmB,MAAM,qBAAqB,CAAC;AAC9G,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAsB,MAAM,4BAA4B,CAAC;AAEhF,OAAO,EACL,iCAAiC,EACjC,yBAAyB,GAE1B,MAAM,+CAA+C,CAAC;AAEvD,yFAAyF;AACzF,KAAK,UAAU,mBAAmB;IAChC,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,0BAA0B,CAAC,CAAC;IACrD,OAAO,GAAG,CAAC,eAAe,CAAC;AAC7B,CAAC;AAUD,4FAA4F;AAC5F,MAAM,oBAAoB,GAAW,yBAAyB,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,UAAU,CAAC;AAEpF,KAAK,UAAU,cAAc,CAAC,OAA6B;IACzD,MAAM,MAAM,GAAG,MAAM,cAAc,CAAe,QAAQ,EAAE,OAAO,CAAC,CAAC;IACrE,MAAM,QAAQ,GAAwB,MAAM,MAAM,CAAC,IAAI,CAAC;QACtD,EAAE,EAAE,iCAAiC;QACrC,MAAM,EAAE,yBAAyB;KAClC,CAAC,CAAC;IACH,OAAO,QAAQ,CAAC,UAAU,CAAC;AAC7B,CAAC;AAED;;;;;;GAMG;AACH,KAAK,UAAU,iBAAiB,CAAC,OAA6B;IAC5D,MAAM,IAAI,GAAG,MAAM,uBAAuB,CAAC,OAAO,CAAC,CAAC;IACpD,IAAI,CAAC,CAAC,IAAI,YAAY,eAAe,CAAC;QAAE,OAAO,IAAI,CAAC;IACpD,SAAS,CAAC,gBAAgB,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;QACtD,MAAM,EAAE,IAAI,CAAC,MAAM;QACnB,UAAU,EAAE,iCAAiC;QAC7C,IAAI,EAAE,oBAAoB;QAC1B,OAAO,EAAE,gBAAgB,CAAC,IAAI,CAAC;KAChC,CAAC,CAAC;IACH,OAAO,oBAAoB,CAAC;AAC9B,CAAC;AAED,yFAAyF;AACzF,KAAK,UAAU,uBAAuB,CAAC,OAA6B;IAClE,IAAI,CAAC;QACH,OAAO,MAAM,cAAc,CAAC,OAAO,CAAC,CAAC;IACvC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,IAAI,eAAe,CACxB,wFAAwF,EACxF,aAAa,EACb;YACE,MAAM,EAAE,wBAAwB;YAChC,OAAO,EAAE,EAAE,UAAU,EAAE,iCAAiC,EAAE,IAAI,EAAE,oBAAoB,EAAE;YACtF,KAAK,EAAE,mBAAmB,CAAC,KAAK,CAAC,KAAK,CAAC;SACxC,CACF,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAC1C,OAA6B;IAE7B,oDAAoD;IACpD,MAAM,UAAU,GAAG,MAAM,iBAAiB,CAAC,OAAO,CAAC,CAAC;IACpD,MAAM,eAAe,GAAG,MAAM,mBAAmB,EAAE,CAAC;IACpD,MAAM,eAAe,CAAC,OAAO,EAAE;QAC7B,EAAE,EAAE,cAAc;QAClB,KAAK,EAAE,QAAQ;QACf,IAAI,EAAE,uBAAuB;QAC7B,WAAW,EACT,gEAAgE;QAClE,QAAQ,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE;QAClD,OAAO,EAAE;YACP,IAAI,EAAE,OAAO;YACb,OAAO,EAAE,OAAO;YAChB,IAAI,EAAE,CAAC,QAAQ,EAAE,KAAK,CAAC;SACxB;QACD,KAAK,EAAE,OAAO;QACd,oEAAoE;QACpE,SAAS,EAAE,MAAM;QACjB,WAAW,EAAE,CAAC;QACd,UAAU,EAAE,IAAI;QAChB,OAAO,EAAE,IAAI;KACd,CAAC,CAAC;AACL,CAAC"}

package/dist/backup/config/storage.backup.config.descriptor.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Storage backup settings — the config manifest backup registration reads.
+ *
+ * `backupCron` is the daily snapshot schedule. It replaces the former
+ * `VIBES_BACKUP_CRON` environment knob: a setting is a declared manifest
+ * key with a useful default (`30 3 * * *`, the previous 03:30 cron),
+ * read through the config owner's client, never an env read at the
+ * call site.
+ *
+ * Declared as data with `createRuntimeAsset` so storage takes no package
+ * edge on `@vibesdotdev/config`. The runtime holds the descriptor until
+ * the `config/manifest` kind registers.
+ */
+import * as z from "zod/v4";
+export declare const StorageBackupConfigSchema: z.ZodObject<{
+    backupCron: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type StorageBackupConfig = z.infer<typeof StorageBackupConfigSchema>;
+export declare const STORAGE_BACKUP_CONFIG_MANIFEST_ID = "storage.backup";
+export declare const storageBackupConfigDescriptor: {
+    kind: "config/manifest";
+    id: string;
+    name: string;
+    namespace: string;
+    description: string;
+    tier: string;
+    category: string;
+    schema: z.ZodObject<{
+        backupCron: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    fields: {
+        backupCron: {
+            ui: {
+                label: string;
+                description: string;
+                component: string;
+                group: string;
+            };
+        };
+    };
+    groups: {
+        id: string;
+        label: string;
+    }[];
+    allowedAdapters: string[];
+    defaultAdapter: string;
+    scope: string;
+    customTables: boolean;
+    version: number;
+    internal: boolean;
+    context: {
+        surfaces: string[];
+    };
+    enabled: true;
+};
+export default storageBackupConfigDescriptor;
+//# sourceMappingURL=storage.backup.config.descriptor.d.ts.map

package/dist/backup/config/storage.backup.config.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.backup.config.descriptor.d.ts","sourceRoot":"","sources":["../../../src/backup/config/storage.backup.config.descriptor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAG5B,eAAO,MAAM,yBAAyB;;iBAGpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,eAAO,MAAM,iCAAiC,mBAAmB,CAAC;AAElE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BxC,CAAC;AAEH,eAAe,6BAA6B,CAAC"}

package/dist/backup/config/storage.backup.config.descriptor.js

@@ -0,0 +1,53 @@
+/**
+ * Storage backup settings — the config manifest backup registration reads.
+ *
+ * `backupCron` is the daily snapshot schedule. It replaces the former
+ * `VIBES_BACKUP_CRON` environment knob: a setting is a declared manifest
+ * key with a useful default (`30 3 * * *`, the previous 03:30 cron),
+ * read through the config owner's client, never an env read at the
+ * call site.
+ *
+ * Declared as data with `createRuntimeAsset` so storage takes no package
+ * edge on `@vibesdotdev/config`. The runtime holds the descriptor until
+ * the `config/manifest` kind registers.
+ */
+import * as z from "zod/v4";
+import { createRuntimeAsset } from "@vibesdotdev/kernel";
+export const StorageBackupConfigSchema = z.object({
+    /** Cron expression for the daily local snapshot channel. */
+    backupCron: z.string().trim().min(1).default("30 3 * * *"),
+});
+export const STORAGE_BACKUP_CONFIG_MANIFEST_ID = "storage.backup";
+export const storageBackupConfigDescriptor = createRuntimeAsset({
+    kind: "config/manifest",
+    id: STORAGE_BACKUP_CONFIG_MANIFEST_ID,
+    name: "Storage backup",
+    namespace: "storage",
+    description: "Daily snapshot schedule for the local backup channel",
+    tier: "user",
+    category: "storage",
+    schema: StorageBackupConfigSchema,
+    fields: {
+        backupCron: {
+            ui: {
+                label: "Daily backup cron",
+                description: "When the local backup.daily channel fires `vibes backup now`",
+                component: "input",
+                group: "schedule",
+            },
+        },
+    },
+    groups: [{ id: "schedule", label: "Schedule" }],
+    allowedAdapters: ["storage.localdb", "storage.json"],
+    defaultAdapter: "storage.localdb",
+    scope: "auto",
+    customTables: false,
+    version: 1,
+    internal: false,
+    context: {
+        surfaces: ["cli", "tui"],
+    },
+    enabled: true,
+});
+export default storageBackupConfigDescriptor;
+//# sourceMappingURL=storage.backup.config.descriptor.js.map

package/dist/backup/config/storage.backup.config.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.backup.config.descriptor.js","sourceRoot":"","sources":["../../../src/backup/config/storage.backup.config.descriptor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAEzD,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC;IAChD,4DAA4D;IAC5D,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC;CAC3D,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,iCAAiC,GAAG,gBAAgB,CAAC;AAElE,MAAM,CAAC,MAAM,6BAA6B,GAAG,kBAAkB,CAAC;IAC9D,IAAI,EAAE,iBAAiB;IACvB,EAAE,EAAE,iCAAiC;IACrC,IAAI,EAAE,gBAAgB;IACtB,SAAS,EAAE,SAAS;IACpB,WAAW,EAAE,sDAAsD;IACnE,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,SAAS;IACnB,MAAM,EAAE,yBAAyB;IACjC,MAAM,EAAE;QACN,UAAU,EAAE;YACV,EAAE,EAAE;gBACF,KAAK,EAAE,mBAAmB;gBAC1B,WAAW,EAAE,8DAA8D;gBAC3E,SAAS,EAAE,OAAO;gBAClB,KAAK,EAAE,UAAU;aAClB;SACF;KACF;IACD,MAAM,EAAE,CAAC,EAAE,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC;IAC/C,eAAe,EAAE,CAAC,iBAAiB,EAAE,cAAc,CAAC;IACpD,cAAc,EAAE,iBAAiB;IACjC,KAAK,EAAE,MAAM;IACb,YAAY,EAAE,KAAK;IACnB,OAAO,EAAE,CAAC;IACV,QAAQ,EAAE,KAAK;IACf,OAAO,EAAE;QACP,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC;KACzB;IACD,OAAO,EAAE,IAAI;CACd,CAAC,CAAC;AAEH,eAAe,6BAA6B,CAAC"}

package/dist/backup/core/hash.d.ts

@@ -0,0 +1,8 @@
+/**
+ * SHA-256 of a snapshot file, read in bounded chunks through the runtime's
+ * filesystem kind without following a link (incremental hash; no host crypto
+ * module).
+ */
+import { type BackupIo } from "./io.ts";
+export declare function sha256OfFile(io: BackupIo, path: string, targetId?: string): Promise<string>;
+//# sourceMappingURL=hash.d.ts.map

package/dist/backup/core/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../../src/backup/core/hash.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAoB,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE1D,wBAAsB,YAAY,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,SAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,CAE1G"}

package/dist/backup/core/hash.js

@@ -0,0 +1,10 @@
+/**
+ * SHA-256 of a snapshot file, read in bounded chunks through the runtime's
+ * filesystem kind without following a link (incremental hash; no host crypto
+ * module).
+ */
+import { hashFileNoFollow } from "./io.js";
+export async function sha256OfFile(io, path, targetId = "backup.verify") {
+    return (await hashFileNoFollow(io, path, targetId)).sha256;
+}
+//# sourceMappingURL=hash.js.map

package/dist/backup/core/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.js","sourceRoot":"","sources":["../../../src/backup/core/hash.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,gBAAgB,EAAiB,MAAM,SAAS,CAAC;AAE1D,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,EAAY,EAAE,IAAY,EAAE,QAAQ,GAAG,eAAe;IACvF,OAAO,CAAC,MAAM,gBAAgB,CAAC,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC;AAC7D,CAAC"}

package/dist/backup/core/homes.d.ts

@@ -0,0 +1,13 @@
+import type { BackupAgentHome } from '../schemas/core.ts';
+export type { BackupAgentHome } from '../schemas/core.ts';
+import { type BackupIo } from "./io.ts";
+/** `<ownerType>/<ownerId>/<agentId>`: how a home is named in results and provenance. */
+export declare function agentHomeLabel(home: BackupAgentHome): string;
+/**
+ * Every agent home under `root` that holds `marker` (a regular file, not a
+ * link). A missing root is no homes; a root or owner directory that cannot be
+ * read refuses with `backup-agent-homes-unreadable` rather than backing up a
+ * partial set silently.
+ */
+export declare function listBackupAgentHomes(io: BackupIo, root: string, marker: string): Promise<BackupAgentHome[]>;
+//# sourceMappingURL=homes.d.ts.map

package/dist/backup/core/homes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"homes.d.ts","sourceRoot":"","sources":["../../../src/backup/core/homes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,YAAY,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAW1D,OAAO,EAAmB,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEzD,wFAAwF;AACxF,wBAAgB,cAAc,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,CAE5D;AAQD;;;;;GAKG;AACH,wBAAsB,oBAAoB,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAuBjH"}