packbat 0.1.0

package/dist/chunk-O43RENSG.js

@@ -0,0 +1,3362 @@
+// src/core/errors.ts
+var PackbatError = class extends Error {
+  name = "PackbatError";
+};
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/core/config.ts
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { z } from "zod";
+var CONFIG_VERSION = 2;
+var rcloneRemoteFields = {
+  /** Full rclone destination, e.g. "packbat-remote:bucket/prefix" or an absolute local path. */
+  destination: z.string().min(1),
+  /** "managed" = Packbat-owned rclone.conf; "default" = the user's own rclone config resolution. */
+  rcloneConfig: z.enum(["managed", "default"])
+};
+var remoteSchema = z.strictObject({
+  type: z.literal("rclone"),
+  ...rcloneRemoteFields
+});
+var remotesSchema = z.tuple([remoteSchema], remoteSchema).refine(
+  (remotes) => new Set(remotes.map((remote) => remote.destination)).size === remotes.length,
+  "remote destinations must be unique"
+  // DRAFT copy
+);
+var offboxSchema = z.discriminatedUnion("mode", [
+  z.object({
+    /** Skipping off-box is a first-class answer, never an error state. */
+    mode: z.literal("skipped"),
+    skippedAt: z.iso.datetime()
+  }),
+  z.object({
+    mode: z.literal("configured"),
+    /** age public recipient. The identity never lives on this machine after onboarding. */
+    recipient: z.string().regex(/^age1[0-9a-z]+$/, "must be an age recipient (age1\u2026)"),
+    remotes: remotesSchema
+  })
+]);
+var configSchema = z.strictObject({
+  version: z.literal(CONFIG_VERSION),
+  /**
+   * Locked at init (default: lowercase short hostname) so a later hostname
+   * change can never silently fork the archive tree. Machine trees are never
+   * merged.
+   */
+  machine: z.string().regex(/^[a-z0-9][a-z0-9-]*$/, "must be lowercase and hostname-safe (a-z, 0-9, -)"),
+  archiveRoot: z.string().refine((p) => p.startsWith("/"), "must be an absolute path"),
+  sweep: z.object({
+    intervalMinutes: z.number().int().min(5).max(24 * 60)
+  }),
+  offbox: offboxSchema
+});
+var legacyConfigSchema = z.strictObject({
+  version: z.literal(1),
+  machine: configSchema.shape.machine,
+  archiveRoot: configSchema.shape.archiveRoot,
+  sweep: configSchema.shape.sweep,
+  offbox: z.discriminatedUnion("mode", [
+    z.object({
+      mode: z.literal("skipped"),
+      skippedAt: z.iso.datetime()
+    }),
+    z.object({
+      mode: z.literal("configured"),
+      recipient: z.string().regex(/^age1[0-9a-z]+$/, "must be an age recipient (age1\u2026)"),
+      remote: z.object(rcloneRemoteFields)
+    })
+  ])
+});
+function remoteStateId(remote) {
+  return createHash("sha256").update(`${remote.type}\0${remote.destination}`).digest("hex");
+}
+function remoteStatePath(home, remote) {
+  return join(home.statePath, "offbox", remoteStateId(remote));
+}
+function migrateLegacyState(home, remote) {
+  const destination = remoteStatePath(home, remote);
+  mkdirSync(destination, { recursive: true });
+  for (const [legacyName, currentName] of [
+    ["offbox-uploaded.jsonl", "uploaded.jsonl"],
+    ["offbox-last-success.json", "last-success.json"]
+  ]) {
+    const legacyPath = join(home.statePath, legacyName);
+    if (!existsSync(legacyPath)) {
+      continue;
+    }
+    const currentPath = join(destination, currentName);
+    if (existsSync(currentPath)) {
+      rmSync(legacyPath);
+    } else {
+      renameSync(legacyPath, currentPath);
+    }
+  }
+  const legacyOutbox = join(home.statePath, "outbox");
+  if (existsSync(legacyOutbox)) {
+    const currentOutbox = join(destination, "outbox");
+    if (existsSync(currentOutbox)) {
+      rmSync(legacyOutbox, { recursive: true });
+    } else {
+      renameSync(legacyOutbox, currentOutbox);
+    }
+  }
+}
+function migrateLegacyConfig(home, legacy) {
+  const offbox = legacy.offbox.mode === "skipped" ? legacy.offbox : {
+    mode: "configured",
+    recipient: legacy.offbox.recipient,
+    remotes: [{ type: "rclone", ...legacy.offbox.remote }]
+  };
+  const migrated = { ...legacy, version: CONFIG_VERSION, offbox };
+  if (migrated.offbox.mode === "configured") {
+    migrateLegacyState(home, migrated.offbox.remotes[0]);
+  }
+  saveConfig(home, migrated);
+  return migrated;
+}
+function loadConfig(home) {
+  let raw;
+  try {
+    raw = readFileSync(home.configPath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new PackbatError(`no config at ${home.configPath} \u2014 run \`packbat init\` first`);
+    }
+    throw error;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new PackbatError(`${home.configPath} is not valid JSON: ${error.message}`);
+  }
+  const result = configSchema.safeParse(parsed);
+  if (result.success) {
+    return result.data;
+  }
+  const legacy = legacyConfigSchema.safeParse(parsed);
+  if (legacy.success) {
+    return migrateLegacyConfig(home, legacy.data);
+  }
+  throw new PackbatError(`${home.configPath} is invalid:
+${z.prettifyError(result.error)}`);
+}
+function saveConfig(home, config) {
+  mkdirSync(dirname(home.configPath), { recursive: true });
+  const tmp = join(dirname(home.configPath), `.config.json.tmp-${process.pid}`);
+  writeFileSync(tmp, `${JSON.stringify(config, null, "	")}
+`);
+  renameSync(tmp, home.configPath);
+}
+
+// src/core/home.ts
+import { homedir } from "os";
+import { join as join2 } from "path";
+function resolveHome(env = process.env) {
+  const override = env.PACKBAT_HOME?.trim();
+  const root = override ? override : join2(homedir(), ".packbat");
+  return {
+    root,
+    configPath: join2(root, "config.json"),
+    statePath: join2(root, "state"),
+    logsPath: join2(root, "logs"),
+    cachePath: join2(root, "cache"),
+    defaultArchiveRoot: join2(root, "archive"),
+    rcloneConfPath: join2(root, "rclone.conf")
+  };
+}
+
+// src/core/exec.ts
+import { accessSync, constants } from "fs";
+import { delimiter, join as join3 } from "path";
+function commandOnPath(command2, env = process.env) {
+  for (const directory of (env.PATH ?? "").split(delimiter)) {
+    if (directory === "") {
+      continue;
+    }
+    const candidate = join3(directory, command2);
+    try {
+      accessSync(candidate, constants.X_OK);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/commands/doctor.ts
+import pc from "picocolors";
+
+// src/doctor/facts.ts
+import { execFile } from "child_process";
+import { randomUUID } from "crypto";
+import { constants as constants2 } from "fs";
+import { access, mkdir, readFile as readFile3, rm, statfs, writeFile } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join12 } from "path";
+import * as zlib from "zlib";
+
+// src/adapters/registry.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join9 } from "path";
+
+// src/adapters/claude-code.ts
+import { join as join4 } from "path";
+
+// src/core/fs.ts
+import { lstatSync } from "fs";
+import { readdir, stat } from "fs/promises";
+function isEnoent(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+async function statOrNull(path) {
+  try {
+    return await stat(path);
+  } catch (error) {
+    if (isEnoent(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function readDirectoryOrEmpty(path) {
+  try {
+    return await readdir(path, { withFileTypes: true });
+  } catch (error) {
+    if (isEnoent(error)) {
+      return [];
+    }
+    throw error;
+  }
+}
+function pathExists(path) {
+  try {
+    lstatSync(path);
+    return true;
+  } catch (error) {
+    if (isEnoent(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+
+// src/adapters/adapter.ts
+var HARNESS_IDS = ["claude-code", "codex", "pi", "opencode", "gemini"];
+var UUID_SOURCE = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+function isHarnessId(value) {
+  return typeof value === "string" && HARNESS_IDS.some((id) => id === value);
+}
+
+// src/adapters/session-files.ts
+import { relative } from "path";
+async function toSessionFile(storeRoot, absPath, role) {
+  const stats = await statOrNull(absPath);
+  if (stats === null || !stats.isFile()) {
+    return null;
+  }
+  return {
+    absPath,
+    relPath: relative(storeRoot, absPath),
+    role,
+    sizeBytes: stats.size,
+    mtimeMs: stats.mtimeMs
+  };
+}
+
+// src/adapters/claude-code.ts
+var TRANSCRIPT_PATTERN = new RegExp(`^(${UUID_SOURCE})\\.jsonl$`, "i");
+var SIDECAR_DIRECTORY_PATTERN = new RegExp(`^(${UUID_SOURCE})$`, "i");
+async function walkSidecars(storeRoot, directory) {
+  const files = [];
+  const entries = (await readDirectoryOrEmpty(directory)).sort((left, right) => left.name.localeCompare(right.name));
+  for (const entry of entries) {
+    if (entry.name === ".DS_Store") {
+      continue;
+    }
+    const absPath = join4(directory, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await walkSidecars(storeRoot, absPath));
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    const file = await toSessionFile(storeRoot, absPath, "sidecar");
+    if (file !== null) {
+      files.push(file);
+    }
+  }
+  return files;
+}
+async function enumerateProject(storeRoot, projectDirectory) {
+  const units = /* @__PURE__ */ new Map();
+  const entries = (await readDirectoryOrEmpty(projectDirectory)).sort(
+    (left, right) => left.name.localeCompare(right.name)
+  );
+  for (const entry of entries) {
+    if (entry.name === ".DS_Store") {
+      continue;
+    }
+    const absPath = join4(projectDirectory, entry.name);
+    if (entry.isFile()) {
+      const match2 = TRANSCRIPT_PATTERN.exec(entry.name);
+      if (match2?.[1] === void 0) {
+        continue;
+      }
+      const file = await toSessionFile(storeRoot, absPath, "main");
+      if (file !== null) {
+        units.set(match2[1], { id: match2[1], files: [file, ...units.get(match2[1])?.files ?? []] });
+      }
+      continue;
+    }
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const match = SIDECAR_DIRECTORY_PATTERN.exec(entry.name);
+    if (match?.[1] === void 0) {
+      continue;
+    }
+    const sidecars = await walkSidecars(storeRoot, absPath);
+    if (sidecars.length > 0) {
+      const existing = units.get(match[1]);
+      units.set(match[1], { id: match[1], files: [...existing?.files ?? [], ...sidecars] });
+    }
+  }
+  return [...units.values()].sort((left, right) => left.id.localeCompare(right.id));
+}
+var claudeCodeAdapter = {
+  id: "claude-code",
+  displayName: "Claude Code",
+  mutationModel: "append-file",
+  retentionRisk: "Claude Code deletes sessions older than cleanupPeriodDays (30 days by default) at startup.",
+  storeRoot(env, home) {
+    const configRoot = env.CLAUDE_CONFIG_DIR ? env.CLAUDE_CONFIG_DIR : join4(home, ".claude");
+    return join4(configRoot, "projects");
+  },
+  async enumerate(storeRoot) {
+    const units = [];
+    const projects = (await readDirectoryOrEmpty(storeRoot)).sort((left, right) => left.name.localeCompare(right.name));
+    for (const project of projects) {
+      if (project.name === ".DS_Store" || !project.isDirectory()) {
+        continue;
+      }
+      units.push(...await enumerateProject(storeRoot, join4(storeRoot, project.name)));
+    }
+    return units;
+  },
+  restoreTarget(storeRoot, relPath) {
+    return join4(storeRoot, relPath);
+  },
+  resumeHint(unit) {
+    return ["Run from the original project directory:", `claude --resume ${unit.id}`];
+  }
+};
+
+// src/adapters/codex.ts
+import { join as join5, relative as relative2, sep } from "path";
+var ROLLOUT_PATTERN = new RegExp(`^rollout-.+-(${UUID_SOURCE})\\.jsonl$`, "i");
+var YEAR_PATTERN = /^\d{4}$/;
+var MONTH_OR_DAY_PATTERN = /^\d{2}$/;
+function rolloutId(relPath) {
+  const segments = relPath.split(sep);
+  const filename = segments.at(-1);
+  if (filename === void 0) {
+    return null;
+  }
+  const match = ROLLOUT_PATTERN.exec(filename);
+  if (match?.[1] === void 0) {
+    return null;
+  }
+  const isArchived = segments.length === 2 && segments[0] === "archived_sessions";
+  const isActive = segments.length === 5 && segments[0] === "sessions" && YEAR_PATTERN.test(segments[1] ?? "") && MONTH_OR_DAY_PATTERN.test(segments[2] ?? "") && MONTH_OR_DAY_PATTERN.test(segments[3] ?? "");
+  return isArchived || isActive ? match[1] : null;
+}
+async function walkRollouts(storeRoot, directory) {
+  const units = [];
+  const entries = (await readDirectoryOrEmpty(directory)).sort((left, right) => left.name.localeCompare(right.name));
+  for (const entry of entries) {
+    if (entry.name === ".DS_Store") {
+      continue;
+    }
+    const absPath = join5(directory, entry.name);
+    if (entry.isDirectory()) {
+      units.push(...await walkRollouts(storeRoot, absPath));
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    const relPath = relative2(storeRoot, absPath);
+    const id = rolloutId(relPath);
+    if (id === null) {
+      continue;
+    }
+    const stats = await statOrNull(absPath);
+    if (stats === null || !stats.isFile()) {
+      continue;
+    }
+    const file = {
+      absPath,
+      relPath,
+      role: "main",
+      sizeBytes: stats.size,
+      mtimeMs: stats.mtimeMs
+    };
+    units.push({ id, files: [file] });
+  }
+  return units;
+}
+var codexAdapter = {
+  id: "codex",
+  displayName: "Codex",
+  mutationModel: "append-file",
+  retentionRisk: null,
+  storeRoot(env, home) {
+    return env.CODEX_HOME ? env.CODEX_HOME : join5(home, ".codex");
+  },
+  async enumerate(storeRoot) {
+    const units = [
+      ...await walkRollouts(storeRoot, join5(storeRoot, "sessions")),
+      ...await walkRollouts(storeRoot, join5(storeRoot, "archived_sessions"))
+    ];
+    return units.sort((left, right) => left.files[0].relPath.localeCompare(right.files[0].relPath));
+  },
+  restoreTarget(storeRoot, relPath) {
+    return join5(storeRoot, relPath);
+  },
+  resumeHint(unit) {
+    const archivedPrefix = `archived_sessions${sep}`;
+    if (unit.relPaths.some((relPath) => relPath.startsWith(archivedPrefix))) {
+      return [`codex unarchive ${unit.id}`, `codex resume ${unit.id}`];
+    }
+    return [`codex resume ${unit.id}`];
+  }
+};
+
+// src/adapters/gemini.ts
+import { open } from "fs/promises";
+import { extname, join as join6 } from "path";
+var MAX_METADATA_BYTES = 64 * 1024;
+var SESSION_PATTERN = /^session-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-([0-9a-f]{8})\.jsonl?$/i;
+var UUID_PATTERN = new RegExp(`^${UUID_SOURCE}$`, "i");
+var LEGACY_ID_PREFIX_PATTERN = new RegExp(`^\\s*\\{\\s*"sessionId"\\s*:\\s*"(${UUID_SOURCE})"`, "i");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function readMetadataPrefix(path) {
+  let handle;
+  try {
+    handle = await open(path, "r");
+    const buffer = Buffer.alloc(MAX_METADATA_BYTES + 1);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    const newline = buffer.subarray(0, bytesRead).indexOf(10);
+    if (extname(path) === ".jsonl") {
+      if (newline < 0 && bytesRead > MAX_METADATA_BYTES) {
+        return null;
+      }
+      return { text: buffer.subarray(0, newline < 0 ? bytesRead : newline).toString("utf8"), complete: true };
+    }
+    return {
+      text: buffer.subarray(0, Math.min(bytesRead, MAX_METADATA_BYTES)).toString("utf8"),
+      complete: bytesRead <= MAX_METADATA_BYTES
+    };
+  } catch (error) {
+    if (isEnoent(error)) {
+      return null;
+    }
+    throw error;
+  } finally {
+    await handle?.close();
+  }
+}
+function sessionIdFromMetadata(path, metadata) {
+  try {
+    const parsed = JSON.parse(metadata.text);
+    if (!isRecord(parsed) || typeof parsed.sessionId !== "string" || !UUID_PATTERN.test(parsed.sessionId)) {
+      return null;
+    }
+    return parsed.kind === "subagent" ? null : parsed.sessionId;
+  } catch {
+    if (extname(path) !== ".json" || metadata.complete) {
+      return null;
+    }
+    return LEGACY_ID_PREFIX_PATTERN.exec(metadata.text)?.[1] ?? null;
+  }
+}
+async function enumerateProject2(storeRoot, projectDirectory) {
+  const marker = await toSessionFile(storeRoot, join6(projectDirectory, ".project_root"), "sidecar");
+  const chatsDirectory = join6(projectDirectory, "chats");
+  const entries = (await readDirectoryOrEmpty(chatsDirectory)).sort(
+    (left, right) => left.name.localeCompare(right.name)
+  );
+  const units = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const match = entry.isFile() ? SESSION_PATTERN.exec(entry.name) : null;
+    if (match?.[1] === void 0) {
+      continue;
+    }
+    const absPath = join6(chatsDirectory, entry.name);
+    const metadata = await readMetadataPrefix(absPath);
+    if (metadata === null) {
+      continue;
+    }
+    const id = sessionIdFromMetadata(absPath, metadata);
+    if (id === null || id.slice(0, 8).toLowerCase() !== match[1].toLowerCase()) {
+      continue;
+    }
+    const main = await toSessionFile(storeRoot, absPath, "main");
+    if (main === null) {
+      continue;
+    }
+    const existing = units.get(id);
+    if (existing === void 0) {
+      units.set(id, { id, files: marker === null ? [main] : [main, marker] });
+      continue;
+    }
+    const existingIsJsonl = extname(existing.files[0].absPath) === ".jsonl";
+    if (existingIsJsonl === (extname(absPath) === ".jsonl")) {
+      continue;
+    }
+    const [jsonlFile, legacyFile] = existingIsJsonl ? [existing.files[0], main] : [main, existing.files[0]];
+    const legacySidecar = { ...legacyFile, role: "sidecar" };
+    units.set(id, { id, files: marker === null ? [jsonlFile, legacySidecar] : [jsonlFile, legacySidecar, marker] });
+  }
+  return [...units.values()].sort((left, right) => left.files[0].relPath.localeCompare(right.files[0].relPath));
+}
+var geminiAdapter = {
+  id: "gemini",
+  displayName: "Gemini CLI",
+  mutationModel: "append-file",
+  // DRAFT copy
+  retentionRisk: "Gemini CLI deletes sessions older than general.sessionRetention.maxAge (30 days by default) at startup, including their associated artifacts.",
+  storeRoot(env, home) {
+    return join6(env.GEMINI_CLI_HOME || home, ".gemini", "tmp");
+  },
+  async enumerate(storeRoot) {
+    const units = [];
+    const projects = (await readDirectoryOrEmpty(storeRoot)).sort((left, right) => left.name.localeCompare(right.name));
+    for (const project of projects) {
+      if (!project.isDirectory()) {
+        continue;
+      }
+      units.push(...await enumerateProject2(storeRoot, join6(storeRoot, project.name)));
+    }
+    return units;
+  },
+  restoreTarget(storeRoot, relPath) {
+    return join6(storeRoot, relPath);
+  },
+  resumeHint(unit) {
+    return ["Run from the original project directory:", `gemini --resume ${unit.id}`];
+  }
+};
+
+// src/adapters/opencode.ts
+import { createHash as createHash2 } from "crypto";
+import { readFile } from "fs/promises";
+import { isAbsolute, join as join7 } from "path";
+var sqliteModule = "node:sqlite";
+var { backup, DatabaseSync } = await import(sqliteModule);
+function assertQuickCheck(database) {
+  const results = database.prepare("PRAGMA quick_check").all();
+  if (results.length !== 1 || results[0]?.quick_check !== "ok") {
+    throw new Error("OpenCode database failed PRAGMA quick_check");
+  }
+}
+function sessions(database) {
+  return database.prepare("SELECT id, time_created, time_updated FROM session ORDER BY id").all().map((row) => {
+    if (typeof row.id !== "string" || typeof row.time_created !== "number" || typeof row.time_updated !== "number") {
+      throw new Error("OpenCode session metadata has an unsupported shape");
+    }
+    return { id: row.id, timeCreated: row.time_created, timeUpdated: row.time_updated };
+  });
+}
+function softwareVersion(database) {
+  const row = database.prepare("SELECT version FROM session ORDER BY time_updated DESC, id DESC LIMIT 1").get();
+  if (row === void 0) {
+    return null;
+  }
+  if (typeof row.version !== "string") {
+    throw new Error("OpenCode version metadata has an unsupported shape");
+  }
+  return row.version;
+}
+async function enumerate(databasePath) {
+  const stats = await statOrNull(databasePath);
+  if (stats === null || !stats.isFile()) {
+    return [];
+  }
+  return [{ sourcePath: databasePath, sourceMtimeMs: stats.mtimeMs, sourceSize: stats.size }];
+}
+async function snapshot(unit, destination) {
+  const source = new DatabaseSync(unit.sourcePath, { readOnly: true });
+  try {
+    await backup(source, destination);
+  } finally {
+    source.close();
+  }
+  const completed = new DatabaseSync(destination, { readOnly: true });
+  let capturedSessions;
+  let capturedVersion;
+  try {
+    assertQuickCheck(completed);
+    capturedVersion = softwareVersion(completed);
+    capturedSessions = sessions(completed);
+  } finally {
+    completed.close();
+  }
+  const bytes = await readFile(destination);
+  return {
+    contentSha256: createHash2("sha256").update(bytes).digest("hex"),
+    sizeBytes: bytes.byteLength,
+    softwareVersion: capturedVersion,
+    sessions: capturedSessions
+  };
+}
+async function validateSnapshot(snapshotPath, sessionId) {
+  const database = new DatabaseSync(snapshotPath, { readOnly: true });
+  try {
+    assertQuickCheck(database);
+    if (database.prepare("SELECT 1 FROM session WHERE id = ?").get(sessionId) === void 0) {
+      throw new Error(`OpenCode snapshot does not contain session ${sessionId}`);
+    }
+  } finally {
+    database.close();
+  }
+}
+var openCodeAdapter = {
+  id: "opencode",
+  // DRAFT copy
+  displayName: "OpenCode",
+  mutationModel: "db-snapshot",
+  // DRAFT copy
+  retentionRisk: "OpenCode does not automatically prune session history; explicit deletion removes it from the shared SQLite database.",
+  snapshotFilename: "opencode.db.zst",
+  storeRoot(env, home) {
+    const dataHome = env.XDG_DATA_HOME ? env.XDG_DATA_HOME : join7(home, ".local", "share");
+    const dataRoot = join7(dataHome, "opencode");
+    if (env.OPENCODE_DB) {
+      return isAbsolute(env.OPENCODE_DB) ? env.OPENCODE_DB : join7(dataRoot, env.OPENCODE_DB);
+    }
+    return join7(dataRoot, "opencode.db");
+  },
+  enumerate,
+  snapshot,
+  validateSnapshot,
+  resumeHint(unit) {
+    return [`opencode -s ${unit.id}`];
+  }
+};
+
+// src/adapters/pi.ts
+import { join as join8, relative as relative3 } from "path";
+var SANITIZED_ISO_SOURCE = "\\d{4}-\\d{2}-\\d{2}T\\d{2}-\\d{2}-\\d{2}-\\d{3}Z";
+var SESSION_PATTERN2 = new RegExp(`^${SANITIZED_ISO_SOURCE}_(${UUID_SOURCE})\\.jsonl$`, "i");
+async function enumerateDirectory(storeRoot, directory) {
+  const units = [];
+  const entries = (await readDirectoryOrEmpty(directory)).sort((left, right) => left.name.localeCompare(right.name));
+  for (const entry of entries) {
+    if (entry.name === ".DS_Store" || !entry.isFile()) {
+      continue;
+    }
+    const match = SESSION_PATTERN2.exec(entry.name);
+    if (match?.[1] === void 0) {
+      continue;
+    }
+    const absPath = join8(directory, entry.name);
+    const stats = await statOrNull(absPath);
+    if (stats === null || !stats.isFile()) {
+      continue;
+    }
+    const file = {
+      absPath,
+      relPath: relative3(storeRoot, absPath),
+      role: "main",
+      sizeBytes: stats.size,
+      mtimeMs: stats.mtimeMs
+    };
+    units.push({ id: match[1], files: [file] });
+  }
+  return units;
+}
+var piAdapter = {
+  id: "pi",
+  displayName: "pi",
+  mutationModel: "rewrite-file",
+  retentionRisk: null,
+  storeRoot(env, home) {
+    return env.PI_CODING_AGENT_SESSION_DIR ? env.PI_CODING_AGENT_SESSION_DIR : join8(home, ".pi", "agent", "sessions");
+  },
+  async enumerate(storeRoot) {
+    const units = await enumerateDirectory(storeRoot, storeRoot);
+    const projects = (await readDirectoryOrEmpty(storeRoot)).sort((left, right) => left.name.localeCompare(right.name));
+    for (const project of projects) {
+      if (project.name === ".DS_Store" || !project.isDirectory()) {
+        continue;
+      }
+      units.push(...await enumerateDirectory(storeRoot, join8(storeRoot, project.name)));
+    }
+    return units.sort((left, right) => left.files[0].relPath.localeCompare(right.files[0].relPath));
+  },
+  restoreTarget(storeRoot, relPath) {
+    return join8(storeRoot, relPath);
+  },
+  resumeHint(unit) {
+    return [`pi --session ${unit.id}`];
+  }
+};
+
+// src/adapters/registry.ts
+var adapters = [
+  claudeCodeAdapter,
+  codexAdapter,
+  piAdapter,
+  openCodeAdapter,
+  geminiAdapter
+];
+function existingPath(path) {
+  return existsSync2(path) ? path : null;
+}
+var unsupportedStores = [
+  {
+    id: "cursor",
+    displayName: "Cursor CLI",
+    mutationModel: "undisclosed",
+    detect(_env, home) {
+      return existingPath(join9(home, ".cursor"));
+    }
+  }
+];
+function getAdapter(id) {
+  return adapters.find((adapter) => adapter.id === id);
+}
+
+// src/core/index.ts
+import { createHash as createHash3 } from "crypto";
+import { appendFile, readFile as readFile2 } from "fs/promises";
+import { basename, join as join10 } from "path";
+function isSnapshotSession(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const session = value;
+  return typeof session.id === "string" && typeof session.timeCreated === "number" && typeof session.timeUpdated === "number";
+}
+function isDatabaseSnapshotManifest(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const manifest = value;
+  return manifest.v === 1 && manifest.kind === "db-snapshot" && isHarnessId(manifest.harness) && typeof manifest.sourcePath === "string" && (manifest.harnessVersion === null || typeof manifest.harnessVersion === "string") && typeof manifest.snapshotAt === "string" && typeof manifest.contentSha256 === "string" && typeof manifest.sizeBytes === "number" && Array.isArray(manifest.sessions) && manifest.sessions.every(isSnapshotSession) && typeof manifest.payload === "string" && manifest.payload !== "" && basename(manifest.payload) === manifest.payload && !Number.isNaN(Date.parse(manifest.snapshotAt));
+}
+function isArchiveIndexRecord(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const record = value;
+  const common = record.v === 1 && typeof record.path === "string" && isHarnessId(record.harness) && typeof record.machine === "string" && typeof record.unit === "string" && typeof record.source === "string" && typeof record.sourceMtimeMs === "number" && typeof record.sourceSize === "number" && typeof record.storedSize === "number" && typeof record.sha256 === "string" && typeof record.archivedAt === "string";
+  if (!common) {
+    return false;
+  }
+  if (record.role === "main" || record.role === "sidecar") {
+    return true;
+  }
+  return record.role === "database" && typeof record.contentSha256 === "string" && typeof record.snapshotAt === "string" && (record.harnessVersion === null || typeof record.harnessVersion === "string") && Array.isArray(record.sessions) && record.sessions.every(isSnapshotSession);
+}
+function isDatabaseSnapshotIndexRecord(record) {
+  return record.role === "database";
+}
+function parseIndex(contents) {
+  const records = /* @__PURE__ */ new Map();
+  let corruptLines = 0;
+  for (const line of contents.split("\n")) {
+    if (line.trim() === "") {
+      continue;
+    }
+    try {
+      const record = JSON.parse(line);
+      if (!isArchiveIndexRecord(record)) {
+        corruptLines += 1;
+        continue;
+      }
+      records.set(record.path, record);
+    } catch {
+      corruptLines += 1;
+    }
+  }
+  return { records, corruptLines };
+}
+async function readIndex(path) {
+  try {
+    return parseIndex(await readFile2(path, "utf8"));
+  } catch (error) {
+    if (isEnoent(error)) {
+      return { records: /* @__PURE__ */ new Map(), corruptLines: 0 };
+    }
+    throw error;
+  }
+}
+async function readSnapshotIndexRecords(machineRoot, machine) {
+  const records = [];
+  for (const harness of HARNESS_IDS) {
+    const snapshotRoot = join10(machineRoot, harness, "snapshots");
+    const directories = (await readDirectoryOrEmpty(snapshotRoot)).filter((entry) => entry.isDirectory());
+    for (const directory of directories) {
+      let value;
+      try {
+        value = JSON.parse(await readFile2(join10(snapshotRoot, directory.name, "manifest.json"), "utf8"));
+      } catch (error) {
+        if (isEnoent(error) || error instanceof SyntaxError) {
+          continue;
+        }
+        throw error;
+      }
+      if (!isDatabaseSnapshotManifest(value) || value.harness !== harness) {
+        continue;
+      }
+      const payloadPath = join10(snapshotRoot, directory.name, value.payload);
+      const payloadStat = await statOrNull(payloadPath);
+      if (payloadStat === null || !payloadStat.isFile()) {
+        continue;
+      }
+      const storedBytes = await readFile2(payloadPath);
+      records.push({
+        v: 1,
+        path: join10(harness, "snapshots", directory.name, value.payload),
+        harness,
+        machine,
+        unit: value.contentSha256,
+        role: "database",
+        source: value.sourcePath,
+        sourceMtimeMs: Date.parse(value.snapshotAt),
+        sourceSize: value.sizeBytes,
+        storedSize: storedBytes.byteLength,
+        sha256: createHash3("sha256").update(storedBytes).digest("hex"),
+        archivedAt: value.snapshotAt,
+        contentSha256: value.contentSha256,
+        snapshotAt: value.snapshotAt,
+        harnessVersion: value.harnessVersion,
+        sessions: value.sessions
+      });
+    }
+  }
+  return records;
+}
+async function readDerivedIndex(machineRoot, machine) {
+  const index = await readIndex(join10(machineRoot, "index.jsonl"));
+  for (const record of await readSnapshotIndexRecords(machineRoot, machine)) {
+    index.records.set(record.path, record);
+  }
+  return index;
+}
+async function appendIndex(path, record) {
+  await appendFile(path, `${JSON.stringify(record)}
+`);
+}
+
+// src/schedule/cron.ts
+var CRON_MARKER = "# packbat-sync";
+function shellQuote(value) {
+  return `'${value.replaceAll("'", `'"'"'`).replaceAll("%", "\\%")}'`;
+}
+function isPackbatEntry(line) {
+  return line.trimEnd().endsWith(CRON_MARKER);
+}
+function generateCronEntry(options) {
+  const environment = [...options.environment].map(([key, value]) => `${key}=${shellQuote(value)} `).join("");
+  return `3 * * * * ${environment}${shellQuote(options.nodePath)} ${shellQuote(options.entryPath)} ${shellQuote("sync")} ${CRON_MARKER}`;
+}
+function stripCronEntry(contents) {
+  const hadTrailingNewline = contents.endsWith("\n");
+  const lines = contents.split("\n");
+  if (hadTrailingNewline) {
+    lines.pop();
+  }
+  const foreignLines = lines.filter((line) => !isPackbatEntry(line));
+  if (foreignLines.length === 0) {
+    return "";
+  }
+  return `${foreignLines.join("\n")}${hadTrailingNewline ? "\n" : ""}`;
+}
+function mergeCronTab(contents, entry) {
+  const foreign = stripCronEntry(contents);
+  const separator = foreign === "" || foreign.endsWith("\n") ? "" : "\n";
+  return `${foreign}${separator}${entry}
+`;
+}
+
+// src/schedule/launchd.ts
+import { join as join11 } from "path";
+var LAUNCHD_LABEL = "dev.packbat.sync";
+function escapeXmlText(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function generateLaunchdPlist(options) {
+  const environment = options.environment.size === 0 ? "" : `	<key>EnvironmentVariables</key>
+	<dict>
+${[...options.environment].map(([key, value]) => `		<key>${escapeXmlText(key)}</key>
+		<string>${escapeXmlText(value)}</string>
+`).join("")}	</dict>
+`;
+  const logPath = escapeXmlText(join11(options.logsPath, "launchd.log"));
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>Label</key>
+	<string>${LAUNCHD_LABEL}</string>
+	<key>ProgramArguments</key>
+	<array>
+		<string>${escapeXmlText(options.nodePath)}</string>
+		<string>${escapeXmlText(options.entryPath)}</string>
+		<string>sync</string>
+	</array>
+${environment}	<key>StartCalendarInterval</key>
+	<dict>
+		<key>Minute</key>
+		<integer>3</integer>
+	</dict>
+	<key>RunAtLoad</key>
+	<true/>
+	<key>ProcessType</key>
+	<string>Background</string>
+	<key>StandardOutPath</key>
+	<string>${logPath}</string>
+	<key>StandardErrorPath</key>
+	<string>${logPath}</string>
+</dict>
+</plist>
+`;
+}
+
+// src/schedule/systemd.ts
+var SYSTEMD_SERVICE = "packbat-sync.service";
+var SYSTEMD_TIMER = "packbat-sync.timer";
+function quoteSystemdValue(value) {
+  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("%", "%%").replaceAll("\n", "\\n")}"`;
+}
+function generateSystemdService(options) {
+  const environment = [...options.environment].map(([key, value]) => `Environment=${quoteSystemdValue(`${key}=${value}`)}
+`).join("");
+  return `[Unit]
+Description=Archive AI agent sessions with Packbat
+
+[Service]
+Type=oneshot
+ExecStart=${quoteSystemdValue(options.nodePath)} ${quoteSystemdValue(options.entryPath)} ${quoteSystemdValue("sync")}
+${environment}`;
+}
+function generateSystemdTimer() {
+  return `[Unit]
+Description=Run Packbat sync hourly
+
+[Timer]
+OnCalendar=*-*-* *:03:00
+Persistent=true
+Unit=${SYSTEMD_SERVICE}
+
+[Install]
+WantedBy=timers.target
+`;
+}
+
+// src/doctor/facts.ts
+var MINIMUM_FREE_BYTES = 500 * 1024 * 1024;
+function fact(id, status, detail, data) {
+  return { id, title: id, status, detail, ...data === void 0 ? {} : { data } };
+}
+function createDoctorContext(config, home, env = process.env, now = /* @__PURE__ */ new Date()) {
+  const configuredHome = env.HOME?.trim();
+  return { config, home, userHome: configuredHome ? configuredHome : homedir2(), env, now };
+}
+async function command(commandPath, args, env) {
+  return await new Promise((resolve) => {
+    execFile(commandPath, args, { encoding: "utf8", env }, (error, stdout, stderr) => {
+      resolve({ ok: error === null, stdout, stderr });
+    });
+  });
+}
+function decodeXml(value) {
+  return value.replaceAll("&quot;", '"').replaceAll("&gt;", ">").replaceAll("&lt;", "<").replaceAll("&amp;", "&");
+}
+function launchdArguments(contents) {
+  const section = /<key>ProgramArguments<\/key>\s*<array>([\s\S]*?)<\/array>/.exec(contents)?.[1];
+  if (section === void 0) {
+    return null;
+  }
+  return [...section.matchAll(/<string>([\s\S]*?)<\/string>/g)].map((match) => decodeXml(match[1] ?? ""));
+}
+function launchdEnvironment(contents) {
+  const marker = "<key>EnvironmentVariables</key>";
+  if (!contents.includes(marker)) {
+    return /* @__PURE__ */ new Map();
+  }
+  const section = /<key>EnvironmentVariables<\/key>\s*<dict>([\s\S]*?)<\/dict>/.exec(contents)?.[1];
+  if (section === void 0) {
+    return null;
+  }
+  const pairPattern = /<key>([\s\S]*?)<\/key>\s*<string>([\s\S]*?)<\/string>/g;
+  if (section.replace(pairPattern, "").trim() !== "") {
+    return null;
+  }
+  return new Map(
+    [...section.matchAll(pairPattern)].map((match) => [decodeXml(match[1] ?? ""), decodeXml(match[2] ?? "")])
+  );
+}
+function decodeSystemdValue(value) {
+  return value.replaceAll("%%", "%").replaceAll("\\n", "\n").replaceAll('\\"', '"').replaceAll("\\\\", "\\");
+}
+function systemdArguments(contents) {
+  const line = /^ExecStart=(.+)$/m.exec(contents)?.[1];
+  if (line === void 0) {
+    return null;
+  }
+  const values = [...line.matchAll(/"((?:\\.|[^"])*)"/g)].map((match) => decodeSystemdValue(match[1] ?? ""));
+  return values.length === 3 ? values : null;
+}
+function systemdEnvironment(contents) {
+  const environment = /* @__PURE__ */ new Map();
+  for (const line of contents.split("\n")) {
+    if (!line.startsWith("Environment=")) {
+      continue;
+    }
+    const encoded = /^Environment="((?:\\.|[^"])*)"$/.exec(line)?.[1];
+    if (encoded === void 0) {
+      return null;
+    }
+    const assignment = decodeSystemdValue(encoded);
+    const separator = assignment.indexOf("=");
+    if (separator <= 0) {
+      return null;
+    }
+    environment.set(assignment.slice(0, separator), assignment.slice(separator + 1));
+  }
+  return environment;
+}
+function shellQuotedToken(input, start) {
+  if (input[start] !== "'") {
+    return null;
+  }
+  let value = "";
+  let index = start + 1;
+  while (index < input.length) {
+    if (input.startsWith(`'"'"'`, index)) {
+      value += "'";
+      index += 5;
+      continue;
+    }
+    const character = input[index];
+    if (character === "'") {
+      return { value: value.replaceAll("\\%", "%"), next: index + 1 };
+    }
+    value += character;
+    index += 1;
+  }
+  return null;
+}
+function cronArguments(contents) {
+  const line = contents.trimEnd();
+  const prefix = "3 * * * * ";
+  if (!line.startsWith(prefix) || !line.endsWith(` ${CRON_MARKER}`)) {
+    return null;
+  }
+  let index = prefix.length;
+  const environment = /* @__PURE__ */ new Map();
+  while (true) {
+    const assignment = /^([A-Z][A-Z0-9_]*)=/.exec(line.slice(index));
+    const key = assignment?.[1];
+    if (assignment === null || key === void 0) {
+      break;
+    }
+    index += assignment[0].length;
+    const value = shellQuotedToken(line, index);
+    if (value === null || line[value.next] !== " ") {
+      return null;
+    }
+    environment.set(key, value.value);
+    index = value.next + 1;
+  }
+  const node = shellQuotedToken(line, index);
+  if (node === null || line[node.next] !== " ") {
+    return null;
+  }
+  const entry = shellQuotedToken(line, node.next + 1);
+  if (entry === null || line[entry.next] !== " ") {
+    return null;
+  }
+  const sync = shellQuotedToken(line, entry.next + 1);
+  if (sync === null || sync.value !== "sync" || line.slice(sync.next) !== ` ${CRON_MARKER}`) {
+    return null;
+  }
+  return { nodePath: node.value, entryPath: entry.value, environment };
+}
+async function executablePathsExist(nodePath, entryPath) {
+  const missing = [];
+  for (const path of [nodePath, entryPath]) {
+    try {
+      await access(path, constants2.F_OK);
+    } catch {
+      missing.push(path);
+    }
+  }
+  return missing;
+}
+function installedData(schedule) {
+  return {
+    kind: schedule.kind,
+    artifactPaths: schedule.artifactPaths,
+    nodePath: schedule.nodePath,
+    entryPath: schedule.entryPath
+  };
+}
+async function checkLaunchdInstalled(context) {
+  const artifactPath = join12(context.userHome, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+  let contents;
+  try {
+    contents = await readFile3(artifactPath, "utf8");
+  } catch (error) {
+    if (isEnoent(error)) {
+      return { fact: fact("installed", "problem", `missing ${artifactPath}`), schedule: null };
+    }
+    return { fact: fact("installed", "problem", `cannot read ${artifactPath}`), schedule: null };
+  }
+  const args = launchdArguments(contents);
+  const environment = launchdEnvironment(contents);
+  if (args === null || environment === null || args.length !== 3 || args[2] !== "sync") {
+    return { fact: fact("installed", "problem", "launchd artifact does not match Packbat's schedule"), schedule: null };
+  }
+  const nodePath = args[0] ?? "";
+  const entryPath = args[1] ?? "";
+  const expected = generateLaunchdPlist({
+    nodePath,
+    entryPath,
+    logsPath: context.home.logsPath,
+    environment
+  });
+  const schedule = { kind: "launchd", artifactPaths: [artifactPath], nodePath, entryPath };
+  if (contents !== expected) {
+    return {
+      fact: fact("installed", "problem", "launchd artifact does not match Packbat's schedule", installedData(schedule)),
+      schedule
+    };
+  }
+  const missingPaths = await executablePathsExist(nodePath, entryPath);
+  if (missingPaths.length > 0) {
+    return {
+      fact: fact("installed", "problem", `scheduled path missing: ${missingPaths.join(", ")}`, installedData(schedule)),
+      schedule
+    };
+  }
+  return { fact: fact("installed", "ok", "launchd schedule matches", installedData(schedule)), schedule };
+}
+function systemdArtifactPaths(userHome3) {
+  const root = join12(userHome3, ".config", "systemd", "user");
+  return { service: join12(root, SYSTEMD_SERVICE), timer: join12(root, SYSTEMD_TIMER) };
+}
+async function checkSystemdInstalled(context) {
+  const paths = systemdArtifactPaths(context.userHome);
+  let service;
+  let timer;
+  try {
+    [service, timer] = await Promise.all([readFile3(paths.service, "utf8"), readFile3(paths.timer, "utf8")]);
+  } catch {
+    return {
+      fact: fact("installed", "problem", `missing or unreadable ${SYSTEMD_SERVICE} / ${SYSTEMD_TIMER}`),
+      schedule: null
+    };
+  }
+  const args = systemdArguments(service);
+  const environment = systemdEnvironment(service);
+  if (args === null || environment === null || args[2] !== "sync") {
+    return { fact: fact("installed", "problem", "systemd artifacts do not match Packbat's schedule"), schedule: null };
+  }
+  const nodePath = args[0] ?? "";
+  const entryPath = args[1] ?? "";
+  const schedule = {
+    kind: "systemd",
+    artifactPaths: [paths.service, paths.timer],
+    nodePath,
+    entryPath
+  };
+  const expectedService = generateSystemdService({
+    nodePath,
+    entryPath,
+    environment
+  });
+  if (service !== expectedService || timer !== generateSystemdTimer()) {
+    return {
+      fact: fact("installed", "problem", "systemd artifacts do not match Packbat's schedule", installedData(schedule)),
+      schedule
+    };
+  }
+  const missingPaths = await executablePathsExist(nodePath, entryPath);
+  if (missingPaths.length > 0) {
+    return {
+      fact: fact("installed", "problem", `scheduled path missing: ${missingPaths.join(", ")}`, installedData(schedule)),
+      schedule
+    };
+  }
+  return { fact: fact("installed", "ok", "systemd schedule matches", installedData(schedule)), schedule };
+}
+async function checkCronInstalled(context) {
+  const artifactPath = join12(context.home.statePath, "schedule.cron");
+  let contents;
+  try {
+    contents = await readFile3(artifactPath, "utf8");
+  } catch {
+    return { fact: fact("installed", "problem", `missing or unreadable ${artifactPath}`), schedule: null };
+  }
+  const args = cronArguments(contents);
+  if (args === null) {
+    return { fact: fact("installed", "problem", "cron artifact does not match Packbat's schedule"), schedule: null };
+  }
+  const schedule = {
+    kind: "cron",
+    artifactPaths: [artifactPath],
+    nodePath: args.nodePath,
+    entryPath: args.entryPath
+  };
+  const expected = `${generateCronEntry({
+    nodePath: args.nodePath,
+    entryPath: args.entryPath,
+    environment: args.environment
+  })}
+`;
+  if (contents !== expected) {
+    return {
+      fact: fact("installed", "problem", "cron artifact does not match Packbat's schedule", installedData(schedule)),
+      schedule
+    };
+  }
+  const missingPaths = await executablePathsExist(args.nodePath, args.entryPath);
+  if (missingPaths.length > 0) {
+    return {
+      fact: fact("installed", "problem", `scheduled path missing: ${missingPaths.join(", ")}`, installedData(schedule)),
+      schedule
+    };
+  }
+  return { fact: fact("installed", "ok", "cron schedule matches", installedData(schedule)), schedule };
+}
+async function checkInstalled(context) {
+  if (process.platform === "darwin") {
+    return await checkLaunchdInstalled(context);
+  }
+  if (process.platform === "linux") {
+    const paths = systemdArtifactPaths(context.userHome);
+    const hasSystemdArtifact = pathExists(paths.service) || pathExists(paths.timer);
+    const hasCronArtifact = pathExists(join12(context.home.statePath, "schedule.cron"));
+    if (hasSystemdArtifact && !hasCronArtifact) {
+      return await checkSystemdInstalled(context);
+    }
+    if (hasCronArtifact && !hasSystemdArtifact) {
+      return await checkCronInstalled(context);
+    }
+    return commandOnPath("systemctl", context.env) !== null ? await checkSystemdInstalled(context) : await checkCronInstalled(context);
+  }
+  return {
+    fact: fact("installed", "problem", `scheduling is not supported on ${process.platform}`),
+    schedule: null
+  };
+}
+function parseLaunchdExitStatus(output) {
+  const match = /last exit (?:code|status)\s*=\s*(-?\d+)/i.exec(output);
+  if (match?.[1] === void 0) {
+    return null;
+  }
+  const value = Number.parseInt(match[1], 10);
+  return Number.isNaN(value) ? null : value;
+}
+function parseLaunchdArtifactPath(output) {
+  return /^\s*path\s*=\s*(.+?)\s*$/im.exec(output)?.[1] ?? null;
+}
+async function checkLaunchdLive(context, schedule) {
+  if (process.getuid === void 0) {
+    return fact("live", "problem", "launchd user domain is unavailable");
+  }
+  const target = `gui/${process.getuid()}/${LAUNCHD_LABEL}`;
+  const result = await command("launchctl", ["print", target], context.env);
+  if (!result.ok) {
+    return fact("live", "problem", `launchd job is not loaded (${target})`);
+  }
+  const expectedPath = schedule.artifactPaths[0] ?? "";
+  const loadedPath = parseLaunchdArtifactPath(result.stdout);
+  if (loadedPath === null) {
+    return fact("live", "problem", `launchd job artifact path is unavailable; expected ${expectedPath}`, {
+      expectedPath
+    });
+  }
+  if (loadedPath !== expectedPath) {
+    return fact("live", "problem", `launchd job is loaded from ${loadedPath}; expected ${expectedPath}`, {
+      loadedPath,
+      expectedPath
+    });
+  }
+  const exitStatus = parseLaunchdExitStatus(result.stdout);
+  if (exitStatus === null) {
+    return fact("live", "info", "loaded, state unverified");
+  }
+  return exitStatus === 0 ? fact("live", "ok", "loaded, last exit 0", { exitStatus }) : fact("live", "problem", `loaded, last exit ${exitStatus}`, { exitStatus });
+}
+function parseProperties(contents) {
+  const properties = {};
+  for (const line of contents.split("\n")) {
+    const separator = line.indexOf("=");
+    if (separator > 0) {
+      properties[line.slice(0, separator)] = line.slice(separator + 1);
+    }
+  }
+  return properties;
+}
+async function checkSystemdLive(context) {
+  const result = await command(
+    "systemctl",
+    ["--user", "show", SYSTEMD_TIMER, "--property=LoadState,UnitFileState,ActiveState"],
+    context.env
+  );
+  if (!result.ok) {
+    return fact("live", "problem", `${SYSTEMD_TIMER} could not be inspected`);
+  }
+  const properties = parseProperties(result.stdout);
+  const expected = { LoadState: "loaded", UnitFileState: "enabled", ActiveState: "active" };
+  const problems = Object.entries(expected).filter(([key, value]) => properties[key] !== value).map(([key, value]) => `${key}=${properties[key] ?? "missing"} (want ${value})`);
+  return problems.length === 0 ? fact("live", "ok", "systemd timer is loaded, enabled, active", properties) : fact("live", "problem", problems.join(", "), properties);
+}
+async function checkCronLive(context) {
+  const result = await command("crontab", ["-l"], context.env);
+  if (!result.ok) {
+    return fact("live", "problem", "Packbat marker is absent from crontab");
+  }
+  const present = result.stdout.split("\n").some((line) => line.trimEnd().endsWith(CRON_MARKER));
+  return present ? fact("live", "info", "cron marker is present; cron cannot prove execution") : fact("live", "problem", "Packbat marker is absent from crontab");
+}
+async function checkLive(context, installed, options = { probe: true }) {
+  if (!options.probe) {
+    return fact("live", "info", "live state not checked; run `packbat doctor`");
+  }
+  if (installed.schedule === null) {
+    return fact("live", "problem", "schedule state cannot be checked until it is installed");
+  }
+  switch (installed.schedule.kind) {
+    case "launchd":
+      return await checkLaunchdLive(context, installed.schedule);
+    case "systemd":
+      return await checkSystemdLive(context);
+    case "cron":
+      return await checkCronLive(context);
+  }
+}
+function isRunStamp(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const record = value;
+  return typeof record.startedAt === "string" && typeof record.finishedAt === "string" && typeof record.ok === "boolean" && typeof record.archived === "number" && typeof record.unchanged === "number" && typeof record.failed === "number" && (record.repaired === void 0 || typeof record.repaired === "number");
+}
+async function readStamp(path) {
+  let raw;
+  try {
+    raw = await readFile3(path, "utf8");
+  } catch (error) {
+    if (isEnoent(error)) {
+      return { kind: "missing" };
+    }
+    return { kind: "invalid", detail: "unreadable" };
+  }
+  try {
+    const value = JSON.parse(raw);
+    if (!isRunStamp(value)) {
+      return { kind: "invalid", detail: "invalid shape" };
+    }
+    const finishedAtMs = Date.parse(value.finishedAt);
+    return Number.isNaN(finishedAtMs) ? { kind: "invalid", detail: "invalid finishedAt" } : { kind: "value", value, finishedAtMs };
+  } catch {
+    return { kind: "invalid", detail: "invalid JSON" };
+  }
+}
+function windowMs(context) {
+  return context.config.sweep.intervalMinutes * 2 * 60 * 1e3;
+}
+function ageMs(timestampMs, now) {
+  return Math.max(0, now.getTime() - timestampMs);
+}
+function formatAge(milliseconds) {
+  const seconds = Math.floor(milliseconds / 1e3);
+  if (seconds < 60) {
+    return `${seconds}s ago`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) {
+    return `${minutes}m ago`;
+  }
+  const hours = Math.floor(minutes / 60);
+  if (hours < 48) {
+    return `${hours}h ago`;
+  }
+  return `${Math.floor(hours / 24)}d ago`;
+}
+async function checkFresh(context) {
+  const [lastRun, lastSuccess] = await Promise.all([
+    readStamp(join12(context.home.statePath, "last-run.json")),
+    readStamp(join12(context.home.statePath, "last-success.json"))
+  ]);
+  if (lastSuccess.kind === "missing") {
+    return { fact: fact("fresh", "problem", "never succeeded"), lastRun, lastSuccess };
+  }
+  if (lastSuccess.kind === "invalid") {
+    return {
+      fact: fact("fresh", "problem", `last-success is ${lastSuccess.detail}`),
+      lastRun,
+      lastSuccess
+    };
+  }
+  const successAgeMs = ageMs(lastSuccess.finishedAtMs, context.now);
+  const fresh = successAgeMs < windowMs(context);
+  if (fresh) {
+    return {
+      fact: fact("fresh", "ok", `last success ${formatAge(successAgeMs)}`, { lastSuccess: lastSuccess.value }),
+      lastRun,
+      lastSuccess
+    };
+  }
+  let detail = `last success ${formatAge(successAgeMs)}`;
+  if (lastRun.kind === "value" && !lastRun.value.ok && ageMs(lastRun.finishedAtMs, context.now) < windowMs(context)) {
+    detail += `; latest run failed ${formatAge(ageMs(lastRun.finishedAtMs, context.now))}`;
+  }
+  return {
+    fact: fact("fresh", "problem", detail, { lastSuccess: lastSuccess.value }),
+    lastRun,
+    lastSuccess
+  };
+}
+function retentionFact() {
+  const risks = adapters.flatMap(
+    (adapter) => adapter.retentionRisk === null ? [] : [
+      {
+        harness: adapter.id,
+        risk: adapter.retentionRisk
+      }
+    ]
+  );
+  return fact(
+    "retention",
+    "info",
+    // DRAFT copy
+    risks.map(({ harness, risk }) => `${harness}: ${risk.replace(/\.$/, "")}; the hourly sweep stays ahead of it`).join("\n"),
+    { risks }
+  );
+}
+async function unsupportedStoreFacts(context) {
+  const facts = [];
+  for (const store of unsupportedStores) {
+    const path = store.detect(context.env, context.userHome);
+    if (path !== null) {
+      facts.push(fact(`unsupported-${store.id}`, "info", `found ${store.id} at ${path} \u2014 not yet supported`, { path }));
+    }
+  }
+  return facts;
+}
+async function storeReadabilityFact(context) {
+  const unreadable = [];
+  const present = [];
+  for (const adapter of adapters) {
+    const path = adapter.storeRoot(context.env, context.userHome);
+    try {
+      await access(path, constants2.F_OK);
+      present.push(path);
+      await access(path, constants2.R_OK);
+    } catch (error) {
+      if (!isEnoent(error)) {
+        unreadable.push(path);
+      }
+    }
+  }
+  return unreadable.length === 0 ? fact(
+    "stores-readable",
+    "ok",
+    `${present.length} existing source store${present.length === 1 ? " is" : "s are"} readable`,
+    {
+      present
+    }
+  ) : fact("stores-readable", "problem", `unreadable: ${unreadable.join(", ")}`, { present, unreadable });
+}
+async function archiveWritableFact(context) {
+  const probePath = join12(context.config.archiveRoot, `.packbat-doctor-${process.pid}-${randomUUID()}`);
+  try {
+    await mkdir(context.config.archiveRoot, { recursive: true });
+    await writeFile(probePath, "packbat doctor\n");
+    await rm(probePath);
+    return fact("archive-writable", "ok", `writable: ${context.config.archiveRoot}`);
+  } catch (error) {
+    await rm(probePath, { force: true }).catch(() => void 0);
+    return fact(
+      "archive-writable",
+      "problem",
+      `cannot write ${context.config.archiveRoot}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function diskHeadroomFact(context) {
+  try {
+    const stats = await statfs(context.config.archiveRoot);
+    const freeBytes = stats.bavail * stats.bsize;
+    const freeMiB = Math.floor(freeBytes / 1024 / 1024);
+    return freeBytes < MINIMUM_FREE_BYTES ? fact("disk-headroom", "problem", `${freeMiB} MiB free; need at least 500 MiB`, { freeBytes }) : fact("disk-headroom", "ok", `${freeMiB} MiB free`, { freeBytes });
+  } catch (error) {
+    return fact(
+      "disk-headroom",
+      "problem",
+      `cannot inspect ${context.config.archiveRoot}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function compressionFact() {
+  try {
+    if (typeof zlib.zstdCompressSync !== "function" || typeof zlib.zstdDecompressSync !== "function") {
+      throw new Error("zstd is unavailable");
+    }
+    const source = Buffer.from("packbat compression smoke\n", "utf8");
+    const restored = zlib.zstdDecompressSync(zlib.zstdCompressSync(source));
+    if (!restored.equals(source)) {
+      throw new Error("round-trip mismatch");
+    }
+    return fact("compression", "ok", "zstd round-trip passed");
+  } catch (error) {
+    return fact(
+      "compression",
+      "problem",
+      `zstd round-trip failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function checkRemoteOffbox(context, remote) {
+  const prefix = `${remote.destination} \xB7 `;
+  const path = join12(remoteStatePath(context.home, remote), "last-success.json");
+  let value;
+  try {
+    value = JSON.parse(await readFile3(path, "utf8"));
+  } catch (error) {
+    if (isEnoent(error)) {
+      return fact("offbox", "problem", `${prefix}off-box has never succeeded`);
+    }
+    return fact("offbox", "problem", `${prefix}last-success is unreadable or invalid`);
+  }
+  const rawFinishedAt = typeof value === "object" && value !== null ? value.finishedAt : void 0;
+  const finishedAt = typeof rawFinishedAt === "string" ? rawFinishedAt : null;
+  const finishedAtMs = finishedAt === null ? Number.NaN : Date.parse(finishedAt);
+  if (Number.isNaN(finishedAtMs)) {
+    return fact("offbox", "problem", `${prefix}last-success has an invalid finishedAt`);
+  }
+  const elapsed = ageMs(finishedAtMs, context.now);
+  return elapsed < windowMs(context) ? fact("offbox", "ok", `${prefix}last off-box success ${formatAge(elapsed)}`, {
+    finishedAt,
+    destination: remote.destination
+  }) : fact("offbox", "problem", `${prefix}last off-box success ${formatAge(elapsed)}`, {
+    finishedAt,
+    destination: remote.destination
+  });
+}
+async function checkOffbox(context) {
+  if (context.config.offbox.mode === "skipped") {
+    return [fact("offbox", "info", `off-box skipped on ${context.config.offbox.skippedAt.slice(0, 10)}`)];
+  }
+  return await Promise.all(
+    context.config.offbox.remotes.map(async (remote) => await checkRemoteOffbox(context, remote))
+  );
+}
+async function collectEnvironmentFacts(context) {
+  const unsupported = await unsupportedStoreFacts(context);
+  const readable = await storeReadabilityFact(context);
+  const writable = await archiveWritableFact(context);
+  const disk = await diskHeadroomFact(context);
+  const compression = compressionFact();
+  const offbox = await checkOffbox(context);
+  return [...unsupported, readable, writable, disk, compression, ...offbox];
+}
+async function readHarnessTallies(context) {
+  const machineRoot = join12(context.config.archiveRoot, context.config.machine);
+  const index = await readDerivedIndex(machineRoot, context.config.machine);
+  return adapters.map((adapter) => {
+    const records = [...index.records.values()].filter((record) => record.harness === adapter.id);
+    return {
+      harness: adapter.id,
+      units: new Set(records.map((record) => record.unit)).size,
+      files: records.length,
+      storedBytes: records.reduce((sum, record) => sum + record.storedSize, 0)
+    };
+  });
+}
+function remedyForFact(item) {
+  if (item.id === "installed") {
+    return "re-run `packbat init`";
+  }
+  if (item.id === "live") {
+    return "re-run `packbat init` and inspect the scheduler";
+  }
+  if (item.id === "fresh") {
+    return "run `packbat sync` and inspect the log; Claude Code's 30-day cleanup keeps running while sweeps fail";
+  }
+  if (item.id === "reconciled") {
+    return "run `packbat sync`";
+  }
+  if (item.id === "stores-readable") {
+    return "fix read access to the listed store roots";
+  }
+  if (item.id === "archive-writable") {
+    return "fix write access to the archive root";
+  }
+  if (item.id === "disk-headroom") {
+    return "free at least 500 MiB at the archive root";
+  }
+  if (item.id === "compression") {
+    return "use Node 22.15 or newer";
+  }
+  if (item.id === "offbox") {
+    return "run the off-box sync and inspect its log";
+  }
+  return "inspect this check and retry";
+}
+
+// src/doctor/reconcile.ts
+import { mkdtemp, rm as rm4, stat as stat4 } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join16, relative as relative4, sep as sep2 } from "path";
+
+// src/core/archive.ts
+import { createHash as createHash5, randomUUID as randomUUID4 } from "crypto";
+import { mkdir as mkdir3, readFile as readFile5, rm as rm3, stat as stat3, utimes as utimes2 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname4, join as join15 } from "path";
+
+// src/core/compress.ts
+import { createHash as createHash4, randomUUID as randomUUID2 } from "crypto";
+import { readFile as readFile4, rename, rm as rm2, stat as stat2, utimes, writeFile as writeFile2 } from "fs/promises";
+import { basename as basename2, dirname as dirname2, join as join13 } from "path";
+import * as zlib2 from "zlib";
+function assertZstdSupport() {
+  if (typeof zlib2.zstdCompressSync !== "function" || typeof zlib2.zstdDecompressSync !== "function") {
+    throw new PackbatError("zstd compression requires Node >= 22.16");
+  }
+}
+async function compressFile(source, destination) {
+  assertZstdSupport();
+  const sourceStat = await stat2(source);
+  const sourceBytes = await readFile4(source);
+  const storedBytes = zlib2.zstdCompressSync(sourceBytes);
+  const temporary = join13(dirname2(destination), `.${basename2(destination)}.tmp-${process.pid}-${randomUUID2()}`);
+  try {
+    await writeFile2(temporary, storedBytes);
+    await rename(temporary, destination);
+  } catch (error) {
+    await rm2(temporary, { force: true });
+    throw error;
+  }
+  await utimes(destination, sourceStat.atimeMs / 1e3, sourceStat.mtimeMs / 1e3);
+  return {
+    sourceMtimeMs: sourceStat.mtimeMs,
+    sourceSize: sourceStat.size,
+    storedSize: storedBytes.byteLength,
+    sha256: createHash4("sha256").update(storedBytes).digest("hex")
+  };
+}
+function decompressBytes(bytes) {
+  assertZstdSupport();
+  return zlib2.zstdDecompressSync(bytes);
+}
+
+// src/core/stamps.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { mkdir as mkdir2, rename as rename2, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3, join as join14 } from "path";
+async function writeAtomicJson(path, value) {
+  await mkdir2(dirname3(path), { recursive: true });
+  const temporary = `${path}.tmp-${process.pid}-${randomUUID3()}`;
+  await writeFile3(temporary, `${JSON.stringify(value, null, "	")}
+`);
+  await rename2(temporary, path);
+}
+async function writeRunStamps(statePath, stamp) {
+  await mkdir2(statePath, { recursive: true });
+  await writeAtomicJson(join14(statePath, "last-run.json"), stamp);
+  if (stamp.ok) {
+    await writeAtomicJson(join14(statePath, "last-success.json"), stamp);
+  }
+}
+
+// src/core/archive.ts
+function shouldArchive(decision) {
+  if (decision.stored === null) {
+    return true;
+  }
+  if (decision.sourceMtimeMs > decision.stored.mtimeMs) {
+    return true;
+  }
+  return decision.sourceMtimeMs === decision.stored.mtimeMs && decision.indexSourceSize !== void 0 && decision.sourceSize !== decision.indexSourceSize;
+}
+async function storedFile(path) {
+  try {
+    const storedStat = await stat3(path);
+    return { mtimeMs: storedStat.mtimeMs };
+  } catch (error) {
+    if (isEnoent(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+function emptyCounts() {
+  return { archived: 0, unchanged: 0, failed: 0 };
+}
+function emptyPerHarness() {
+  return Object.fromEntries(HARNESS_IDS.map((harness) => [harness, emptyCounts()]));
+}
+function increment(result, harness, field) {
+  result[field] += 1;
+  result.perHarness[harness][field] += 1;
+}
+function userHome(env) {
+  const configured = env.HOME?.trim();
+  return configured ? configured : homedir3();
+}
+function utcBasic(isoTimestamp) {
+  return isoTimestamp.replaceAll("-", "").replaceAll(":", "");
+}
+async function newestSnapshot(machinePath, adapter) {
+  const snapshotRoot = join15(machinePath, adapter.id, "snapshots");
+  const entries = (await readDirectoryOrEmpty(snapshotRoot)).filter((entry) => entry.isDirectory()).sort((left, right) => right.name.localeCompare(left.name));
+  for (const entry of entries) {
+    const directory = join15(snapshotRoot, entry.name);
+    let value;
+    try {
+      value = JSON.parse(await readFile5(join15(directory, "manifest.json"), "utf8"));
+    } catch (error) {
+      if (isEnoent(error) || error instanceof SyntaxError) {
+        continue;
+      }
+      throw error;
+    }
+    if (!isDatabaseSnapshotManifest(value) || value.harness !== adapter.id || value.payload !== adapter.snapshotFilename) {
+      continue;
+    }
+    const payloadPath = join15(directory, value.payload);
+    const payloadStat = await statOrNull(payloadPath);
+    if (payloadStat === null || !payloadStat.isFile()) {
+      continue;
+    }
+    try {
+      const databaseBytes = decompressBytes(await readFile5(payloadPath));
+      if (databaseBytes.byteLength !== value.sizeBytes || createHash5("sha256").update(databaseBytes).digest("hex") !== value.contentSha256) {
+        return null;
+      }
+    } catch {
+      return null;
+    }
+    return {
+      manifest: value,
+      payloadPath,
+      relativePayloadPath: join15(adapter.id, "snapshots", entry.name, value.payload)
+    };
+  }
+  return null;
+}
+async function snapshotIndexRecord(machine, snapshot2) {
+  const storedBytes = await readFile5(snapshot2.payloadPath);
+  return {
+    v: 1,
+    path: snapshot2.relativePayloadPath,
+    harness: snapshot2.manifest.harness,
+    machine,
+    unit: snapshot2.manifest.contentSha256,
+    role: "database",
+    source: snapshot2.manifest.sourcePath,
+    sourceMtimeMs: Date.parse(snapshot2.manifest.snapshotAt),
+    sourceSize: snapshot2.manifest.sizeBytes,
+    storedSize: storedBytes.byteLength,
+    sha256: createHash5("sha256").update(storedBytes).digest("hex"),
+    archivedAt: snapshot2.manifest.snapshotAt,
+    contentSha256: snapshot2.manifest.contentSha256,
+    snapshotAt: snapshot2.manifest.snapshotAt,
+    harnessVersion: snapshot2.manifest.harnessVersion,
+    sessions: snapshot2.manifest.sessions
+  };
+}
+async function archiveDatabaseSnapshot(config, machinePath, indexPath, index, adapter, unit, result) {
+  const stagingRoot = join15(machinePath, adapter.id, ".staging");
+  const stagedDatabase = join15(stagingRoot, `snapshot-${process.pid}-${randomUUID4()}.db`);
+  await mkdir3(stagingRoot, { recursive: true });
+  try {
+    const capture = await adapter.snapshot(unit, stagedDatabase);
+    const newest = await newestSnapshot(machinePath, adapter);
+    if (newest?.manifest.contentSha256 === capture.contentSha256) {
+      if (!index.records.has(newest.relativePayloadPath)) {
+        const repaired = await snapshotIndexRecord(config.machine, newest);
+        await appendIndex(indexPath, repaired);
+        index.records.set(repaired.path, repaired);
+        result.repaired += 1;
+      }
+      increment(result, adapter.id, "unchanged");
+      return;
+    }
+    const snapshotAt = (/* @__PURE__ */ new Date()).toISOString();
+    const snapshotName = `${utcBasic(snapshotAt)}-${capture.contentSha256}`;
+    const snapshotRoot = join15(machinePath, adapter.id, "snapshots");
+    const snapshotDirectory = join15(snapshotRoot, snapshotName);
+    await mkdir3(snapshotRoot, { recursive: true });
+    await mkdir3(snapshotDirectory);
+    const snapshotTime = Date.parse(snapshotAt) / 1e3;
+    await utimes2(stagedDatabase, snapshotTime, snapshotTime);
+    const payloadPath = join15(snapshotDirectory, adapter.snapshotFilename);
+    const compressed = await compressFile(stagedDatabase, payloadPath);
+    const manifest = {
+      v: 1,
+      kind: "db-snapshot",
+      harness: adapter.id,
+      sourcePath: unit.sourcePath,
+      harnessVersion: capture.softwareVersion,
+      snapshotAt,
+      contentSha256: capture.contentSha256,
+      sizeBytes: capture.sizeBytes,
+      sessions: capture.sessions,
+      payload: adapter.snapshotFilename
+    };
+    await writeAtomicJson(join15(snapshotDirectory, "manifest.json"), manifest);
+    const relativePayloadPath = join15(adapter.id, "snapshots", snapshotName, adapter.snapshotFilename);
+    const record = {
+      v: 1,
+      path: relativePayloadPath,
+      harness: adapter.id,
+      machine: config.machine,
+      unit: capture.contentSha256,
+      role: "database",
+      source: unit.sourcePath,
+      sourceMtimeMs: compressed.sourceMtimeMs,
+      sourceSize: capture.sizeBytes,
+      storedSize: compressed.storedSize,
+      sha256: compressed.sha256,
+      archivedAt: snapshotAt,
+      contentSha256: capture.contentSha256,
+      snapshotAt,
+      harnessVersion: capture.softwareVersion,
+      sessions: capture.sessions
+    };
+    await appendIndex(indexPath, record);
+    index.records.set(record.path, record);
+    increment(result, adapter.id, "archived");
+  } catch (error) {
+    increment(result, adapter.id, "failed");
+    result.errors.push(`${adapter.id}: ${unit.sourcePath}: ${errorMessage(error)}`);
+  } finally {
+    await Promise.all([
+      rm3(stagedDatabase, { force: true }),
+      rm3(`${stagedDatabase}-wal`, { force: true }),
+      rm3(`${stagedDatabase}-shm`, { force: true })
+    ]);
+  }
+}
+async function archiveSessions(config, machinePath, indexPath, index, adapter, units, result) {
+  for (const unit of units) {
+    for (const file of unit.files) {
+      const relativePath = join15(adapter.id, `${file.relPath}.zst`);
+      const destination = join15(machinePath, relativePath);
+      try {
+        const currentIndexRecord = index.records.get(relativePath);
+        const stored = await storedFile(destination);
+        if (!shouldArchive({
+          sourceMtimeMs: file.mtimeMs,
+          sourceSize: file.sizeBytes,
+          stored,
+          indexSourceSize: currentIndexRecord?.sourceSize
+        })) {
+          if (stored !== null && currentIndexRecord?.sourceMtimeMs !== stored.mtimeMs) {
+            const storedBytes = await readFile5(destination);
+            const record2 = {
+              v: 1,
+              path: relativePath,
+              harness: adapter.id,
+              machine: config.machine,
+              unit: unit.id,
+              role: file.role,
+              source: file.absPath,
+              sourceMtimeMs: stored.mtimeMs,
+              sourceSize: file.sizeBytes,
+              storedSize: storedBytes.byteLength,
+              sha256: createHash5("sha256").update(storedBytes).digest("hex"),
+              archivedAt: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            await appendIndex(indexPath, record2);
+            index.records.set(relativePath, record2);
+            result.repaired += 1;
+          }
+          increment(result, adapter.id, "unchanged");
+          continue;
+        }
+        await mkdir3(dirname4(destination), { recursive: true });
+        const compressed = await compressFile(file.absPath, destination);
+        const record = {
+          v: 1,
+          path: relativePath,
+          harness: adapter.id,
+          machine: config.machine,
+          unit: unit.id,
+          role: file.role,
+          source: file.absPath,
+          sourceMtimeMs: compressed.sourceMtimeMs,
+          sourceSize: compressed.sourceSize,
+          storedSize: compressed.storedSize,
+          sha256: compressed.sha256,
+          archivedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        await appendIndex(indexPath, record);
+        index.records.set(relativePath, record);
+        increment(result, adapter.id, "archived");
+      } catch (error) {
+        increment(result, adapter.id, "failed");
+        result.errors.push(`${adapter.id}: ${file.absPath}: ${errorMessage(error)}`);
+      }
+    }
+  }
+}
+async function sweep(config, env) {
+  const result = {
+    ...emptyCounts(),
+    repaired: 0,
+    perHarness: emptyPerHarness(),
+    errors: []
+  };
+  const machinePath = join15(config.archiveRoot, config.machine);
+  const indexPath = join15(machinePath, "index.jsonl");
+  const index = await readIndex(indexPath);
+  for (const adapter of adapters) {
+    const storeRoot = adapter.storeRoot(env, userHome(env));
+    if (adapter.mutationModel === "db-snapshot") {
+      let units2;
+      try {
+        units2 = await adapter.enumerate(storeRoot);
+      } catch (error) {
+        increment(result, adapter.id, "failed");
+        result.errors.push(`${adapter.id}: could not enumerate store: ${errorMessage(error)}`);
+        continue;
+      }
+      for (const unit of units2) {
+        await archiveDatabaseSnapshot(config, machinePath, indexPath, index, adapter, unit, result);
+      }
+      continue;
+    }
+    let units;
+    try {
+      units = await adapter.enumerate(storeRoot);
+    } catch (error) {
+      increment(result, adapter.id, "failed");
+      result.errors.push(`${adapter.id}: could not enumerate store: ${errorMessage(error)}`);
+      continue;
+    }
+    await archiveSessions(config, machinePath, indexPath, index, adapter, units, result);
+  }
+  return result;
+}
+
+// src/doctor/reconcile.ts
+function emptyHarness() {
+  return { sources: 0, archived: 0, missing: 0, stale: 0, pending: 0, orphaned: 0 };
+}
+function harnessRecord() {
+  return Object.fromEntries(HARNESS_IDS.map((harness) => [harness, emptyHarness()]));
+}
+async function walkFiles(root) {
+  const entries = await readDirectoryOrEmpty(root);
+  const files = [];
+  for (const entry of entries) {
+    const path = join16(root, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await walkFiles(path));
+    } else {
+      files.push(path);
+    }
+  }
+  return files;
+}
+async function storedMtime(path) {
+  return (await statOrNull(path))?.mtimeMs ?? null;
+}
+async function sourceExists(path) {
+  return await statOrNull(path) !== null;
+}
+function archivedSourcePath(archiveRelativePath, storeRoots) {
+  const parts = archiveRelativePath.split(sep2);
+  const harness = parts.shift();
+  if (!isHarnessId(harness)) {
+    return null;
+  }
+  const last = parts.at(-1);
+  if (last === void 0 || !last.endsWith(".zst")) {
+    return null;
+  }
+  parts[parts.length - 1] = last.slice(0, -4);
+  const root = storeRoots.get(harness);
+  return root === void 0 ? null : { harness, sourcePath: join16(root, ...parts) };
+}
+function anomalyDetail(harnesses) {
+  const details = [];
+  for (const adapter of adapters) {
+    const data = harnesses[adapter.id];
+    const items = [];
+    for (const key of ["missing", "stale", "pending", "orphaned"]) {
+      if (data[key] > 0) {
+        items.push(`${data[key]} ${key}`);
+      }
+    }
+    if (items.length > 0) {
+      details.push(`${adapter.id}: ${items.join(", ")}`);
+    }
+  }
+  return details;
+}
+async function checkReconciled(context) {
+  const machinePath = join16(context.config.archiveRoot, context.config.machine);
+  const harnesses = harnessRecord();
+  const storeRoots = /* @__PURE__ */ new Map();
+  const sources = [];
+  const enumerationErrors = [];
+  const reconciliationErrors = [];
+  for (const adapter of adapters) {
+    const storeRoot = adapter.storeRoot(context.env, context.userHome);
+    storeRoots.set(adapter.id, storeRoot);
+    try {
+      if (adapter.mutationModel === "db-snapshot") {
+        for (const unit of await adapter.enumerate(storeRoot)) {
+          const temporaryRoot = await mkdtemp(join16(tmpdir(), "packbat-doctor-snapshot-"));
+          try {
+            const capture = await adapter.snapshot(unit, join16(temporaryRoot, "snapshot.db"));
+            sources.push({
+              kind: "db-snapshot",
+              harness: adapter.id,
+              unit,
+              contentSha256: capture.contentSha256,
+              observedMtimeMs: Math.max(unit.sourceMtimeMs, ...capture.sessions.map((session) => session.timeUpdated))
+            });
+            harnesses[adapter.id].sources += 1;
+          } finally {
+            await rm4(temporaryRoot, { recursive: true, force: true });
+          }
+        }
+        continue;
+      }
+      for (const unit of await adapter.enumerate(storeRoot)) {
+        for (const file of unit.files) {
+          const relativeArchivePath = join16(adapter.id, `${file.relPath}.zst`);
+          sources.push({
+            kind: "session",
+            harness: adapter.id,
+            file,
+            archivePath: join16(machinePath, relativeArchivePath),
+            relativeArchivePath
+          });
+          harnesses[adapter.id].sources += 1;
+        }
+      }
+    } catch (error) {
+      enumerationErrors.push(`${adapter.id}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  let treeFiles;
+  let index;
+  try {
+    [treeFiles, index] = await Promise.all([
+      walkFiles(machinePath),
+      readDerivedIndex(machinePath, context.config.machine)
+    ]);
+  } catch (error) {
+    return {
+      id: "reconciled",
+      title: "reconciled",
+      status: "problem",
+      detail: `archive tree cannot be read: ${error instanceof Error ? error.message : String(error)}`,
+      data: { harnesses, enumerationErrors }
+    };
+  }
+  const archiveFiles = treeFiles.filter((path) => {
+    const archivePath = relative4(machinePath, path);
+    return archivePath !== "index.jsonl" && !archivePath.endsWith(`${sep2}manifest.json`) && !archivePath.split(sep2).includes(".staging");
+  });
+  const treeRelative = archiveFiles.map((path) => relative4(machinePath, path));
+  const treeSet = new Set(treeRelative);
+  for (const archiveRelativePath of treeRelative) {
+    const harness = archiveRelativePath.split(sep2, 1)[0];
+    if (isHarnessId(harness)) {
+      harnesses[harness].archived += 1;
+    }
+  }
+  for (const source of sources) {
+    if (source.kind === "db-snapshot") {
+      const newest = [...index.records.values()].filter(
+        (record) => record.harness === source.harness && isDatabaseSnapshotIndexRecord(record)
+      ).sort(
+        (left, right) => right.sourceMtimeMs - left.sourceMtimeMs || right.archivedAt.localeCompare(left.archivedAt)
+      )[0];
+      if (newest?.contentSha256 === source.contentSha256) {
+        continue;
+      }
+      const pending = ageMs(source.observedMtimeMs, context.now) < windowMs(context);
+      harnesses[source.harness][newest === void 0 ? pending ? "pending" : "missing" : pending ? "pending" : "stale"] += 1;
+      continue;
+    }
+    let mtimeMs;
+    try {
+      mtimeMs = await storedMtime(source.archivePath);
+    } catch (error) {
+      reconciliationErrors.push(
+        `${source.harness}: cannot inspect ${source.archivePath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+      continue;
+    }
+    if (mtimeMs === null) {
+      if (ageMs(source.file.mtimeMs, context.now) < windowMs(context)) {
+        harnesses[source.harness].pending += 1;
+      } else {
+        harnesses[source.harness].missing += 1;
+      }
+      continue;
+    }
+    const stale = shouldArchive({
+      sourceMtimeMs: source.file.mtimeMs,
+      sourceSize: source.file.sizeBytes,
+      stored: { mtimeMs },
+      indexSourceSize: index.records.get(source.relativeArchivePath)?.sourceSize
+    });
+    if (!stale) {
+      continue;
+    }
+    if (ageMs(source.file.mtimeMs, context.now) < windowMs(context)) {
+      harnesses[source.harness].pending += 1;
+    } else {
+      harnesses[source.harness].stale += 1;
+    }
+  }
+  for (const archiveRelativePath of treeRelative) {
+    const indexed = index.records.get(archiveRelativePath);
+    const derived = indexed !== void 0 && isDatabaseSnapshotIndexRecord(indexed) ? { harness: indexed.harness, sourcePath: indexed.source } : archivedSourcePath(archiveRelativePath, storeRoots);
+    if (derived !== null) {
+      try {
+        if (!await sourceExists(derived.sourcePath)) {
+          harnesses[derived.harness].orphaned += 1;
+        }
+      } catch (error) {
+        reconciliationErrors.push(
+          `${derived.harness}: cannot inspect ${derived.sourcePath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+  let metadataMismatch = 0;
+  for (const archiveRelativePath of treeRelative) {
+    const record = index.records.get(archiveRelativePath);
+    if (record === void 0) {
+      continue;
+    }
+    try {
+      const archiveStat = await stat4(join16(machinePath, archiveRelativePath));
+      if (archiveStat.size !== record.storedSize || archiveStat.mtimeMs !== record.sourceMtimeMs) {
+        metadataMismatch += 1;
+      }
+    } catch (error) {
+      reconciliationErrors.push(
+        `index: cannot inspect ${archiveRelativePath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  const indexDrift = {
+    unindexed: treeRelative.filter((path) => !index.records.has(path)).length,
+    missingFromTree: [...index.records.keys()].filter((path) => !treeSet.has(path)).length,
+    metadataMismatch,
+    corruptLines: index.corruptLines
+  };
+  const totals = Object.values(harnesses).reduce(
+    (result, value) => ({
+      sources: result.sources + value.sources,
+      archived: result.archived + value.archived,
+      missing: result.missing + value.missing,
+      stale: result.stale + value.stale,
+      pending: result.pending + value.pending,
+      orphaned: result.orphaned + value.orphaned
+    }),
+    emptyHarness()
+  );
+  const driftCount = indexDrift.unindexed + indexDrift.missingFromTree + indexDrift.metadataMismatch + indexDrift.corruptLines;
+  const hasProblem = totals.missing > 0 || totals.stale > 0 || indexDrift.missingFromTree > 0 || enumerationErrors.length > 0 || reconciliationErrors.length > 0;
+  const hasInfo = totals.pending > 0 || totals.orphaned > 0 || driftCount > 0;
+  const details = anomalyDetail(harnesses);
+  if (enumerationErrors.length > 0) {
+    details.push(`enumeration failed: ${enumerationErrors.join("; ")}`);
+  }
+  if (reconciliationErrors.length > 0) {
+    details.push(`inspection failed: ${reconciliationErrors.join("; ")}`);
+  }
+  if (driftCount > 0) {
+    details.push(`index drift: ${driftCount}`);
+  }
+  if (indexDrift.missingFromTree > 0) {
+    details.push("archived payloads recorded in the index are missing from the tree");
+  }
+  const detail = details.length === 0 ? `nothing missed; ${totals.sources} source file${totals.sources === 1 ? "" : "s"} current` : `${hasProblem ? "coverage gaps" : "nothing missed"}; ${details.join("; ")}`;
+  return {
+    id: "reconciled",
+    title: "reconciled",
+    status: hasProblem ? "problem" : hasInfo ? "info" : "ok",
+    detail,
+    data: {
+      windowMinutes: context.config.sweep.intervalMinutes * 2,
+      totals,
+      harnesses,
+      indexDrift,
+      enumerationErrors,
+      reconciliationErrors
+    }
+  };
+}
+
+// src/commands/doctor.ts
+var USAGE = "Usage: packbat doctor [--json]\n";
+function parseOptions(argv) {
+  if (argv.length === 0) {
+    return { json: false };
+  }
+  if (argv.length === 1 && argv[0] === "--json") {
+    return { json: true };
+  }
+  process.stderr.write(`packbat doctor: only --json is accepted
+
+${USAGE}`);
+  return null;
+}
+function symbol(item) {
+  switch (item.status) {
+    case "ok":
+      return pc.green("\u2713");
+    case "problem":
+      return pc.red("\u2717");
+    case "info":
+      return pc.dim("\xB7");
+  }
+}
+function printHuman(facts) {
+  for (const item of facts) {
+    process.stdout.write(`${symbol(item)} ${item.title}: ${item.detail}
+`);
+  }
+  const problems = facts.filter((item) => item.status === "problem");
+  if (problems.length > 0) {
+    process.stdout.write("\nproblems:\n");
+    for (const item of problems) {
+      process.stdout.write(`  ${item.title}: ${remedyForFact(item)}
+`);
+    }
+  }
+}
+async function runDoctor(argv) {
+  const options = parseOptions(argv);
+  if (options === null) {
+    return 1;
+  }
+  const home = resolveHome();
+  const config = loadConfig(home);
+  const context = createDoctorContext(config, home);
+  const installed = await checkInstalled(context);
+  const [live, fresh, reconciled] = await Promise.all([
+    checkLive(context, installed),
+    checkFresh(context),
+    checkReconciled(context)
+  ]);
+  const environment = await collectEnvironmentFacts(context);
+  const facts = [installed.fact, live, fresh.fact, reconciled, retentionFact(), ...environment];
+  const ok = !facts.some((item) => item.status === "problem");
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify({ v: 1, ok, machine: config.machine, facts })}
+`);
+  } else {
+    printHuman(facts);
+  }
+  return ok ? 0 : 2;
+}
+
+// src/schedule/scheduler.ts
+import { execFile as execFile2, spawn, spawnSync } from "child_process";
+import { accessSync as accessSync2, constants as constants3 } from "fs";
+import { mkdir as mkdir4, readFile as readFile6, rm as rm5, writeFile as writeFile4 } from "fs/promises";
+import { isAbsolute as isAbsolute2, join as join17 } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile2);
+function systemctlForRemoval(env) {
+  const fromPath = commandOnPath("systemctl", env);
+  if (fromPath !== null) {
+    return fromPath;
+  }
+  for (const candidate of ["/usr/bin/systemctl", "/bin/systemctl"]) {
+    try {
+      accessSync2(candidate, constants3.X_OK);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function userId() {
+  if (process.getuid === void 0) {
+    throw new PackbatError("scheduler requires a POSIX user id");
+  }
+  return process.getuid();
+}
+function assertAbsoluteCommand(options) {
+  if (!isAbsolute2(options.nodePath) || !isAbsolute2(options.entryPath)) {
+    throw new PackbatError("scheduler command paths must be absolute");
+  }
+}
+async function runSchedulerCommand(command2, args) {
+  try {
+    const result = await execFileAsync(command2, args, { encoding: "utf8" });
+    return result.stdout;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new PackbatError(`scheduler command failed: ${command2} ${args.join(" ")}: ${message}`);
+  }
+}
+async function runIgnoringSchedulerFailure(command2, args) {
+  try {
+    await execFileAsync(command2, args);
+  } catch {
+  }
+}
+async function readCrontab(crontab) {
+  try {
+    const result = await execFileAsync(crontab, ["-l"], { encoding: "utf8" });
+    return result.stdout;
+  } catch (error) {
+    if (error.code === 1) {
+      return "";
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    throw new PackbatError(`scheduler command failed: ${crontab} -l: ${message}`);
+  }
+}
+async function writeCrontab(crontab, contents) {
+  await new Promise((resolve, reject) => {
+    const child = spawn(crontab, ["-"], { stdio: ["pipe", "ignore", "pipe"] });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new PackbatError(`scheduler command failed: ${crontab} -: ${stderr.trim() || `exit ${code}`}`));
+    });
+    child.stdin.end(contents);
+  });
+}
+function launchdPath(userHome3) {
+  return join17(userHome3, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+}
+function systemdPaths(userHome3) {
+  const directory = join17(userHome3, ".config", "systemd", "user");
+  return { service: join17(directory, SYSTEMD_SERVICE), timer: join17(directory, SYSTEMD_TIMER) };
+}
+function systemdEnablementPath(userHome3) {
+  return join17(userHome3, ".config", "systemd", "user", "timers.target.wants", SYSTEMD_TIMER);
+}
+function cronArtifactPath(statePath) {
+  return join17(statePath, "schedule.cron");
+}
+function activationMarkerPath(statePath) {
+  return join17(statePath, "schedule-activated");
+}
+async function installLaunchd(options) {
+  const path = launchdPath(options.userHome);
+  await mkdir4(join17(options.userHome, "Library", "LaunchAgents"), { recursive: true });
+  await writeFile4(path, generateLaunchdPlist(options));
+  return { artifactPaths: [path], notes: [] };
+}
+async function installSystemd(options) {
+  const paths = systemdPaths(options.userHome);
+  await mkdir4(join17(options.userHome, ".config", "systemd", "user"), { recursive: true });
+  await Promise.all([
+    writeFile4(paths.service, generateSystemdService(options)),
+    writeFile4(paths.timer, generateSystemdTimer())
+  ]);
+  return { artifactPaths: [paths.service, paths.timer], notes: [] };
+}
+async function installCron(options) {
+  const path = cronArtifactPath(options.statePath);
+  await mkdir4(options.statePath, { recursive: true });
+  await writeFile4(path, `${generateCronEntry(options)}
+`);
+  return { artifactPaths: [path], notes: [] };
+}
+function scheduleKind(env) {
+  if (process.platform === "darwin") {
+    return "launchd";
+  }
+  if (process.platform === "linux") {
+    const systemctl = commandOnPath("systemctl", env);
+    if (systemctl === null) {
+      return "cron";
+    }
+    return spawnSync(systemctl, ["--user", "show-environment"], { env, stdio: "ignore" }).status === 0 ? "systemd" : "cron";
+  }
+  throw new PackbatError(`scheduling is not supported on ${process.platform}`);
+}
+function previewSchedule(options) {
+  assertAbsoluteCommand(options);
+  switch (scheduleKind(options.env)) {
+    case "launchd":
+      return { artifactPaths: [launchdPath(options.userHome)], notes: [] };
+    case "systemd": {
+      const paths = systemdPaths(options.userHome);
+      return { artifactPaths: [paths.service, paths.timer], notes: [] };
+    }
+    case "cron":
+      return { artifactPaths: [cronArtifactPath(options.statePath)], notes: [] };
+  }
+}
+async function installSchedule(options) {
+  assertAbsoluteCommand(options);
+  switch (scheduleKind(options.env)) {
+    case "launchd":
+      return await installLaunchd(options);
+    case "systemd":
+      return await installSystemd(options);
+    case "cron":
+      return await installCron(options);
+  }
+}
+async function stripInstalledCron(statePath, env) {
+  const crontab = commandOnPath("crontab", env);
+  if (crontab !== null) {
+    const current = await readCrontab(crontab);
+    const stripped = stripCronEntry(current);
+    if (stripped !== current) {
+      await writeCrontab(crontab, stripped);
+    }
+  }
+  await rm5(cronArtifactPath(statePath), { force: true });
+}
+async function deactivateLaunchd(options) {
+  if (!pathExists(launchdPath(options.userHome)) && !pathExists(activationMarkerPath(options.statePath))) {
+    return;
+  }
+  await runIgnoringSchedulerFailure("launchctl", ["bootout", `gui/${userId()}/${LAUNCHD_LABEL}`]);
+}
+async function deactivateLinux(options) {
+  const paths = systemdPaths(options.userHome);
+  const enablementPath = systemdEnablementPath(options.userHome);
+  const wasActivated = pathExists(activationMarkerPath(options.statePath));
+  const hasSystemdArtifacts = [paths.service, paths.timer, enablementPath].some(pathExists);
+  if (hasSystemdArtifacts && (wasActivated || pathExists(enablementPath))) {
+    const systemctl = systemctlForRemoval(options.env);
+    if (systemctl === null) {
+      if (pathExists(enablementPath)) {
+        throw new PackbatError("cannot deactivate the enabled systemd timer because systemctl is unavailable");
+      }
+    } else if (pathExists(enablementPath)) {
+      await runSchedulerCommand(systemctl, ["--user", "disable", "--now", SYSTEMD_TIMER]);
+    } else {
+      await runIgnoringSchedulerFailure(systemctl, ["--user", "disable", "--now", SYSTEMD_TIMER]);
+    }
+  }
+  if (wasActivated && pathExists(cronArtifactPath(options.statePath))) {
+    const crontab = commandOnPath("crontab", options.env);
+    if (crontab === null) {
+      throw new PackbatError("cannot deactivate the installed cron schedule because crontab is unavailable");
+    }
+    const current = await readCrontab(crontab);
+    const stripped = stripCronEntry(current);
+    if (stripped !== current) {
+      await writeCrontab(crontab, stripped);
+    }
+  }
+}
+async function deactivateSchedule(options) {
+  if (process.platform === "darwin") {
+    await deactivateLaunchd(options);
+    await rm5(activationMarkerPath(options.statePath), { force: true });
+    return;
+  }
+  if (process.platform === "linux") {
+    await deactivateLinux(options);
+    await rm5(activationMarkerPath(options.statePath), { force: true });
+    return;
+  }
+  throw new PackbatError(`scheduling is not supported on ${process.platform}`);
+}
+async function activateLaunchd(options) {
+  const path = launchdPath(options.userHome);
+  const domain = `gui/${userId()}`;
+  await runIgnoringSchedulerFailure("launchctl", ["bootout", domain, path]);
+  await runSchedulerCommand("launchctl", ["bootstrap", domain, path]);
+  return [];
+}
+async function activateSystemd(options, systemctl) {
+  await runSchedulerCommand(systemctl, ["--user", "daemon-reload"]);
+  await runSchedulerCommand(systemctl, ["--user", "enable", "--now", SYSTEMD_TIMER]);
+  await stripInstalledCron(options.statePath, options.env);
+  const notes = [];
+  const loginctl = commandOnPath("loginctl", options.env);
+  if (loginctl !== null) {
+    try {
+      const linger = await runSchedulerCommand(loginctl, ["show-user", String(userId()), "-p", "Linger"]);
+      if (!/^Linger=yes$/m.test(linger)) {
+        notes.push("note: systemd linger is off; scheduled sync resumes at the next login");
+      }
+    } catch {
+    }
+  }
+  return notes;
+}
+async function activateCron(options) {
+  const crontab = commandOnPath("crontab", options.env);
+  if (crontab === null) {
+    throw new PackbatError("no supported scheduler found (systemctl and crontab are unavailable)");
+  }
+  const entry = (await readFile6(cronArtifactPath(options.statePath), "utf8")).trimEnd();
+  const current = await readCrontab(crontab);
+  await writeCrontab(crontab, mergeCronTab(current, entry));
+  const paths = systemdPaths(options.userHome);
+  await Promise.all(
+    [paths.service, paths.timer, systemdEnablementPath(options.userHome)].map(
+      async (path) => await rm5(path, { force: true })
+    )
+  );
+  return [];
+}
+async function activateSchedule(options) {
+  let notes;
+  switch (scheduleKind(options.env)) {
+    case "launchd":
+      notes = await activateLaunchd(options);
+      break;
+    case "systemd": {
+      const systemctl = commandOnPath("systemctl", options.env);
+      if (systemctl === null) {
+        throw new PackbatError("systemd user manager became unavailable during schedule activation");
+      }
+      notes = await activateSystemd(options, systemctl);
+      break;
+    }
+    case "cron":
+      notes = await activateCron(options);
+      break;
+  }
+  await mkdir4(options.statePath, { recursive: true });
+  await writeFile4(activationMarkerPath(options.statePath), "active\n");
+  return notes;
+}
+function scheduleWasActivated(statePath) {
+  return pathExists(activationMarkerPath(statePath));
+}
+async function uninstallLaunchd(options) {
+  const path = launchdPath(options.userHome);
+  const cronPath = cronArtifactPath(options.statePath);
+  const markerPath = activationMarkerPath(options.statePath);
+  const removedPaths = [path, cronPath, markerPath].filter(pathExists);
+  if (pathExists(markerPath)) {
+    await runIgnoringSchedulerFailure("launchctl", ["bootout", `gui/${userId()}/${LAUNCHD_LABEL}`]);
+  }
+  await Promise.all(removedPaths.map(async (artifactPath) => await rm5(artifactPath, { force: true })));
+  return { removedPaths };
+}
+async function uninstallLinux(options) {
+  const paths = systemdPaths(options.userHome);
+  const cronPath = cronArtifactPath(options.statePath);
+  const present = [
+    paths.service,
+    paths.timer,
+    systemdEnablementPath(options.userHome),
+    cronPath,
+    activationMarkerPath(options.statePath)
+  ].filter(pathExists);
+  const crontab = commandOnPath("crontab", options.env);
+  let hadCronEntry = false;
+  if (crontab !== null) {
+    const current = await readCrontab(crontab);
+    hadCronEntry = stripCronEntry(current) !== current;
+  }
+  await deactivateLinux(options);
+  const systemctl = systemctlForRemoval(options.env);
+  await Promise.all(present.map(async (path) => await rm5(path, { force: true })));
+  const removedPaths = [...present];
+  if (crontab !== null) {
+    const current = await readCrontab(crontab);
+    const stripped = stripCronEntry(current);
+    if (stripped !== current) {
+      await writeCrontab(crontab, stripped);
+    }
+    if (hadCronEntry) {
+      removedPaths.push("crontab (# packbat-sync)");
+    }
+  }
+  if (systemctl !== null) {
+    await runIgnoringSchedulerFailure(systemctl, ["--user", "daemon-reload"]);
+  }
+  return { removedPaths };
+}
+async function uninstallSchedule(options) {
+  if (process.platform === "darwin") {
+    return await uninstallLaunchd(options);
+  }
+  if (process.platform === "linux") {
+    return await uninstallLinux(options);
+  }
+  throw new PackbatError(`scheduling is not supported on ${process.platform}`);
+}
+
+// src/core/setup.ts
+import { existsSync as existsSync3 } from "fs";
+import { mkdir as mkdir5, realpath } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { isAbsolute as isAbsolute3 } from "path";
+
+// src/schedule/environment.ts
+var SCHEDULE_ENVIRONMENT_KEYS = [
+  "PACKBAT_HOME",
+  "CLAUDE_CONFIG_DIR",
+  "CODEX_HOME",
+  "GEMINI_CLI_HOME",
+  "OPENCODE_DB",
+  "PI_CODING_AGENT_SESSION_DIR",
+  "XDG_DATA_HOME"
+];
+function scheduleEnvironment(env) {
+  const result = /* @__PURE__ */ new Map();
+  for (const key of SCHEDULE_ENVIRONMENT_KEYS) {
+    const value = env[key];
+    if (value !== void 0 && value.trim() !== "") {
+      result.set(key, value);
+    }
+  }
+  return result;
+}
+
+// src/core/machine.ts
+import { hostname } from "os";
+function sanitizeMachineName(value) {
+  const sanitized = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return sanitized === "" ? "machine" : sanitized;
+}
+function defaultMachineName() {
+  return sanitizeMachineName(hostname().split(".", 1)[0] ?? "");
+}
+
+// src/core/setup.ts
+function skippedOffboxConfig() {
+  return { mode: "skipped", skippedAt: (/* @__PURE__ */ new Date()).toISOString() };
+}
+function userHome2() {
+  const configured = process.env.HOME?.trim();
+  return configured ? configured : homedir4();
+}
+function detectInitStores(homePath) {
+  return {
+    detected: adapters.map((adapter) => ({ displayName: adapter.displayName, path: adapter.storeRoot(process.env, homePath) })).filter(({ path }) => existsSync3(path)),
+    unsupported: unsupportedStores.map((store) => ({ displayName: store.displayName, path: store.detect(process.env, homePath) })).filter((entry) => entry.path !== null)
+  };
+}
+async function writeInitConfig(home, archiveRoot, offbox) {
+  if (!isAbsolute3(archiveRoot)) {
+    throw new PackbatError("archive root must be absolute");
+  }
+  let config;
+  if (existsSync3(home.configPath)) {
+    config = loadConfig(home);
+    if (archiveRoot !== config.archiveRoot) {
+      throw new PackbatError(`archive root is already ${config.archiveRoot}; edit config.json to move the archive`);
+    }
+    if (offbox !== void 0) {
+      config = { ...config, offbox };
+    }
+  } else {
+    config = {
+      version: CONFIG_VERSION,
+      machine: defaultMachineName(),
+      archiveRoot,
+      sweep: { intervalMinutes: 60 },
+      offbox: offbox ?? skippedOffboxConfig()
+    };
+  }
+  saveConfig(home, config);
+  await Promise.all([
+    mkdir5(home.statePath, { recursive: true }),
+    mkdir5(home.logsPath, { recursive: true }),
+    mkdir5(config.archiveRoot, { recursive: true })
+  ]);
+  return config;
+}
+async function createInitScheduleOptions(home, homePath) {
+  const entryArgument = process.argv[1];
+  if (entryArgument === void 0) {
+    throw new Error("CLI entry path is unavailable");
+  }
+  return {
+    userHome: homePath,
+    statePath: home.statePath,
+    logsPath: home.logsPath,
+    nodePath: process.execPath,
+    entryPath: await realpath(entryArgument),
+    environment: scheduleEnvironment(process.env),
+    env: process.env
+  };
+}
+async function installInitSchedule(options, activate) {
+  if (activate || scheduleWasActivated(options.statePath)) {
+    await deactivateSchedule(options);
+  }
+  const schedule = await installSchedule(options);
+  const activationNotes = activate ? await activateSchedule(options) : [];
+  return { schedule, activationNotes };
+}
+
+// src/offbox/age.ts
+import {
+  identityToRecipient as ageIdentityToRecipient,
+  Decrypter,
+  Encrypter,
+  generateIdentity as generateAgeIdentity
+} from "age-encryption";
+async function generateIdentity() {
+  return await generateAgeIdentity();
+}
+async function identityToRecipient(identity) {
+  return await ageIdentityToRecipient(identity);
+}
+async function encryptToRecipient(recipient, plaintext) {
+  const encrypter = new Encrypter();
+  encrypter.addRecipient(recipient);
+  return Buffer.from(await encrypter.encrypt(plaintext));
+}
+async function decryptWithIdentity(identity, ciphertext) {
+  const decrypter = new Decrypter();
+  decrypter.addIdentity(identity);
+  return Buffer.from(await decrypter.decrypt(ciphertext));
+}
+function parseIdentityFile(contents) {
+  const identity = contents.split(/\r?\n/u).map((line) => line.trim()).find((line) => /^AGE-SECRET-KEY-1[0-9A-Z]+$/u.test(line));
+  if (identity === void 0) {
+    throw new PackbatError("identity file does not contain an AGE-SECRET-KEY-1\u2026 identity");
+  }
+  return identity;
+}
+
+// src/offbox/rclone.ts
+import { spawn as spawn2 } from "child_process";
+import { constants as constants4 } from "fs";
+import { access as access2, chmod, mkdir as mkdir6, open as open2 } from "fs/promises";
+import { dirname as dirname5 } from "path";
+var RCLONE_MISSING = "rclone was not found on PATH; install it with `brew install rclone` (macOS) or `apt install rclone` (Debian/Ubuntu)";
+async function discoverRclone(env = process.env) {
+  const fromPath = commandOnPath("rclone", env);
+  if (fromPath !== null) {
+    return fromPath;
+  }
+  for (const candidate of ["/opt/homebrew/bin/rclone", "/usr/local/bin/rclone", "/usr/bin/rclone"]) {
+    try {
+      await access2(candidate, constants4.X_OK);
+      return candidate;
+    } catch (error) {
+      if (error.code !== "ENOENT" && error.code !== "EACCES") {
+        throw error;
+      }
+    }
+  }
+  throw new PackbatError(RCLONE_MISSING);
+}
+async function managedConfigArguments(mode) {
+  if (mode === "default") {
+    return [];
+  }
+  const configPath = resolveHome().rcloneConfPath;
+  await mkdir6(dirname5(configPath), { recursive: true });
+  const handle = await open2(configPath, "a", 384);
+  await handle.close();
+  await chmod(configPath, 384);
+  return ["--config", configPath];
+}
+async function runRclone(command2, args, mode) {
+  const executable = await discoverRclone();
+  const configArguments = await managedConfigArguments(mode);
+  return await new Promise((resolve, reject) => {
+    const child = spawn2(executable, [command2, ...configArguments, ...args], {
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", (error) => {
+      reject(new PackbatError(`could not start rclone: ${error.message}`));
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve(stdout);
+        return;
+      }
+      const output = `${stdout}${stderr}`;
+      reject(new PackbatError(`rclone ${command2} failed${output.trim() === "" ? "" : `: ${output.trim()}`}`));
+    });
+  });
+}
+async function remoteFileExists(destinationFile, mode) {
+  let output;
+  try {
+    output = await runRclone("lsjson", [destinationFile], mode);
+  } catch {
+    return false;
+  }
+  let items;
+  try {
+    items = JSON.parse(output);
+  } catch {
+    throw new PackbatError("rclone lsjson returned invalid JSON");
+  }
+  return Array.isArray(items) && items.length > 0;
+}
+async function copyTree(source, destination, mode) {
+  await runRclone("copy", [source, destination], mode);
+}
+async function copyFile(source, destinationFile, mode) {
+  await runRclone("copyto", [source, destinationFile], mode);
+}
+function joinRcloneDestination(destination, relativePath) {
+  const child = relativePath.replace(/^\/+/, "");
+  if (destination.endsWith(":")) {
+    return `${destination}${child}`;
+  }
+  const base = destination.replace(/\/+$/, "");
+  return `${base === "" ? "/" : `${base}/`}${child}`;
+}
+
+// src/core/lock.ts
+import { randomUUID as randomUUID5 } from "crypto";
+import { link, mkdir as mkdir7, readFile as readFile7, rm as rm6, writeFile as writeFile5 } from "fs/promises";
+import { join as join18 } from "path";
+function isProcessAlive(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = error.code;
+    if (code === "EPERM") {
+      return true;
+    }
+    if (code === "ESRCH") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function lockOwnerIsAlive(path) {
+  try {
+    const parsed = JSON.parse(await readFile7(path, "utf8"));
+    if (typeof parsed !== "object" || parsed === null || !("pid" in parsed)) {
+      return false;
+    }
+    return isProcessAlive(parsed.pid);
+  } catch (error) {
+    if (error.code === "ENOENT" || error instanceof SyntaxError) {
+      return false;
+    }
+    throw error;
+  }
+}
+async function tryAcquire(path) {
+  const contents = { pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  const temporary = `${path}.tmp-${process.pid}-${randomUUID5()}`;
+  try {
+    await writeFile5(temporary, `${JSON.stringify(contents)}
+`, { flag: "wx" });
+    try {
+      await link(temporary, path);
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        return false;
+      }
+      throw error;
+    }
+  } finally {
+    await rm6(temporary, { force: true });
+  }
+  return true;
+}
+async function withLock(statePath, name, fn) {
+  await mkdir7(statePath, { recursive: true });
+  const path = join18(statePath, `${name}.lock`);
+  let acquired = await tryAcquire(path);
+  if (!acquired) {
+    if (await lockOwnerIsAlive(path)) {
+      return { acquired: false };
+    }
+    await rm6(path, { force: true });
+    acquired = await tryAcquire(path);
+    if (!acquired) {
+      return { acquired: false };
+    }
+  }
+  try {
+    return { acquired: true, value: await fn() };
+  } finally {
+    await rm6(path, { force: true });
+  }
+}
+async function withSyncLock(statePath, fn) {
+  return await withLock(statePath, "sync", fn);
+}
+async function withRetrievalLock(statePath, fn) {
+  return await withLock(statePath, "retrieval", fn);
+}
+
+// src/core/log.ts
+import { appendFile as appendFile2, mkdir as mkdir8, rename as rename3, rm as rm7, stat as stat5 } from "fs/promises";
+import { join as join19 } from "path";
+var MAX_LOG_BYTES = 1024 * 1024;
+var LOG_NAME = "packbat.log";
+async function renameIfPresent(source, destination) {
+  try {
+    await rename3(source, destination);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+async function rotate(path) {
+  await rm7(`${path}.3`, { force: true });
+  await renameIfPresent(`${path}.2`, `${path}.3`);
+  await renameIfPresent(`${path}.1`, `${path}.2`);
+  await renameIfPresent(path, `${path}.1`);
+}
+async function appendLog(logsPath, line, at = /* @__PURE__ */ new Date()) {
+  await mkdir8(logsPath, { recursive: true });
+  const path = join19(logsPath, LOG_NAME);
+  const entry = `[${at.toISOString()}] ${line}
+`;
+  let existingSize = 0;
+  try {
+    existingSize = (await stat5(path)).size;
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  if (existingSize + Buffer.byteLength(entry) > MAX_LOG_BYTES) {
+    await rotate(path);
+  }
+  await appendFile2(path, entry);
+}
+
+// src/offbox/outbox.ts
+import { createHash as createHash6, randomUUID as randomUUID6 } from "crypto";
+import { appendFile as appendFile3, mkdir as mkdir9, readdir as readdir2, readFile as readFile8, rename as rename4, rm as rm8, stat as stat6, writeFile as writeFile6 } from "fs/promises";
+import { basename as basename3, dirname as dirname6, join as join20, relative as relative5 } from "path";
+
+// src/offbox/remote.ts
+var RcloneArchiveRemote = class {
+  constructor(config) {
+    this.config = config;
+    this.destination = config.destination;
+  }
+  config;
+  destination;
+  async indexExists(machine) {
+    return await remoteFileExists(
+      joinRcloneDestination(this.config.destination, `${machine}/index.jsonl.age`),
+      this.config.rcloneConfig
+    );
+  }
+  async putArchiveObjects(sourceRoot) {
+    await copyTree(sourceRoot, this.config.destination, this.config.rcloneConfig);
+  }
+  async putIndex(machine, sourcePath) {
+    await copyFile(
+      sourcePath,
+      joinRcloneDestination(this.config.destination, `${machine}/index.jsonl.age`),
+      this.config.rcloneConfig
+    );
+  }
+  async getIndex(machine, destinationPath) {
+    await copyFile(
+      joinRcloneDestination(this.config.destination, `${machine}/index.jsonl.age`),
+      destinationPath,
+      this.config.rcloneConfig
+    );
+  }
+  async getArchiveObject(machine, archivePath, destinationPath) {
+    await copyFile(
+      joinRcloneDestination(this.config.destination, `${machine}/${archivePath}.age`),
+      destinationPath,
+      this.config.rcloneConfig
+    );
+  }
+};
+function createArchiveRemote(config) {
+  switch (config.type) {
+    case "rclone":
+      return new RcloneArchiveRemote(config);
+  }
+}
+
+// src/offbox/outbox.ts
+var WEEK_MS = 7 * 24 * 60 * 60 * 1e3;
+var REMINDER = "If this laptop dies, sessions not copied off-box die with it.";
+function isUploadedRecord(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const record = value;
+  return record.v === 1 && typeof record.path === "string" && typeof record.mtimeMs === "number" && typeof record.uploadedAt === "string" && typeof record.recipient === "string" && typeof record.destination === "string" && (record.rcloneConfig === "managed" || record.rcloneConfig === "default");
+}
+function parseUploadedRecords(contents) {
+  const records = /* @__PURE__ */ new Map();
+  for (const line of contents.split("\n")) {
+    if (line.trim() === "") {
+      continue;
+    }
+    try {
+      const value = JSON.parse(line);
+      if (isUploadedRecord(value)) {
+        records.set(value.path, value);
+      }
+    } catch {
+    }
+  }
+  return records;
+}
+async function readUploadedRecords(path) {
+  try {
+    return parseUploadedRecords(await readFile8(path, "utf8"));
+  } catch (error) {
+    if (isEnoent(error)) {
+      return /* @__PURE__ */ new Map();
+    }
+    throw error;
+  }
+}
+async function readIndexState(path) {
+  try {
+    const value = JSON.parse(await readFile8(path, "utf8"));
+    if (typeof value === "object" && value !== null && value.v === 1 && typeof value.hash === "string" && typeof value.recipient === "string") {
+      return value;
+    }
+    return null;
+  } catch (error) {
+    if (isEnoent(error) || error instanceof SyntaxError) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function pathExists2(path) {
+  try {
+    await stat6(path);
+    return true;
+  } catch (error) {
+    if (isEnoent(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+async function walkArchiveFiles(machinePath, machine) {
+  const files = [];
+  async function walk(path) {
+    for (const entry of await readdir2(path, { withFileTypes: true })) {
+      const child = join20(path, entry.name);
+      if (entry.isDirectory()) {
+        await walk(child);
+      } else if (entry.isFile()) {
+        const pathFromMachine = relative5(machinePath, child);
+        if (pathFromMachine !== "index.jsonl") {
+          files.push({
+            path: join20(machine, pathFromMachine),
+            absolutePath: child,
+            mtimeMs: (await stat6(child)).mtimeMs
+          });
+        }
+      }
+    }
+  }
+  await walk(machinePath);
+  return files.sort((left, right) => left.path.localeCompare(right.path));
+}
+async function encryptFile(source, destination, recipient) {
+  await mkdir9(dirname6(destination), { recursive: true });
+  const temporary = join20(dirname6(destination), `.${basename3(destination)}.tmp-${process.pid}-${randomUUID6()}`);
+  try {
+    const ciphertext = await encryptToRecipient(recipient, await readFile8(source));
+    await writeFile6(temporary, ciphertext);
+    await rename4(temporary, destination);
+    return ciphertext.byteLength;
+  } catch (error) {
+    await rm8(temporary, { force: true });
+    throw error;
+  }
+}
+async function publishRemote(home, config, offbox, remoteConfig) {
+  const machinePath = join20(config.archiveRoot, config.machine);
+  const indexPath = join20(machinePath, "index.jsonl");
+  await mkdir9(machinePath, { recursive: true });
+  await writeFile6(indexPath, "", { flag: "a" });
+  const statePath = remoteStatePath(home, remoteConfig);
+  const uploadedPath = join20(statePath, "uploaded.jsonl");
+  const successPath = join20(statePath, "last-success.json");
+  const indexStatePath = join20(statePath, "index.json");
+  const uploaded = await readUploadedRecords(uploadedPath);
+  const previousIndex = await readIndexState(indexStatePath);
+  const remote = createArchiveRemote(remoteConfig);
+  const hasPublished = uploaded.size > 0 || previousIndex !== null || await pathExists2(successPath);
+  if (!hasPublished && await remote.indexExists(config.machine)) {
+    throw new PackbatError(
+      `an archive for machine \`${config.machine}\` already exists at the remote; restore it first (\`packbat restore --from-remote --identity <kit-file>\`) or change \`machine\` in config.json.`
+    );
+  }
+  const archiveFiles = await walkArchiveFiles(machinePath, config.machine);
+  const changed = archiveFiles.filter((file) => {
+    const previous = uploaded.get(file.path);
+    return previous === void 0 || previous.recipient !== offbox.recipient || previous.destination !== remoteConfig.destination || previous.rcloneConfig !== remoteConfig.rcloneConfig || file.mtimeMs > previous.mtimeMs;
+  });
+  const outboxPath = join20(statePath, "outbox");
+  await rm8(outboxPath, { recursive: true, force: true });
+  let bytes = 0;
+  for (const file of changed) {
+    bytes += await encryptFile(file.absolutePath, join20(outboxPath, `${file.path}.age`), offbox.recipient);
+  }
+  if (changed.length > 0) {
+    await remote.putArchiveObjects(outboxPath);
+  }
+  const indexContents = await readFile8(indexPath);
+  const indexHash = createHash6("sha256").update(indexContents).digest("hex");
+  const indexChanged = previousIndex?.hash !== indexHash || previousIndex.recipient !== offbox.recipient;
+  const encryptedIndexPath = join20(outboxPath, config.machine, "index.jsonl.age");
+  if (indexChanged) {
+    await encryptFile(indexPath, encryptedIndexPath, offbox.recipient);
+    await remote.putIndex(config.machine, encryptedIndexPath);
+  }
+  const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (changed.length > 0) {
+    await mkdir9(statePath, { recursive: true });
+    await appendFile3(
+      uploadedPath,
+      `${changed.map(
+        (file) => JSON.stringify({
+          v: 1,
+          path: file.path,
+          mtimeMs: file.mtimeMs,
+          uploadedAt: finishedAt,
+          recipient: offbox.recipient,
+          destination: remoteConfig.destination,
+          rcloneConfig: remoteConfig.rcloneConfig
+        })
+      ).join("\n")}
+`
+    );
+  }
+  if (indexChanged) {
+    await writeAtomicJson(indexStatePath, { v: 1, hash: indexHash, recipient: offbox.recipient });
+  }
+  await rm8(outboxPath, { recursive: true, force: true });
+  const result = {
+    destination: remote.destination,
+    finishedAt,
+    uploaded: changed.length,
+    bytes,
+    indexUploaded: indexChanged
+  };
+  await writeAtomicJson(successPath, result);
+  return { ok: true, ...result };
+}
+async function publishOffbox(home, config, offbox) {
+  const outcomes = [];
+  for (const remote of offbox.remotes) {
+    try {
+      outcomes.push(await publishRemote(home, config, offbox, remote));
+    } catch (error) {
+      outcomes.push({
+        destination: remote.destination,
+        ok: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return outcomes;
+}
+async function remindOffboxSkipped(home, now = /* @__PURE__ */ new Date()) {
+  const stampPath = join20(home.statePath, "offbox-reminder.json");
+  let remindedAtMs = Number.NaN;
+  try {
+    const value = JSON.parse(await readFile8(stampPath, "utf8"));
+    const remindedAt = typeof value === "object" && value !== null ? value.remindedAt : void 0;
+    if (typeof remindedAt === "string") {
+      remindedAtMs = Date.parse(remindedAt);
+    }
+  } catch (error) {
+    if (!isEnoent(error) && !(error instanceof SyntaxError)) {
+      throw error;
+    }
+  }
+  if (!Number.isNaN(remindedAtMs) && now.getTime() - remindedAtMs < WEEK_MS) {
+    return;
+  }
+  await appendLog(home.logsPath, REMINDER, now);
+  await writeAtomicJson(stampPath, { remindedAt: now.toISOString() });
+}
+
+// src/commands/sync.ts
+var USAGE2 = "Usage: packbat sync\n";
+function reportSummary(summary, options) {
+  options.onSummary?.(summary);
+  if (options.writeSummary !== false) {
+    process.stdout.write(`${summary}
+`);
+  }
+}
+function offboxSummary(outcomes) {
+  return `off-box ${outcomes.filter((outcome) => outcome.ok).length}/${outcomes.length}`;
+}
+async function runSync(argv, output = {}) {
+  if (argv.length > 0) {
+    process.stderr.write(USAGE2);
+    return 1;
+  }
+  const home = resolveHome();
+  const config = loadConfig(home);
+  assertZstdSupport();
+  const locked = await withSyncLock(home.statePath, async () => {
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    let archived = 0;
+    let unchanged = 0;
+    let failed = 0;
+    let repaired = 0;
+    let errors = [];
+    let offboxOutcomes = [];
+    let offboxError;
+    try {
+      const result = await sweep(config, process.env);
+      archived = result.archived;
+      unchanged = result.unchanged;
+      failed = result.failed;
+      repaired = result.repaired;
+      errors = result.errors;
+    } catch (error) {
+      failed = 1;
+      errors = [`sweep: ${error instanceof Error ? error.message : String(error)}`];
+    }
+    const ok = failed === 0;
+    if (ok) {
+      try {
+        if (config.offbox.mode === "configured") {
+          offboxOutcomes = await publishOffbox(home, config, config.offbox);
+        } else {
+          await remindOffboxSkipped(home);
+        }
+      } catch (error) {
+        offboxError = error instanceof Error ? error.message : String(error);
+      }
+    }
+    const offboxFailures = offboxOutcomes.filter(
+      (outcome) => !outcome.ok && outcome.error !== void 0
+    );
+    const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const summary = `archived ${archived}, unchanged ${unchanged}, failed ${failed}${repaired > 0 ? `, repaired ${repaired}` : ""}${offboxOutcomes.length > 0 ? `, ${offboxSummary(offboxOutcomes)}` : ""}`;
+    await writeRunStamps(home.statePath, {
+      startedAt,
+      finishedAt,
+      ok,
+      archived,
+      unchanged,
+      failed,
+      repaired,
+      ...offboxFailures.length > 0 ? { offbox: offboxFailures.map((outcome) => `${outcome.destination}: ${outcome.error}`).join("; ") } : offboxError === void 0 ? {} : { offbox: offboxError }
+    });
+    await appendLog(home.logsPath, summary, new Date(finishedAt));
+    if (offboxError !== void 0) {
+      await appendLog(home.logsPath, `off-box failed: ${offboxError}`, new Date(finishedAt));
+    }
+    for (const outcome of offboxFailures) {
+      await appendLog(home.logsPath, `off-box failed (${outcome.destination}): ${outcome.error}`, new Date(finishedAt));
+    }
+    for (const error of errors) {
+      process.stderr.write(`packbat sync: ${error}
+`);
+    }
+    if (offboxError !== void 0) {
+      process.stderr.write(`packbat sync: off-box: ${offboxError}
+`);
+    }
+    for (const outcome of offboxFailures) {
+      process.stderr.write(`packbat sync: off-box ${outcome.destination}: ${outcome.error}
+`);
+    }
+    reportSummary(summary, output);
+    return ok && offboxFailures.length === 0 && offboxError === void 0 ? 0 : 1;
+  });
+  if (!locked.acquired) {
+    output.onBusy?.();
+    reportSummary("sync already running", output);
+    return 0;
+  }
+  return locked.value;
+}
+
+export {
+  PackbatError,
+  errorMessage,
+  loadConfig,
+  resolveHome,
+  isEnoent,
+  readDirectoryOrEmpty,
+  HARNESS_IDS,
+  UUID_SOURCE,
+  isHarnessId,
+  adapters,
+  getAdapter,
+  commandOnPath,
+  isDatabaseSnapshotIndexRecord,
+  readIndex,
+  readDerivedIndex,
+  createDoctorContext,
+  checkInstalled,
+  checkLive,
+  ageMs,
+  formatAge,
+  checkFresh,
+  checkOffbox,
+  readHarnessTallies,
+  decompressBytes,
+  runDoctor,
+  previewSchedule,
+  uninstallSchedule,
+  skippedOffboxConfig,
+  userHome2 as userHome,
+  detectInitStores,
+  writeInitConfig,
+  createInitScheduleOptions,
+  installInitSchedule,
+  withRetrievalLock,
+  generateIdentity,
+  identityToRecipient,
+  decryptWithIdentity,
+  parseIdentityFile,
+  discoverRclone,
+  createArchiveRemote,
+  runSync
+};