harnery 0.36.0 → 0.37.0

package/src/core/agents/rules/commit-conflict.ts

@@ -25,6 +25,7 @@ import { appendFileSync, existsSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { coordFreshnessSeconds } from "../../config.ts";
 import { resolveOwner } from "../../hooks/resolve/owner.ts";
+import { recordLiveClaimChangeV3 } from "../live-authority-v3.ts";
 import { readLiveCoordinationRows } from "../state/live-coordination-view.ts";
 import { instanceHasLivePid } from "../state/pidmap.ts";
 
@@ -34,6 +35,7 @@ interface PeerHeartbeat {
   name?: string;
   files_touched?: string[];
   last_heartbeat?: string;
+  platform?: string;
 }
 
 interface Conflict {
@@ -190,6 +192,15 @@ export function evaluateCommit(coordRoot: string, req: CommitVerdictRequest): Co
     };
   }
 
+  // A blocked commit proves this session has work in every staged path, even
+  // when the edit hook never acquired a claim (for example, a shell edit made
+  // just before another session claimed the same file). Keep those paths on
+  // the blocked session's durable claim set. The original holder's later
+  // commit will then see the overlap instead of silently sweeping this
+  // session's working-tree hunks. A successful later commit releases clean
+  // paths through the existing post-commit hook.
+  retainBlockedStagedPaths(coordRoot, me, mySession, req.staged_paths, peers);
+
   return {
     allow: false,
     exit_code: 1,
@@ -204,6 +215,41 @@ export function evaluateCommit(coordRoot: string, req: CommitVerdictRequest): Co
   };
 }
 
+function retainBlockedStagedPaths(
+  coordRoot: string,
+  instanceId: string,
+  sessionId: string,
+  stagedPaths: readonly string[],
+  peers: readonly PeerHeartbeat[],
+): void {
+  if (instanceId === "__unattributed__") return;
+  const self = peers.find((peer) => peer.instance_id === instanceId);
+  if (!self) return;
+
+  for (const path of stagedPaths) {
+    try {
+      recordLiveClaimChangeV3({
+        coordRoot,
+        owner: instanceId,
+        nativeSessionId: self.session_id ?? sessionId,
+        adapter: adapterFromPlatform(self.platform),
+        operation: "acquired",
+        path,
+        access: "write",
+      });
+    } catch {
+      // The commit is already blocked. Coordination remains fail-open for
+      // authority-write failures so a damaged cache cannot brick Git.
+    }
+  }
+}
+
+function adapterFromPlatform(platform: unknown): "claude-code" | "cursor" | "codex" {
+  if (platform === "cursor") return "cursor";
+  if (platform === "codex") return "codex";
+  return "claude-code";
+}
+
 function findOverlap(
   staged: string,
   files: readonly string[],
@@ -269,6 +315,18 @@ function isHolderSelfAttributed(
   stagedSet: Set<string>,
   peers: readonly PeerHeartbeat[],
 ): boolean {
+  const holder = peers.find((p) => p.instance_id === holderId);
+
+  // Windows-hosted Codex sessions cross a process boundary into WSL, so they
+  // deliberately have no usable PID anchor. Their canonical V3 session row is
+  // the foreign-identity evidence instead. Treating that row as a transient
+  // self identity would suppress the symmetric claim retained after a blocked
+  // commit and reopen the working-tree sweep this guard is meant to stop.
+  if (holder?.platform === "codex" && holder.session_id) {
+    debugGate(coordRoot, { holder: holderId, gate: "B", reason: "canonical_codex_session" });
+    return false;
+  }
+
   // Gate B (cheaper): live foreign pid-map entry blocks self-attribution.
   if (holderHasLiveForeignPid(coordRoot, holderId)) {
     debugGate(coordRoot, { holder: holderId, gate: "B", reason: "live_pid_anchor" });
@@ -276,7 +334,6 @@ function isHolderSelfAttributed(
   }
 
   // Gate A: every held path is either in the staged set or already clean in HEAD.
-  const holder = peers.find((p) => p.instance_id === holderId);
   if (!holder) {
     debugGate(coordRoot, { holder: holderId, gate: "A", reason: "holder_not_found" });
     return false;

package/src/core/agents/rules/stop-hook.ts

@@ -154,22 +154,16 @@ export function evaluateStopHookV3Events(
     .map((event) => observedBoolean(event.payload.ritual?.status_box_present_strict))
     .filter((value): value is boolean => value !== undefined);
   const currentStrictBox = claudeContinuation ? req.status_box_present_strict : undefined;
-  if (req.adapter !== "cursor" && latestBox === undefined && currentStrictBox === undefined) {
+  if (latestBox === undefined && currentStrictBox === undefined) {
     return evidenceUnavailable(
       "turn.completed has no observed V3 assistant-text status-box result; Stop remains fail-open",
     );
   }
 
-  const ackPresent =
-    req.adapter === "cursor"
-      ? requiredStatusChecked
-      : claudeContinuation
-        ? strictBoxObservations.includes(true) || currentStrictBox === true
-        : latestBox === true;
-  const ackBlock =
-    req.adapter === "cursor"
-      ? () => rule13Block(coordRoot, req.session_id)
-      : () => rule23Block(coordRoot, req.session_id);
+  const ackPresent = claudeContinuation
+    ? strictBoxObservations.includes(true) || currentStrictBox === true
+    : latestBox === true;
+  const ackBlock = () => rule23Block(coordRoot, req.session_id);
 
   // Pure prose turns keep the human-visible acknowledgement but do not require
   // task or final-status mutations. This preserves the pre-V3 policy exactly.
@@ -354,7 +348,7 @@ function sessionIdSuffix(sessionId?: string): string {
  * The verdict keeps the first failure's rule id, so the `blocked_rule`
  * telemetry and the adapter's `rule=` stderr contract are unchanged; the
  * reason enumerates the rest so a single continuation can repair all of them.
- * Cursor maps the acknowledgement onto rule 1/3, so identical rules dedupe.
+ * Duplicate rules are folded so one continuation repairs every missing signal.
  */
 function mergeStopBlocks(blocks: VerdictResult[]): VerdictResult | undefined {
   let primary: VerdictResult | undefined;

package/src/core/agents/session-finalizer-v3.ts

@@ -584,7 +584,10 @@ function observeCascades(
     }
     if (
       event.event_type === "lifecycle.sweep_observed" &&
-      event.payload.observation === "stale_sweep"
+      // stale-sweep.ts emits the observation as `stale_heartbeat`; the
+      // finalization request it produces is the one named `stale_sweep`.
+      // Matching the request name here made this branch unreachable.
+      event.payload.observation === "stale_heartbeat"
     ) {
       const record = records.find(
         ({ state }) => !state.terminal && state.instance_id === event.payload.subject_instance_id,

package/src/core/artifacts/index.ts

@@ -27,6 +27,8 @@ import {
   artifactAutoCleanEnabled,
   artifactAutoCleanIntervalHours,
   artifactDefaultRetentionDays,
+  artifactMaxBytes,
+  artifactMaxUnitBytes,
 } from "../config.ts";
 import { ARTIFACT_MANIFEST, ARTIFACT_SCHEMA_VERSION, ARTIFACTS_DIR } from "./constants.ts";
 
@@ -52,12 +54,15 @@ export interface ArtifactManifestV1 {
   };
   released_at?: string;
   released_by?: ArtifactActor;
+  oversize_acknowledged?: boolean;
 }
 
 export type ArtifactClassification =
   | "managed-active"
   | "managed-current"
   | "managed-expired"
+  | "managed-oversize"
+  | "managed-over-budget"
   | "managed-tracked"
   | "invalid-manifest"
   | "unmanaged"
@@ -78,6 +83,7 @@ export interface ArtifactInventoryEntry {
   last_modified_at: string | null;
   expires_at: string | null;
   owner_instance_id: string | null;
+  oversize_acknowledged: boolean;
 }
 
 export interface ArtifactCreateInput {
@@ -87,6 +93,7 @@ export interface ArtifactCreateInput {
   actor?: ArtifactActor;
   now?: Date;
   id?: string;
+  big?: boolean;
 }
 
 export interface ArtifactMutationInput {
@@ -94,6 +101,15 @@ export interface ArtifactMutationInput {
   now?: Date;
 }
 
+export interface ArtifactAdoptionResult {
+  candidates: Array<{ path: string; name: string; bytes: number; kind: "file" | "directory" }>;
+  candidate_bytes: number;
+  requires_big: boolean;
+  adopted_artifact_id: string | null;
+  adopted_path: string | null;
+  adopted_directories: number;
+}
+
 interface ParsedManifest {
   ok: true;
   manifest: ArtifactManifestV1;
@@ -145,6 +161,7 @@ export function createArtifact(
     retention: {
       expires_at: addDays(now, retentionDays).toISOString(),
     },
+    ...(input.big ? { oversize_acknowledged: true } : {}),
   };
   atomicWriteManifest(path, manifest);
   return { path, manifest };
@@ -177,7 +194,7 @@ export function inventoryArtifacts(
   for (const name of names) {
     rows.push(classifyArtifactPath(repoRoot, join(root, name), now, freshnessSeconds));
   }
-  return rows;
+  return applyArtifactBudgets(repoRoot, rows);
 }
 
 export function showArtifact(
@@ -186,12 +203,8 @@ export function showArtifact(
   opts: { now?: Date; freshnessSeconds?: number } = {},
 ): { entry: ArtifactInventoryEntry; manifest: ArtifactManifestV1 } {
   const path = resolveArtifactRef(repoRoot, ref);
-  const entry = classifyArtifactPath(
-    repoRoot,
-    path,
-    opts.now ?? new Date(),
-    opts.freshnessSeconds ?? 600,
-  );
+  const entry = inventoryArtifacts(repoRoot, opts).find((row) => row.path === path);
+  if (!entry) throw new Error(`artifact "${ref}" was not found`);
   const parsed = readManifest(path);
   if (!parsed.ok) throw new Error(parsed.reason);
   return { entry, manifest: parsed.manifest };
@@ -243,6 +256,108 @@ export function releaseArtifact(
   return manifest;
 }
 
+/** Adopt untracked loose files and legacy directories without changing directory paths. */
+export function adoptUnmanagedArtifactFiles(
+  repoRoot: string,
+  input: {
+    yes?: boolean;
+    big?: boolean;
+    purpose: string;
+    retentionDays: number;
+    actor?: ArtifactActor;
+    now?: Date;
+  },
+): ArtifactAdoptionResult {
+  const now = input.now ?? new Date();
+  const candidates: ArtifactAdoptionResult["candidates"] = [];
+  for (const row of inventoryArtifacts(repoRoot, { now })) {
+    if (row.classification !== "unmanaged") continue;
+    try {
+      const stat = lstatSync(row.path);
+      if (stat.isSymbolicLink() || containsTrackedPath(repoRoot, row.path)) continue;
+      if (stat.isFile()) {
+        candidates.push({ path: row.path, name: row.name, bytes: stat.size, kind: "file" });
+        continue;
+      }
+      if (stat.isDirectory() && !existsSync(join(row.path, ARTIFACT_MANIFEST))) {
+        const bytes = safeTreeSize(row.path);
+        if (bytes !== null && normalizeSlug(row.name)) {
+          candidates.push({ path: row.path, name: row.name, bytes, kind: "directory" });
+        }
+      }
+    } catch {
+      // A racing or unreadable entry stays unmanaged.
+    }
+  }
+  const candidateBytes = candidates.reduce((sum, row) => sum + row.bytes, 0);
+  const fileBytes = candidates.reduce((sum, row) => sum + (row.kind === "file" ? row.bytes : 0), 0);
+  const maxUnitBytes = artifactMaxUnitBytes(repoRoot);
+  const requiresBig =
+    fileBytes > maxUnitBytes ||
+    candidates.some((row) => row.kind === "directory" && row.bytes > maxUnitBytes);
+  const preview: ArtifactAdoptionResult = {
+    candidates,
+    candidate_bytes: candidateBytes,
+    requires_big: requiresBig,
+    adopted_artifact_id: null,
+    adopted_path: null,
+    adopted_directories: 0,
+  };
+  if (!input.yes || candidates.length === 0) return preview;
+  if (requiresBig && !input.big) {
+    throw new Error("unmanaged adoption exceeds the per-bundle ceiling; repeat with --big");
+  }
+
+  // Revalidate every exact source before creating a destination. A changed,
+  // tracked, linked, or non-regular entry aborts the whole adoption.
+  for (const candidate of candidates) {
+    const stat = lstatSync(candidate.path);
+    const bytes = stat.isDirectory() ? safeTreeSize(candidate.path) : stat.size;
+    if (
+      stat.isSymbolicLink() ||
+      bytes !== candidate.bytes ||
+      containsTrackedPath(repoRoot, candidate.path)
+    ) {
+      throw new Error(`unmanaged entry changed before adoption: ${candidate.name}`);
+    }
+    if (candidate.kind === "file" ? !stat.isFile() : !stat.isDirectory()) {
+      throw new Error(`unmanaged entry changed before adoption: ${candidate.name}`);
+    }
+  }
+  const files = candidates.filter((candidate) => candidate.kind === "file");
+  const created = files.length
+    ? createArtifact(repoRoot, {
+        slug: "adopted-unmanaged",
+        purpose: input.purpose,
+        retentionDays: input.retentionDays,
+        actor: input.actor,
+        now,
+        big: input.big,
+      })
+    : null;
+  for (const candidate of files) renameSync(candidate.path, join(created!.path, candidate.name));
+  const retentionDays = positiveDays(input.retentionDays);
+  const directories = candidates.filter((candidate) => candidate.kind === "directory");
+  for (const candidate of directories) {
+    atomicWriteManifest(candidate.path, {
+      schema_version: ARTIFACT_SCHEMA_VERSION,
+      artifact_id: randomUUID(),
+      slug: normalizeSlug(candidate.name),
+      purpose: `${input.purpose}: ${candidate.name}`,
+      created_at: now.toISOString(),
+      created_by: input.actor,
+      retention: { expires_at: addDays(now, retentionDays).toISOString() },
+      ...(input.big ? { oversize_acknowledged: true } : {}),
+    });
+  }
+  return {
+    ...preview,
+    adopted_artifact_id: created?.manifest.artifact_id ?? null,
+    adopted_path: created?.path ?? null,
+    adopted_directories: directories.length,
+  };
+}
+
 export function cleanArtifacts(
   repoRoot: string,
   opts: { yes?: boolean; now?: Date; freshnessSeconds?: number } = {},
@@ -253,11 +368,24 @@ export function cleanArtifacts(
   if (!opts.yes) return rows;
 
   return rows.map((entry) => {
-    if (entry.classification !== "managed-expired") return entry;
+    if (entry.action !== "would-delete") return entry;
     // Reclassify immediately before removal. A renewal, release-state change,
     // heartbeat, symlink swap, or tracked file added since inventory must win.
-    const current = classifyArtifactPath(repoRoot, entry.path, now, freshnessSeconds);
-    if (current.classification !== "managed-expired") return current;
+    const current = inventoryArtifacts(repoRoot, { now, freshnessSeconds }).find(
+      (row) => row.path === entry.path,
+    );
+    if (!current) {
+      return { ...entry, classification: "unknown", reason: "entry disappeared", action: "keep" };
+    }
+    if (
+      current.action !== "would-delete" ||
+      current.artifact_id !== entry.artifact_id ||
+      current.bytes !== entry.bytes ||
+      current.last_modified_at !== entry.last_modified_at ||
+      current.expires_at !== entry.expires_at
+    ) {
+      return current;
+    }
     try {
       const top = lstatSync(current.path);
       if (!top.isDirectory() || top.isSymbolicLink()) {
@@ -404,6 +532,7 @@ function classifyArtifactPath(
     last_modified_at: new Date(effectiveLastModifiedMs).toISOString(),
     expires_at: effectiveExpiresAt,
     owner_instance_id: manifest.created_by?.instance_id ?? null,
+    oversize_acknowledged: manifest.oversize_acknowledged === true,
   });
 
   if (base.bytes === null || lastModifiedMs === null) {
@@ -450,6 +579,59 @@ function classifyArtifactPath(
   };
 }
 
+function applyArtifactBudgets(
+  repoRoot: string,
+  inputRows: ArtifactInventoryEntry[],
+): ArtifactInventoryEntry[] {
+  const maxUnitBytes = artifactMaxUnitBytes(repoRoot);
+  const maxBytes = artifactMaxBytes(repoRoot);
+  const rows = inputRows.map((row) => ({ ...row }));
+
+  for (const row of rows) {
+    if (
+      row.classification === "managed-current" &&
+      row.bytes !== null &&
+      row.bytes > maxUnitBytes &&
+      !row.oversize_acknowledged
+    ) {
+      row.classification = "managed-oversize";
+      row.reason = `bundle uses ${row.bytes} bytes, above the ${maxUnitBytes}-byte ceiling without --big`;
+      row.action = "would-delete";
+    }
+  }
+
+  const managedBytes = rows.reduce(
+    (sum, row) => sum + (row.artifact_id && row.bytes !== null ? row.bytes : 0),
+    0,
+  );
+  let retainedBytes =
+    managedBytes -
+    rows.reduce(
+      (sum, row) => sum + (row.action === "would-delete" && row.bytes !== null ? row.bytes : 0),
+      0,
+    );
+  if (retainedBytes <= maxBytes) return rows;
+
+  const candidates = rows
+    .filter(
+      (row) =>
+        row.classification === "managed-current" && row.action === "keep" && row.bytes !== null,
+    )
+    .sort((left, right) =>
+      `${left.expires_at ?? ""}\0${left.created_at ?? ""}\0${left.name}`.localeCompare(
+        `${right.expires_at ?? ""}\0${right.created_at ?? ""}\0${right.name}`,
+      ),
+    );
+  for (const row of candidates) {
+    if (retainedBytes <= maxBytes) break;
+    row.classification = "managed-over-budget";
+    row.reason = `repository artifact budget is ${maxBytes} bytes; earliest-expiring inactive bundles are removed first`;
+    row.action = "would-delete";
+    retainedBytes -= row.bytes ?? 0;
+  }
+  return rows;
+}
+
 function readManifest(path: string): ParsedManifest | ManifestError {
   const manifestPath = join(path, ARTIFACT_MANIFEST);
   if (!existsSync(manifestPath)) {
@@ -495,6 +677,9 @@ function readManifest(path: string): ParsedManifest | ManifestError {
   if (m.released_by !== undefined && !validActor(m.released_by)) {
     return { ok: false, reason: "invalid released_by" };
   }
+  if (m.oversize_acknowledged !== undefined && typeof m.oversize_acknowledged !== "boolean") {
+    return { ok: false, reason: "invalid oversize_acknowledged" };
+  }
   return { ok: true, manifest: m as ArtifactManifestV1 };
 }
 
@@ -604,6 +789,7 @@ function rowFor(
     last_modified_at: null,
     expires_at: null,
     owner_instance_id: null,
+    oversize_acknowledged: false,
   };
 }
 

package/src/core/config.ts

@@ -137,12 +137,23 @@ interface HarneryConfig {
    * (default 32 MiB; `0` disables rotation). Read via
    * `eventLedgerRotateActiveBytes()`.
    */
-  events?: { rotate_active_bytes?: number };
+  events?: {
+    rotate_active_bytes?: number;
+    archive_max_bytes?: number;
+    archive_max_age_days?: number;
+    archive_keep_min?: number;
+    archive_auto_clean?: boolean;
+  };
   /**
    * Managed working-artifact defaults. `default_retention_days` is the
    * create-time TTL when the caller does not pass `artifacts create --days`.
    */
-  artifacts?: { default_retention_days?: number; auto_clean?: boolean };
+  artifacts?: {
+    default_retention_days?: number;
+    auto_clean?: boolean;
+    max_bytes?: number;
+    max_unit_bytes?: number;
+  };
   /**
    * `harn backup` (restic) defaults: `repo` path/URL, `password_file`, and the
    * `keep_daily`/`keep_weekly`/`keep_monthly` prune policy. Read via `backupConfig()`.
@@ -622,6 +633,51 @@ export function eventLedgerRotateActiveBytes(coordRoot?: string | null): number
   return resolveEventLedgerRotateActiveBytesV3(root);
 }
 
+const DEFAULT_EVENT_ARCHIVE_MAX_BYTES = 1024 * 1024 * 1024;
+const DEFAULT_EVENT_ARCHIVE_MAX_AGE_DAYS = 7;
+const DEFAULT_EVENT_ARCHIVE_KEEP_MIN = 2;
+
+export interface EventLedgerArchivePolicy {
+  maxBytes: number;
+  maxAgeDays: number;
+  keepMin: number;
+  autoClean: boolean;
+}
+
+/** Bounded retention for closed V3 epochs under `ledgers/v3-archives`. */
+export function eventLedgerArchivePolicy(coordRoot?: string | null): EventLedgerArchivePolicy {
+  const root = coordRoot ?? findCoordRoot();
+  const configured = root ? readConfig(root).events : undefined;
+  return {
+    maxBytes: integerSetting(
+      coordEnv("EVENT_V3_ARCHIVE_MAX_BYTES"),
+      configured?.archive_max_bytes,
+      64 * 1024 * 1024,
+      1024 * 1024 * 1024 * 1024,
+      DEFAULT_EVENT_ARCHIVE_MAX_BYTES,
+    ),
+    maxAgeDays: integerSetting(
+      coordEnv("EVENT_V3_ARCHIVE_MAX_AGE_DAYS"),
+      configured?.archive_max_age_days,
+      1,
+      3650,
+      DEFAULT_EVENT_ARCHIVE_MAX_AGE_DAYS,
+    ),
+    keepMin: integerSetting(
+      coordEnv("EVENT_V3_ARCHIVE_KEEP_MIN"),
+      configured?.archive_keep_min,
+      1,
+      1000,
+      DEFAULT_EVENT_ARCHIVE_KEEP_MIN,
+    ),
+    autoClean: booleanSetting(
+      coordEnv("EVENT_V3_ARCHIVE_AUTO_CLEAN"),
+      configured?.archive_auto_clean,
+      true,
+    ),
+  };
+}
+
 function parseWebPort(value: unknown, source: string): number {
   const port = typeof value === "number" ? value : Number(value);
   if (!Number.isInteger(port) || port < 1024 || port > 65535) {
@@ -703,6 +759,33 @@ export function artifactDefaultRetentionDays(coordRoot?: string | null): number
     : 3;
 }
 
+const DEFAULT_ARTIFACT_MAX_BYTES = 20 * 1024 * 1024 * 1024;
+const DEFAULT_ARTIFACT_MAX_UNIT_BYTES = 1024 * 1024 * 1024;
+
+/** Soft repository budget for managed working artifacts. */
+export function artifactMaxBytes(coordRoot?: string | null): number {
+  const root = coordRoot ?? findCoordRoot();
+  return integerSetting(
+    coordEnv("ARTIFACT_MAX_BYTES"),
+    root ? readConfig(root).artifacts?.max_bytes : undefined,
+    64 * 1024 * 1024,
+    1024 * 1024 * 1024 * 1024,
+    DEFAULT_ARTIFACT_MAX_BYTES,
+  );
+}
+
+/** Size at which one bundle requires an explicit `artifacts create --big` acknowledgement. */
+export function artifactMaxUnitBytes(coordRoot?: string | null): number {
+  const root = coordRoot ?? findCoordRoot();
+  return integerSetting(
+    coordEnv("ARTIFACT_MAX_UNIT_BYTES"),
+    root ? readConfig(root).artifacts?.max_unit_bytes : undefined,
+    16 * 1024 * 1024,
+    1024 * 1024 * 1024 * 1024,
+    DEFAULT_ARTIFACT_MAX_UNIT_BYTES,
+  );
+}
+
 /**
  * Whether the daily SessionStart sweep of expired artifact workspaces runs.
  * Precedence: `HARNERY_ARTIFACT_AUTO_CLEAN` (0/false disables) ->
@@ -733,6 +816,32 @@ export function artifactAutoCleanIntervalHours(): number {
   return 24;
 }
 
+function integerSetting(
+  envValue: string | undefined,
+  configured: unknown,
+  minimum: number,
+  maximum: number,
+  fallback: number,
+): number {
+  for (const value of [envValue, configured]) {
+    const parsed = typeof value === "number" ? value : Number(value);
+    if (Number.isSafeInteger(parsed) && parsed >= minimum && parsed <= maximum) return parsed;
+  }
+  return fallback;
+}
+
+function booleanSetting(
+  envValue: string | undefined,
+  configured: unknown,
+  fallback: boolean,
+): boolean {
+  if (envValue !== undefined) {
+    if (envValue === "1" || envValue.toLowerCase() === "true") return true;
+    if (envValue === "0" || envValue.toLowerCase() === "false") return false;
+  }
+  return typeof configured === "boolean" ? configured : fallback;
+}
+
 /** Resolved `harn backup` defaults (restic repo/password + prune policy). */
 export interface BackupConfig {
   repo: string;