packbat 0.1.0

package/dist/main.js

@@ -0,0 +1,2541 @@
+import {
+  HARNESS_IDS,
+  PackbatError,
+  UUID_SOURCE,
+  adapters,
+  ageMs,
+  checkFresh,
+  checkInstalled,
+  checkLive,
+  checkOffbox,
+  createArchiveRemote,
+  createDoctorContext,
+  createInitScheduleOptions,
+  decompressBytes,
+  decryptWithIdentity,
+  detectInitStores,
+  errorMessage,
+  formatAge,
+  getAdapter,
+  identityToRecipient,
+  installInitSchedule,
+  isDatabaseSnapshotIndexRecord,
+  isEnoent,
+  isHarnessId,
+  loadConfig,
+  parseIdentityFile,
+  readDerivedIndex,
+  readDirectoryOrEmpty,
+  readHarnessTallies,
+  readIndex,
+  resolveHome,
+  runDoctor,
+  runSync,
+  skippedOffboxConfig,
+  uninstallSchedule,
+  userHome,
+  withRetrievalLock,
+  writeInitConfig
+} from "./chunk-O43RENSG.js";
+
+// src/main.ts
+import { readFileSync } from "fs";
+
+// src/commands/init.ts
+import { existsSync } from "fs";
+import { isAbsolute } from "path";
+var USAGE = `Usage: packbat init --yes [--archive-root <abs>] [--offbox skip|remote]
+       [--offbox-remote <rclone-dest>] [--age-recipient <age1\u2026>]
+       [--rclone-config default|managed] [--no-activate]
+       packbat init --uninstall
+`;
+function usageError(message) {
+  process.stderr.write(`packbat init: ${message}
+
+${USAGE}`);
+  return null;
+}
+function parseOptions(argv) {
+  const options = { yes: false, uninstall: false, noActivate: false };
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    switch (argument) {
+      case "--yes":
+        if (options.yes) {
+          return usageError("--yes may only be passed once");
+        }
+        options.yes = true;
+        break;
+      case "--archive-root": {
+        if (options.archiveRoot !== void 0) {
+          return usageError("--archive-root may only be passed once");
+        }
+        const value = argv[index + 1];
+        if (value === void 0 || value.startsWith("--")) {
+          return usageError("--archive-root requires an absolute path");
+        }
+        if (!isAbsolute(value)) {
+          return usageError("--archive-root requires an absolute path");
+        }
+        options.archiveRoot = value;
+        index += 1;
+        break;
+      }
+      case "--offbox": {
+        if (options.offbox !== void 0) {
+          return usageError("--offbox may only be passed once");
+        }
+        const value = argv[index + 1];
+        if (value !== "skip" && value !== "remote") {
+          return usageError("--offbox only accepts skip or remote");
+        }
+        options.offbox = value;
+        index += 1;
+        break;
+      }
+      case "--offbox-remote": {
+        if (options.offboxRemote !== void 0) {
+          return usageError("--offbox-remote may only be passed once");
+        }
+        const value = argv[index + 1];
+        if (value === void 0 || value.startsWith("--")) {
+          return usageError("--offbox-remote requires an rclone destination");
+        }
+        options.offboxRemote = value;
+        index += 1;
+        break;
+      }
+      case "--age-recipient": {
+        if (options.ageRecipient !== void 0) {
+          return usageError("--age-recipient may only be passed once");
+        }
+        const value = argv[index + 1];
+        if (value === void 0 || value.startsWith("--")) {
+          return usageError("--age-recipient requires an age1\u2026 recipient");
+        }
+        if (!/^age1[0-9a-z]+$/u.test(value)) {
+          return usageError("--age-recipient requires an age1\u2026 recipient");
+        }
+        options.ageRecipient = value;
+        index += 1;
+        break;
+      }
+      case "--rclone-config": {
+        if (options.rcloneConfig !== void 0) {
+          return usageError("--rclone-config may only be passed once");
+        }
+        const value = argv[index + 1];
+        if (value !== "default" && value !== "managed") {
+          return usageError("--rclone-config only accepts default or managed");
+        }
+        options.rcloneConfig = value;
+        index += 1;
+        break;
+      }
+      case "--no-activate":
+        if (options.noActivate) {
+          return usageError("--no-activate may only be passed once");
+        }
+        options.noActivate = true;
+        break;
+      case "--uninstall":
+        if (options.uninstall) {
+          return usageError("--uninstall may only be passed once");
+        }
+        options.uninstall = true;
+        break;
+      default:
+        return usageError(`unknown option ${argument ?? ""}`);
+    }
+  }
+  if (options.uninstall && (options.yes || options.archiveRoot !== void 0 || options.offbox !== void 0 || options.offboxRemote !== void 0 || options.ageRecipient !== void 0 || options.rcloneConfig !== void 0 || options.noActivate)) {
+    return usageError("--uninstall cannot be combined with setup options");
+  }
+  if (options.offbox === "remote") {
+    if (options.offboxRemote === void 0) {
+      return usageError("--offbox remote requires --offbox-remote");
+    }
+    if (options.ageRecipient === void 0) {
+      return usageError("--offbox remote requires --age-recipient");
+    }
+  } else if (options.offboxRemote !== void 0 || options.ageRecipient !== void 0 || options.rcloneConfig !== void 0) {
+    return usageError("off-box remote options require --offbox remote");
+  }
+  return options;
+}
+function requestedOffbox(options) {
+  if (options.offbox === "skip") {
+    return skippedOffboxConfig();
+  }
+  if (options.offbox === "remote") {
+    return {
+      mode: "configured",
+      recipient: options.ageRecipient,
+      remotes: [
+        {
+          type: "rclone",
+          destination: options.offboxRemote,
+          rcloneConfig: options.rcloneConfig ?? "default"
+        }
+      ]
+    };
+  }
+  return void 0;
+}
+async function runInit(argv) {
+  const options = parseOptions(argv);
+  if (options === null) {
+    return 1;
+  }
+  const homePath = userHome();
+  if (options.uninstall) {
+    const result = await uninstallSchedule({
+      userHome: homePath,
+      statePath: resolveHome().statePath,
+      env: process.env
+    });
+    if (result.removedPaths.length === 0) {
+      process.stdout.write("schedule: nothing installed\n");
+    } else {
+      for (const path of result.removedPaths) {
+        process.stdout.write(`removed: ${path}
+`);
+      }
+    }
+    return 0;
+  }
+  if (!options.yes) {
+    if (process.stdin.isTTY === true) {
+      const { runInitWizard } = await import("./init-wizard-PEBPT3M3.js");
+      return await runInitWizard();
+    }
+    process.stderr.write("packbat init: stdin is not a TTY; run `packbat init --yes`\n");
+    return 1;
+  }
+  const home = resolveHome();
+  const detection = detectInitStores(homePath);
+  const config = await writeInitConfig(
+    home,
+    options.archiveRoot ?? (existsSync(home.configPath) ? loadConfig(home).archiveRoot : home.defaultArchiveRoot),
+    requestedOffbox(options)
+  );
+  const installed = await installInitSchedule(await createInitScheduleOptions(home, homePath), !options.noActivate);
+  process.stdout.write(`detected: ${detection.detected.map(({ displayName }) => displayName).join(", ") || "none"}
+`);
+  if (detection.unsupported.length === 0) {
+    process.stdout.write("found, not yet supported: none\n");
+  } else {
+    for (const { displayName, path } of detection.unsupported) {
+      process.stdout.write(`found, not yet supported: ${displayName} (${path})
+`);
+    }
+  }
+  process.stdout.write(`archive: ${config.archiveRoot}
+`);
+  for (const path of installed.schedule.artifactPaths) {
+    process.stdout.write(`wrote: ${path}
+`);
+  }
+  for (const note of [...installed.schedule.notes, ...installed.activationNotes]) {
+    process.stdout.write(`${note}
+`);
+  }
+  const syncCode = await runSync([]);
+  const doctorCode = await runDoctor([]);
+  return syncCode === 1 || doctorCode === 1 ? 1 : 0;
+}
+
+// src/core/restore.ts
+import { createHash, randomUUID } from "crypto";
+import { mkdir, readFile, rename, rm, stat, utimes, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { basename, dirname, isAbsolute as isAbsolute2, join, relative, resolve, sep } from "path";
+function recordRelPath(record) {
+  const prefix = `${record.harness}${sep}`;
+  if (!record.path.startsWith(prefix) || !record.path.endsWith(".zst")) {
+    throw new PackbatError(`invalid archive path in index: ${record.path}`);
+  }
+  const relPath = record.path.slice(prefix.length, -".zst".length);
+  if (relPath === "" || isAbsolute2(relPath)) {
+    throw new PackbatError(`invalid archive path in index: ${record.path}`);
+  }
+  return relPath;
+}
+function assertContained(root, path, label) {
+  const fromRoot = relative(resolve(root), resolve(path));
+  if (fromRoot === "" || fromRoot === ".." || fromRoot.startsWith(`..${sep}`) || isAbsolute2(fromRoot)) {
+    throw new PackbatError(`${label} escapes its root: ${path}`);
+  }
+}
+function compareRecordRecency(left, right) {
+  if (left.sourceMtimeMs !== right.sourceMtimeMs) {
+    return left.sourceMtimeMs - right.sourceMtimeMs;
+  }
+  const archivedAt = left.archivedAt.localeCompare(right.archivedAt);
+  return archivedAt !== 0 ? archivedAt : left.path.localeCompare(right.path);
+}
+function codexState(record) {
+  const relPath = recordRelPath(record);
+  if (relPath.startsWith(`sessions${sep}`)) {
+    return "active";
+  }
+  if (relPath.startsWith(`archived_sessions${sep}`)) {
+    return "archived";
+  }
+  return null;
+}
+function selectCodexState(records) {
+  const hasActive = records.some((record) => codexState(record) === "active");
+  const hasArchived = records.some((record) => codexState(record) === "archived");
+  if (!hasActive || !hasArchived) {
+    return { records, supersededLocations: [] };
+  }
+  const newest = records.reduce((current, record) => compareRecordRecency(record, current) > 0 ? record : current);
+  const selectedState = codexState(newest);
+  const selected = records.filter((record) => codexState(record) === selectedState);
+  const supersededLocations = records.filter((record) => codexState(record) !== selectedState).map(recordRelPath).sort((left, right) => left.localeCompare(right));
+  return { records: selected, supersededLocations };
+}
+function toArchivedUnit(config, machine, harness, id, records) {
+  const selected = harness === "codex" ? selectCodexState(records) : { records, supersededLocations: [] };
+  const machineRoot = join(config.archiveRoot, machine);
+  const files = selected.records.map((record) => {
+    const archivePath = join(machineRoot, record.path);
+    assertContained(machineRoot, archivePath, "archive path");
+    return { record, relPath: recordRelPath(record), archivePath };
+  }).sort((left, right) => {
+    if (left.record.role !== right.record.role) {
+      return left.record.role === "main" ? -1 : 1;
+    }
+    return left.relPath.localeCompare(right.relPath);
+  });
+  const newestSourceMtimeMs = Math.max(...files.map((file) => file.record.sourceMtimeMs));
+  return {
+    kind: "session",
+    id,
+    harness,
+    machine,
+    files,
+    newestSourceMtimeMs,
+    archived: harness === "codex" && files.some((file) => codexState(file.record) === "archived"),
+    supersededLocations: selected.supersededLocations
+  };
+}
+function toArchivedSnapshotUnit(config, machine, id, record) {
+  const machineRoot = join(config.archiveRoot, machine);
+  const archivePath = join(machineRoot, record.path);
+  assertContained(machineRoot, archivePath, "archive path");
+  return {
+    kind: "db-snapshot",
+    id,
+    harness: record.harness,
+    machine,
+    files: [{ record, relPath: recordRelPath(record), archivePath }],
+    newestSourceMtimeMs: record.sourceMtimeMs,
+    archived: false,
+    supersededLocations: []
+  };
+}
+function attachGeminiProjectMarkers(groups) {
+  const markers = /* @__PURE__ */ new Map();
+  for (const group of groups.values()) {
+    if (group.harness !== "gemini") {
+      continue;
+    }
+    for (const record of group.records) {
+      const parts = recordRelPath(record).split(sep);
+      if (parts.length === 2 && parts[1] === ".project_root") {
+        markers.set(parts[0], record);
+      }
+    }
+  }
+  for (const group of groups.values()) {
+    if (group.harness !== "gemini") {
+      continue;
+    }
+    const main2 = group.records.find((record) => record.role === "main");
+    if (main2 === void 0) {
+      continue;
+    }
+    const parts = recordRelPath(main2).split(sep);
+    const marker = parts[1] === "chats" ? markers.get(parts[0]) : void 0;
+    if (marker !== void 0 && !group.records.some((record) => record.path === marker.path)) {
+      group.records.push(marker);
+    }
+  }
+}
+async function readArchivedUnits(config, machine) {
+  let records;
+  try {
+    records = [...(await readDerivedIndex(join(config.archiveRoot, machine), machine)).records.values()].filter(
+      (record) => record.machine === machine
+    );
+  } catch (error) {
+    throw new PackbatError(`could not read archive index for ${machine}: ${errorMessage(error)}`);
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const record of records.filter((record2) => !isDatabaseSnapshotIndexRecord(record2))) {
+    const key = `${record.harness}\0${record.unit}`;
+    const group = groups.get(key);
+    if (group === void 0) {
+      groups.set(key, { harness: record.harness, id: record.unit, records: [record] });
+    } else {
+      group.records.push(record);
+    }
+  }
+  attachGeminiProjectMarkers(groups);
+  const newestSnapshots = /* @__PURE__ */ new Map();
+  for (const record of records.filter(isDatabaseSnapshotIndexRecord)) {
+    for (const session of record.sessions) {
+      const key = `${record.harness}\0${session.id}`;
+      const current = newestSnapshots.get(key);
+      if (current === void 0 || compareRecordRecency(record, current.record) > 0) {
+        newestSnapshots.set(key, { id: session.id, record });
+      }
+    }
+  }
+  return [
+    ...[...groups.values()].map((group) => toArchivedUnit(config, machine, group.harness, group.id, group.records)),
+    ...[...newestSnapshots.values()].map(({ id, record }) => toArchivedSnapshotUnit(config, machine, id, record))
+  ].sort(
+    (left, right) => right.newestSourceMtimeMs - left.newestSourceMtimeMs || left.id.localeCompare(right.id) || left.harness.localeCompare(right.harness)
+  );
+}
+function resolveArchivedUnit(units, prefix) {
+  const matchingIds = [...new Set(units.filter((unit) => unit.id.startsWith(prefix)).map((unit) => unit.id))].sort(
+    (left, right) => left.localeCompare(right)
+  );
+  if (matchingIds.length === 0) {
+    throw new PackbatError(`no archived unit matches "${prefix}"`);
+  }
+  if (matchingIds.length > 1) {
+    throw new PackbatError(
+      `archive prefix "${prefix}" is ambiguous:
+${matchingIds.map((id2) => `  ${id2}`).join("\n")}`
+    );
+  }
+  const id = matchingIds[0];
+  const matches = units.filter((unit) => unit.id === id);
+  if (matches.length !== 1) {
+    throw new PackbatError(
+      `archive id "${id}" exists in multiple harnesses:
+${matches.map((unit) => `  ${unit.id} (${unit.harness})`).join("\n")}`
+    );
+  }
+  return matches[0];
+}
+async function liveMtime(path) {
+  try {
+    return (await stat(path)).mtimeMs;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw new PackbatError(`could not inspect live target ${path}: ${errorMessage(error)}`);
+  }
+}
+async function writeRestoredFile(plan) {
+  let archivedBytes;
+  try {
+    archivedBytes = await readFile(plan.file.archivePath);
+  } catch (error) {
+    throw new PackbatError(`could not read archived file ${plan.file.archivePath}: ${errorMessage(error)}`);
+  }
+  const actualSha256 = createHash("sha256").update(archivedBytes).digest("hex");
+  if (actualSha256 !== plan.file.record.sha256) {
+    throw new PackbatError(`archived file is corrupt: ${plan.file.archivePath} (sha256 mismatch)`);
+  }
+  let bytes;
+  try {
+    bytes = decompressBytes(archivedBytes);
+  } catch (error) {
+    throw new PackbatError(`could not read archived file ${plan.file.archivePath}: ${errorMessage(error)}`);
+  }
+  await mkdir(dirname(plan.target), { recursive: true });
+  const temporary = join(dirname(plan.target), `.${basename(plan.target)}.tmp-${process.pid}-${randomUUID()}`);
+  try {
+    await writeFile(temporary, bytes);
+    await rename(temporary, plan.target);
+    const mtimeSeconds = plan.file.record.sourceMtimeMs / 1e3;
+    await utimes(plan.target, mtimeSeconds, mtimeSeconds);
+  } catch (error) {
+    await rm(temporary, { force: true });
+    throw new PackbatError(`could not restore ${plan.target}: ${errorMessage(error)}`);
+  }
+}
+async function archivedPayload(file) {
+  let archivedBytes;
+  try {
+    archivedBytes = await readFile(file.archivePath);
+  } catch (error) {
+    throw new PackbatError(`could not read archived file ${file.archivePath}: ${errorMessage(error)}`);
+  }
+  const actualSha256 = createHash("sha256").update(archivedBytes).digest("hex");
+  if (actualSha256 !== file.record.sha256) {
+    throw new PackbatError(`archived file is corrupt: ${file.archivePath} (sha256 mismatch)`);
+  }
+  try {
+    return decompressBytes(archivedBytes);
+  } catch (error) {
+    throw new PackbatError(`could not read archived file ${file.archivePath}: ${errorMessage(error)}`);
+  }
+}
+function sideBySidePath(target, sessionId) {
+  return join(dirname(target), `opencode-restored-${sessionId}.db`);
+}
+async function restoreDatabaseSnapshot(unit) {
+  const adapter = getAdapter(unit.harness);
+  if (adapter === void 0 || adapter.mutationModel !== "db-snapshot") {
+    throw new PackbatError(`archive uses unsupported database snapshot harness ${unit.harness}`);
+  }
+  const target = adapter.storeRoot(process.env, homedir());
+  if (await liveMtime(target) !== null) {
+    const recoveryPath = sideBySidePath(target, unit.id);
+    throw new PackbatError(
+      `restore requires an absent OpenCode database: ${target}
+side-by-side recovery: OPENCODE_DB=${recoveryPath} opencode -s ${unit.id}`
+    );
+  }
+  const file = unit.files[0];
+  if (file === void 0 || unit.files.length !== 1 || !isDatabaseSnapshotIndexRecord(file.record)) {
+    throw new PackbatError(`invalid database snapshot archive for ${unit.id}`);
+  }
+  const bytes = await archivedPayload(file);
+  const contentSha256 = createHash("sha256").update(bytes).digest("hex");
+  if (contentSha256 !== file.record.contentSha256) {
+    throw new PackbatError(`archived database is corrupt: ${file.archivePath} (content sha256 mismatch)`);
+  }
+  await mkdir(dirname(target), { recursive: true });
+  const temporary = join(dirname(target), `.${basename(target)}.tmp-${process.pid}-${randomUUID()}`);
+  try {
+    await writeFile(temporary, bytes);
+    await adapter.validateSnapshot(temporary, unit.id);
+    if (await liveMtime(target) !== null) {
+      const recoveryPath = sideBySidePath(target, unit.id);
+      throw new PackbatError(
+        `restore requires an absent OpenCode database: ${target}
+side-by-side recovery: OPENCODE_DB=${recoveryPath} opencode -s ${unit.id}`
+      );
+    }
+    await Promise.all([rm(`${target}-wal`, { force: true }), rm(`${target}-shm`, { force: true })]);
+    await rename(temporary, target);
+  } catch (error) {
+    await rm(temporary, { force: true });
+    if (error instanceof PackbatError) {
+      throw error;
+    }
+    throw new PackbatError(`could not restore ${target}: ${errorMessage(error)}`);
+  }
+  return {
+    fileCount: 1,
+    targetRoot: target,
+    resumeHints: adapter.resumeHint({ id: unit.id, targetPath: target })
+  };
+}
+async function restoreArchivedUnit(unit, force) {
+  if (unit.kind === "db-snapshot") {
+    return await restoreDatabaseSnapshot(unit);
+  }
+  const adapter = getAdapter(unit.harness);
+  if (adapter === void 0 || adapter.mutationModel === "db-snapshot") {
+    throw new PackbatError(`archive uses unsupported harness ${unit.harness}`);
+  }
+  const targetRoot = adapter.storeRoot(process.env, homedir());
+  const plans = unit.files.map((file) => {
+    const target = adapter.restoreTarget(targetRoot, file.relPath);
+    assertContained(targetRoot, target, "restore target");
+    return { file, target };
+  });
+  const targets = /* @__PURE__ */ new Set();
+  for (const plan of plans) {
+    if (targets.has(plan.target)) {
+      throw new PackbatError(`archive maps more than one file to ${plan.target}`);
+    }
+    targets.add(plan.target);
+  }
+  const offenders = [];
+  for (const plan of plans) {
+    const mtimeMs = await liveMtime(plan.target);
+    if (mtimeMs !== null && mtimeMs > plan.file.record.sourceMtimeMs) {
+      offenders.push(plan.target);
+    }
+  }
+  if (!force && offenders.length > 0) {
+    throw new PackbatError(
+      `restore would overwrite newer live files:
+${offenders.map((path) => `  ${path}`).join("\n")}`
+    );
+  }
+  for (const plan of plans) {
+    await writeRestoredFile(plan);
+  }
+  return {
+    fileCount: plans.length,
+    targetRoot,
+    resumeHints: adapter.resumeHint({ id: unit.id, relPaths: unit.files.map((file) => file.relPath) })
+  };
+}
+
+// src/offbox/remote-restore.ts
+import { mkdir as mkdir2, mkdtemp, readFile as readFile2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir } from "os";
+import { dirname as dirname2, join as join2 } from "path";
+async function readIdentity(path) {
+  try {
+    return parseIdentityFile(await readFile2(path, "utf8"));
+  } catch (error) {
+    if (error instanceof PackbatError) {
+      throw error;
+    }
+    throw new PackbatError(`could not read identity file ${path}: ${errorMessage(error)}`);
+  }
+}
+async function pullAndDecryptFile(options) {
+  await mkdir2(dirname2(options.encryptedPath), { recursive: true });
+  await options.pull(options.encryptedPath);
+  try {
+    await writeFile2(
+      options.decryptedPath,
+      await decryptWithIdentity(options.identity, await readFile2(options.encryptedPath))
+    );
+  } catch (error) {
+    throw new PackbatError(`could not decrypt ${options.label}: ${errorMessage(error)}`);
+  }
+}
+function selectRemote(config, destination) {
+  if (config.offbox.mode !== "configured") {
+    throw new PackbatError("off-box is not configured; run `packbat init` first");
+  }
+  if (destination === void 0) {
+    return config.offbox.remotes[0];
+  }
+  const remote = config.offbox.remotes.find((candidate) => candidate.destination === destination);
+  if (remote === void 0) {
+    throw new PackbatError(`no configured remote has destination ${destination}`);
+  }
+  return remote;
+}
+async function restoreFromRemote(options) {
+  if (options.config.offbox.mode !== "configured") {
+    throw new PackbatError("off-box is not configured; run `packbat init` first");
+  }
+  const offbox = options.config.offbox;
+  const remoteConfig = selectRemote(options.config, options.remoteDestination);
+  const remote = createArchiveRemote(remoteConfig);
+  const identity = await readIdentity(options.identityPath);
+  let recipient;
+  try {
+    recipient = await identityToRecipient(identity);
+  } catch (error) {
+    throw new PackbatError(`could not parse age identity: ${errorMessage(error)}`);
+  }
+  if (recipient !== offbox.recipient) {
+    throw new PackbatError("identity does not match the configured age recipient");
+  }
+  const stagePath = await mkdtemp(join2(tmpdir(), "packbat-remote-restore-"));
+  try {
+    const machinePath = join2(stagePath, options.machine);
+    const encryptedIndexPath = join2(stagePath, "index.jsonl.age");
+    await mkdir2(machinePath, { recursive: true });
+    await pullAndDecryptFile({
+      pull: async (destinationPath) => await remote.getIndex(options.machine, destinationPath),
+      encryptedPath: encryptedIndexPath,
+      decryptedPath: join2(machinePath, "index.jsonl"),
+      identity,
+      label: "remote index"
+    });
+    const stageConfig = { ...options.config, archiveRoot: stagePath };
+    const units = await readArchivedUnits(stageConfig, options.machine);
+    if (options.prefix === void 0) {
+      return { kind: "listed", units };
+    }
+    const unit = resolveArchivedUnit(units, options.prefix);
+    for (const file of unit.files) {
+      const encryptedPath = `${file.archivePath}.age`;
+      await pullAndDecryptFile({
+        pull: async (destinationPath) => await remote.getArchiveObject(options.machine, file.record.path, destinationPath),
+        encryptedPath,
+        decryptedPath: file.archivePath,
+        identity,
+        label: `remote file ${file.record.path}`
+      });
+    }
+    return { kind: "restored", unit, restore: await restoreArchivedUnit(unit, options.force) };
+  } finally {
+    await rm2(stagePath, { recursive: true, force: true });
+  }
+}
+
+// src/commands/restore.ts
+var USAGE2 = "Usage: packbat restore [--machine <name>] [--force] [--from-remote --identity <file> [--remote <destination>]] [<id-or-prefix>]\n";
+var MACHINE_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+function usageError2(message) {
+  process.stderr.write(`packbat restore: ${message}
+
+${USAGE2}`);
+  return null;
+}
+function parseOptions2(argv) {
+  const options = { force: false, fromRemote: false };
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    switch (argument) {
+      case "--machine": {
+        if (options.machine !== void 0) {
+          return usageError2("--machine may only be passed once");
+        }
+        const value = argv[index + 1];
+        if (value === void 0 || value.startsWith("--")) {
+          return usageError2("--machine requires a name");
+        }
+        if (!MACHINE_PATTERN.test(value)) {
+          return usageError2("--machine must be lowercase and hostname-safe (a-z, 0-9, -)");
+        }
+        options.machine = value;
+        index += 1;
+        break;
+      }
+      case "--force":
+        if (options.force) {
+          return usageError2("--force may only be passed once");
+        }
+        options.force = true;
+        break;
+      case "--from-remote":
+        if (options.fromRemote) {
+          return usageError2("--from-remote may only be passed once");
+        }
+        options.fromRemote = true;
+        break;
+      case "--identity": {
+        if (options.identityPath !== void 0) {
+          return usageError2("--identity may only be passed once");
+        }
+        const value = argv[index + 1];
+        if (value === void 0 || value.startsWith("--")) {
+          return usageError2("--identity requires a file");
+        }
+        options.identityPath = value;
+        index += 1;
+        break;
+      }
+      case "--remote": {
+        if (options.remoteDestination !== void 0) {
+          return usageError2("--remote may only be passed once");
+        }
+        const value = argv[index + 1];
+        if (value === void 0 || value.startsWith("--")) {
+          return usageError2("--remote requires a destination");
+        }
+        options.remoteDestination = value;
+        index += 1;
+        break;
+      }
+      default:
+        if (argument === void 0) {
+          return usageError2("missing argument");
+        }
+        if (argument.startsWith("-")) {
+          return usageError2(`unknown option ${argument}`);
+        }
+        if (options.prefix !== void 0) {
+          return usageError2("only one id or prefix may be passed");
+        }
+        options.prefix = argument;
+    }
+  }
+  if (options.force && options.prefix === void 0) {
+    return usageError2("--force requires an id or prefix");
+  }
+  if (options.fromRemote && options.identityPath === void 0) {
+    return usageError2("--from-remote requires --identity <file>");
+  }
+  if (!options.fromRemote && options.identityPath !== void 0) {
+    return usageError2("--identity requires --from-remote");
+  }
+  if (!options.fromRemote && options.remoteDestination !== void 0) {
+    return usageError2("--remote requires --from-remote");
+  }
+  return options;
+}
+function printUnits(machine, units) {
+  if (units.length === 0) {
+    process.stdout.write(`no archived sessions for ${machine}
+`);
+    return;
+  }
+  for (const unit of units) {
+    const fileCount = `${unit.files.length} file${unit.files.length === 1 ? "" : "s"}`;
+    const archived = unit.archived ? " \xB7 archived" : "";
+    process.stdout.write(
+      `${unit.id} \xB7 ${unit.harness} \xB7 ${unit.machine} \xB7 ${fileCount} \xB7 ${new Date(unit.newestSourceMtimeMs).toISOString()}${archived}
+`
+    );
+  }
+}
+function printRestoreResult(unit, result) {
+  for (const location of unit.supersededLocations) {
+    process.stdout.write(`superseded codex location: ${location}
+`);
+  }
+  process.stdout.write(
+    `restored ${result.fileCount} file${result.fileCount === 1 ? "" : "s"} to ${result.targetRoot}
+`
+  );
+  for (const hint of result.resumeHints) {
+    process.stdout.write(`${hint}
+`);
+  }
+}
+async function runRestore(argv) {
+  const options = parseOptions2(argv);
+  if (options === null) {
+    return 1;
+  }
+  const home = resolveHome();
+  const config = loadConfig(home);
+  const machine = options.machine ?? config.machine;
+  if (options.fromRemote) {
+    const remote = await restoreFromRemote({
+      config,
+      machine,
+      identityPath: options.identityPath,
+      remoteDestination: options.remoteDestination,
+      prefix: options.prefix,
+      force: options.force
+    });
+    if (remote.kind === "listed") {
+      printUnits(machine, remote.units);
+    } else {
+      printRestoreResult(remote.unit, remote.restore);
+    }
+    return 0;
+  }
+  const units = await readArchivedUnits(config, machine);
+  if (options.prefix === void 0) {
+    printUnits(machine, units);
+    return 0;
+  }
+  const unit = resolveArchivedUnit(units, options.prefix);
+  const result = await restoreArchivedUnit(unit, options.force);
+  printRestoreResult(unit, result);
+  return 0;
+}
+
+// src/commands/search.ts
+import { resolve as resolve2 } from "path";
+
+// src/retrieval/database.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { chmod, mkdir as mkdir3, rename as rename2, rm as rm3, stat as stat3 } from "fs/promises";
+import { createRequire } from "module";
+import { basename as basename2, dirname as dirname3, join as join4 } from "path";
+
+// src/readers/common.ts
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+import { createZstdDecompress } from "zlib";
+var MAX_ISSUES = 100;
+function asObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function stringField(object, key) {
+  const value = object?.[key];
+  return typeof value === "string" ? value : null;
+}
+function timestamp(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const milliseconds = Date.parse(value);
+  return Number.isNaN(milliseconds) ? null : new Date(milliseconds).toISOString();
+}
+function stringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return [...new Set(value.filter((item) => typeof item === "string"))];
+}
+function textContent(value) {
+  if (typeof value === "string") {
+    return value === "" ? [] : [value];
+  }
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const texts = [];
+  for (const item of value) {
+    const block = asObject(item);
+    if (block?.type === "text" && typeof block.text === "string" && block.text !== "") {
+      texts.push(block.text);
+    } else if (block?.type === "input_text" && typeof block.text === "string" && block.text !== "") {
+      texts.push(block.text);
+    } else if (block?.type === "output_text" && typeof block.text === "string" && block.text !== "") {
+      texts.push(block.text);
+    }
+  }
+  return [...new Set(texts)];
+}
+function addIssue(issues, seen, issue, dedupeKey = `${issue.code}\0${issue.detail}`) {
+  if (issues.length >= MAX_ISSUES || seen.has(dedupeKey)) {
+    return;
+  }
+  seen.add(dedupeKey);
+  issues.push(issue);
+}
+async function parseJsonl(file) {
+  const records = [];
+  const issues = [];
+  let invalidLines = 0;
+  let line = 0;
+  try {
+    const decompressor = createZstdDecompress();
+    const input = createReadStream(file.archivePath);
+    const lines = createInterface({ input: input.pipe(decompressor), crlfDelay: Number.POSITIVE_INFINITY });
+    for await (const contents of lines) {
+      line += 1;
+      if (contents.trim() === "") {
+        continue;
+      }
+      try {
+        const value = JSON.parse(contents);
+        const object = asObject(value);
+        if (object === null) {
+          invalidLines += 1;
+          issues.push({
+            sourcePath: file.path,
+            sourceLine: line,
+            code: "invalid-record",
+            detail: "skipped JSON value that is not an object"
+          });
+        } else {
+          records.push({ value: object, line });
+        }
+      } catch {
+        invalidLines += 1;
+        if (issues.length < MAX_ISSUES) {
+          issues.push({
+            sourcePath: file.path,
+            sourceLine: line,
+            code: "malformed-json",
+            detail: "skipped malformed JSONL record"
+          });
+        }
+      }
+    }
+    return { records, issues, invalidLines, validLines: records.length, corrupt: false };
+  } catch (error) {
+    return {
+      records,
+      issues: [
+        ...issues,
+        {
+          sourcePath: file.path,
+          sourceLine: null,
+          code: "zstd-corrupt",
+          detail: `could not decompress archive: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      invalidLines,
+      validLines: records.length,
+      corrupt: true
+    };
+  }
+}
+function finishTurns(turns) {
+  turns.sort((left, right) => {
+    if (left.timestamp === null && right.timestamp !== null) {
+      return 1;
+    }
+    if (left.timestamp !== null && right.timestamp === null) {
+      return -1;
+    }
+    return (left.timestamp?.localeCompare(right.timestamp ?? "") ?? 0) || left.sourcePath.localeCompare(right.sourcePath) || left.sourceLine - right.sourceLine;
+  });
+  return turns.map((turn, index) => ({ ...turn, turn: index }));
+}
+function pushUniqueTurn(turns, seen, turn) {
+  if (turn.text === "") {
+    return;
+  }
+  const key = `${turn.sourcePath}\0${turn.sourceLine}\0${turn.role}\0${turn.text}\0${JSON.stringify(turn.filesTouched)}\0${JSON.stringify(turn.commands)}`;
+  if (!seen.has(key)) {
+    seen.add(key);
+    turns.push(turn);
+  }
+}
+function explicitPaths(input) {
+  if (input === null) {
+    return [];
+  }
+  const paths = [];
+  for (const key of ["file_path", "path", "filepath", "absolute_path"]) {
+    const value = input[key];
+    if (typeof value === "string") {
+      paths.push(value);
+    }
+  }
+  for (const key of ["files", "paths", "file_paths"]) {
+    paths.push(...stringArray(input[key]));
+  }
+  return [...new Set(paths)];
+}
+function shellCommands(name, input) {
+  if (name === null || input === null || !/^(bash|shell|exec|exec_command)$/i.test(name)) {
+    return [];
+  }
+  for (const key of ["command", "cmd", "script"]) {
+    const value = input[key];
+    if (typeof value === "string") {
+      return [value];
+    }
+  }
+  return [];
+}
+
+// src/readers/claude-code.ts
+var KNOWN_METADATA = /* @__PURE__ */ new Set([
+  "agent-name",
+  "ai-title",
+  "attachment",
+  "bridge-session",
+  "custom-title",
+  "file-history-snapshot",
+  "last-prompt",
+  "mode",
+  "permission-mode",
+  "pr-link",
+  "queue-operation",
+  "relocated",
+  "system",
+  "worktree-state"
+]);
+var claudeCodeReader = {
+  harness: "claude-code",
+  version: 1,
+  async read(unit) {
+    const turns = [];
+    const turnKeys = /* @__PURE__ */ new Set();
+    const issues = [];
+    const issueKeys = /* @__PURE__ */ new Set();
+    const files = [];
+    for (const file of unit.files) {
+      if (!file.path.endsWith(".jsonl.zst")) {
+        files.push({ path: file.path, status: "ok" });
+        continue;
+      }
+      const parsed = await parseJsonl(file);
+      for (const issue of parsed.issues) {
+        addIssue(issues, issueKeys, issue, `${issue.sourcePath}\0${issue.sourceLine}\0${issue.code}`);
+      }
+      if (parsed.corrupt || parsed.validLines === 0 && parsed.invalidLines > 0) {
+        files.push({ path: file.path, status: "corrupt" });
+        continue;
+      }
+      let project = null;
+      let recognized = false;
+      let filePartial = parsed.invalidLines > 0;
+      for (const record of parsed.records) {
+        const type = stringField(record.value, "type");
+        const ownProject = stringField(record.value, "cwd");
+        if (ownProject !== null) {
+          project = ownProject;
+        }
+        if (type !== "user" && type !== "assistant") {
+          if (type !== null && KNOWN_METADATA.has(type)) {
+            continue;
+          }
+          filePartial = true;
+          addIssue(issues, issueKeys, {
+            sourcePath: file.path,
+            sourceLine: record.line,
+            code: "unknown-record",
+            detail: `skipped record type ${type ?? "<missing>"}`
+          });
+          continue;
+        }
+        recognized = true;
+        const embeddedId = stringField(record.value, "sessionId");
+        if (embeddedId !== null && embeddedId !== unit.id) {
+          filePartial = true;
+          addIssue(issues, issueKeys, {
+            sourcePath: file.path,
+            sourceLine: record.line,
+            code: "identity-mismatch",
+            detail: `session id ${embeddedId} does not match archive unit ${unit.id}`
+          });
+        }
+        const recordTimestamp = timestamp(record.value.timestamp);
+        const message = asObject(record.value.message);
+        const role = type === "user" ? "user" : "assistant";
+        const isSummary = record.value.isCompactSummary === true;
+        for (const text of textContent(message?.content)) {
+          pushUniqueTurn(turns, turnKeys, {
+            timestamp: recordTimestamp,
+            project,
+            role: isSummary ? "summary" : role,
+            text,
+            filesTouched: [],
+            commands: [],
+            sourcePath: file.path,
+            sourceLine: record.line
+          });
+        }
+        if (!Array.isArray(message?.content)) {
+          continue;
+        }
+        for (const rawBlock of message.content) {
+          const block = asObject(rawBlock);
+          const blockType = stringField(block, "type");
+          if (blockType === "tool_use") {
+            const name = stringField(block, "name");
+            const input = asObject(block?.input);
+            pushUniqueTurn(turns, turnKeys, {
+              timestamp: recordTimestamp,
+              project,
+              role: "tool",
+              text: name ?? "tool call",
+              filesTouched: explicitPaths(input),
+              commands: shellCommands(name, input),
+              sourcePath: file.path,
+              sourceLine: record.line
+            });
+          } else if (blockType === "tool_result") {
+            for (const text of textContent(block?.content)) {
+              pushUniqueTurn(turns, turnKeys, {
+                timestamp: recordTimestamp,
+                project,
+                role: "tool",
+                text,
+                filesTouched: [],
+                commands: [],
+                sourcePath: file.path,
+                sourceLine: record.line
+              });
+            }
+          } else if (!["text", "thinking", "image", "document", "fallback"].includes(blockType ?? "")) {
+            filePartial = true;
+            addIssue(issues, issueKeys, {
+              sourcePath: file.path,
+              sourceLine: record.line,
+              code: "unknown-content",
+              detail: `skipped content type ${blockType ?? "<missing>"}`
+            });
+          }
+        }
+      }
+      files.push({
+        path: file.path,
+        status: recognized ? filePartial ? "partial" : "ok" : "unsupported"
+      });
+      if (!recognized) {
+        addIssue(issues, issueKeys, {
+          sourcePath: file.path,
+          sourceLine: null,
+          code: "unsupported-structure",
+          detail: "no recognized Claude Code session records"
+        });
+      }
+    }
+    return { turns: finishTurns(turns), issues, files };
+  }
+};
+
+// src/readers/codex.ts
+function structuredInput(value) {
+  if (typeof value === "string") {
+    try {
+      return asObject(JSON.parse(value));
+    } catch {
+      return null;
+    }
+  }
+  return asObject(value);
+}
+function eventText(payload) {
+  const type = stringField(payload, "type");
+  if (type === "user_message") {
+    return { role: "user", text: stringField(payload, "message") ?? "" };
+  }
+  if (type === "agent_message") {
+    return { role: "assistant", text: stringField(payload, "message") ?? "" };
+  }
+  return null;
+}
+var codexReader = {
+  harness: "codex",
+  version: 1,
+  async read(unit) {
+    const turns = [];
+    const turnKeys = /* @__PURE__ */ new Set();
+    const issues = [];
+    const issueKeys = /* @__PURE__ */ new Set();
+    const files = [];
+    for (const file of unit.files) {
+      const parsed = await parseJsonl(file);
+      for (const issue of parsed.issues) {
+        addIssue(issues, issueKeys, issue, `${issue.sourcePath}\0${issue.sourceLine}\0${issue.code}`);
+      }
+      if (parsed.corrupt || parsed.validLines === 0 && parsed.invalidLines > 0) {
+        files.push({ path: file.path, status: "corrupt" });
+        continue;
+      }
+      let project = null;
+      let recognized = false;
+      let filePartial = parsed.invalidLines > 0;
+      const canonicalMessages = /* @__PURE__ */ new Set();
+      const deferredEvents = [];
+      for (const record of parsed.records) {
+        const type = stringField(record.value, "type");
+        const payload = asObject(record.value.payload);
+        const recordTimestamp = timestamp(record.value.timestamp);
+        project = stringField(record.value, "cwd") ?? project;
+        if (type === "session_meta") {
+          recognized = true;
+          project = stringField(payload, "cwd") ?? project;
+          const embeddedId = stringField(payload, "id");
+          if (embeddedId !== null && embeddedId !== unit.id) {
+            filePartial = true;
+            addIssue(issues, issueKeys, {
+              sourcePath: file.path,
+              sourceLine: record.line,
+              code: "identity-mismatch",
+              detail: `session id ${embeddedId} does not match archive unit ${unit.id}`
+            });
+          }
+          continue;
+        }
+        if (type === "turn_context") {
+          recognized = true;
+          project = stringField(payload, "cwd") ?? project;
+          continue;
+        }
+        if (type === "response_item") {
+          recognized = true;
+          const itemType = stringField(payload, "type");
+          if (itemType === "message") {
+            const rawRole = stringField(payload, "role");
+            const role = rawRole === "user" ? "user" : rawRole === "assistant" ? "assistant" : null;
+            if (role !== null) {
+              for (const text of textContent(payload?.content)) {
+                canonicalMessages.add(`${role}\0${text}\0${recordTimestamp ?? ""}`);
+                pushUniqueTurn(turns, turnKeys, {
+                  timestamp: recordTimestamp,
+                  project,
+                  role,
+                  text,
+                  filesTouched: [],
+                  commands: [],
+                  sourcePath: file.path,
+                  sourceLine: record.line
+                });
+              }
+            }
+          } else if (itemType === "function_call" || itemType === "custom_tool_call") {
+            const name = stringField(payload, "name");
+            const input = structuredInput(payload?.arguments ?? payload?.input);
+            pushUniqueTurn(turns, turnKeys, {
+              timestamp: recordTimestamp,
+              project,
+              role: "tool",
+              text: name ?? "tool call",
+              filesTouched: explicitPaths(input),
+              commands: shellCommands(name, input),
+              sourcePath: file.path,
+              sourceLine: record.line
+            });
+          } else if (itemType === "function_call_output" || itemType === "custom_tool_call_output") {
+            for (const text of textContent(payload?.output)) {
+              pushUniqueTurn(turns, turnKeys, {
+                timestamp: recordTimestamp,
+                project,
+                role: "tool",
+                text,
+                filesTouched: [],
+                commands: [],
+                sourcePath: file.path,
+                sourceLine: record.line
+              });
+            }
+          } else if (!["reasoning", "tool_search_call", "tool_search_output", "agent_message"].includes(itemType ?? "")) {
+            filePartial = true;
+            addIssue(issues, issueKeys, {
+              sourcePath: file.path,
+              sourceLine: record.line,
+              code: "unknown-content",
+              detail: `skipped response item type ${itemType ?? "<missing>"}`
+            });
+          }
+          continue;
+        }
+        if (type === "event_msg") {
+          recognized = true;
+          const event = payload === null ? null : eventText(payload);
+          if (event !== null && event.text !== "") {
+            deferredEvents.push({
+              timestamp: recordTimestamp,
+              project,
+              role: event.role,
+              text: event.text,
+              filesTouched: [],
+              commands: [],
+              sourcePath: file.path,
+              sourceLine: record.line
+            });
+          }
+          continue;
+        }
+        if (type === "compacted") {
+          recognized = true;
+          const text = stringField(payload, "message");
+          if (text !== null) {
+            pushUniqueTurn(turns, turnKeys, {
+              timestamp: recordTimestamp,
+              project,
+              role: "summary",
+              text,
+              filesTouched: [],
+              commands: [],
+              sourcePath: file.path,
+              sourceLine: record.line
+            });
+          }
+          continue;
+        }
+        if (type === "world_state" || type === "inter_agent_communication_metadata") {
+          recognized = true;
+          continue;
+        }
+        filePartial = true;
+        addIssue(issues, issueKeys, {
+          sourcePath: file.path,
+          sourceLine: record.line,
+          code: "unknown-record",
+          detail: `skipped record type ${type ?? "<missing>"}`
+        });
+      }
+      for (const event of deferredEvents) {
+        if (!canonicalMessages.has(`${event.role}\0${event.text}\0${event.timestamp ?? ""}`)) {
+          pushUniqueTurn(turns, turnKeys, event);
+        }
+      }
+      files.push({ path: file.path, status: recognized ? filePartial ? "partial" : "ok" : "unsupported" });
+      if (!recognized) {
+        addIssue(issues, issueKeys, {
+          sourcePath: file.path,
+          sourceLine: null,
+          code: "unsupported-structure",
+          detail: "no recognized Codex session records"
+        });
+      }
+    }
+    return { turns: finishTurns(turns), issues, files };
+  }
+};
+
+// src/readers/pi.ts
+var KNOWN_METADATA2 = /* @__PURE__ */ new Set(["model_change", "thinking_level_change", "session_info", "label"]);
+var piReader = {
+  harness: "pi",
+  version: 1,
+  async read(unit) {
+    const turns = [];
+    const turnKeys = /* @__PURE__ */ new Set();
+    const issues = [];
+    const issueKeys = /* @__PURE__ */ new Set();
+    const files = [];
+    for (const file of unit.files) {
+      const parsed = await parseJsonl(file);
+      for (const issue of parsed.issues) {
+        addIssue(issues, issueKeys, issue, `${issue.sourcePath}\0${issue.sourceLine}\0${issue.code}`);
+      }
+      if (parsed.corrupt || parsed.validLines === 0 && parsed.invalidLines > 0) {
+        files.push({ path: file.path, status: "corrupt" });
+        continue;
+      }
+      let project = null;
+      let recognizedHeader = false;
+      let supportedVersion = false;
+      let filePartial = parsed.invalidLines > 0;
+      for (const record of parsed.records) {
+        const type = stringField(record.value, "type");
+        const recordTimestamp = timestamp(record.value.timestamp);
+        project = stringField(record.value, "cwd") ?? project;
+        if (type === "session") {
+          recognizedHeader = true;
+          const version2 = record.value.version;
+          supportedVersion = version2 === 1 || version2 === 2 || version2 === 3;
+          project = stringField(record.value, "cwd") ?? project;
+          if (!supportedVersion) {
+            filePartial = true;
+            addIssue(issues, issueKeys, {
+              sourcePath: file.path,
+              sourceLine: record.line,
+              code: "unsupported-version",
+              detail: `unsupported pi session version ${String(version2)}`
+            });
+          }
+          continue;
+        }
+        if (!supportedVersion) {
+          continue;
+        }
+        if (type === "message") {
+          const message = asObject(record.value.message);
+          const role = stringField(message, "role");
+          const details = asObject(record.value.details) ?? asObject(message?.details);
+          const filesTouched = [...stringArray(details?.readFiles), ...stringArray(details?.modifiedFiles)];
+          if (role === "user" || role === "assistant" || role === "toolResult") {
+            for (const text of textContent(message?.content)) {
+              pushUniqueTurn(turns, turnKeys, {
+                timestamp: recordTimestamp,
+                project,
+                role: role === "toolResult" ? "tool" : role,
+                text,
+                filesTouched: [...new Set(filesTouched)],
+                commands: [],
+                sourcePath: file.path,
+                sourceLine: record.line
+              });
+            }
+            if (role === "assistant" && Array.isArray(message?.content)) {
+              for (const rawBlock of message.content) {
+                const block = asObject(rawBlock);
+                if (block?.type !== "toolCall") {
+                  continue;
+                }
+                const name = stringField(block, "name");
+                const input = asObject(block.arguments) ?? asObject(block.input);
+                pushUniqueTurn(turns, turnKeys, {
+                  timestamp: recordTimestamp,
+                  project,
+                  role: "tool",
+                  text: name ?? "tool call",
+                  filesTouched: [.../* @__PURE__ */ new Set([...filesTouched, ...explicitPaths(input)])],
+                  commands: shellCommands(name, input),
+                  sourcePath: file.path,
+                  sourceLine: record.line
+                });
+              }
+            }
+          } else if (role === "bashExecution") {
+            const command = stringField(message, "command");
+            const output = stringField(message, "output");
+            pushUniqueTurn(turns, turnKeys, {
+              timestamp: recordTimestamp,
+              project,
+              role: "tool",
+              text: output === null || output === "" ? command ?? "bash execution" : output,
+              filesTouched: [...new Set(filesTouched)],
+              commands: command === null ? [] : [command],
+              sourcePath: file.path,
+              sourceLine: record.line
+            });
+          } else {
+            filePartial = true;
+            addIssue(issues, issueKeys, {
+              sourcePath: file.path,
+              sourceLine: record.line,
+              code: "unknown-content",
+              detail: `skipped pi message role ${role ?? "<missing>"}`
+            });
+          }
+          continue;
+        }
+        if (type === "compaction" || type === "branch_summary") {
+          const text = stringField(record.value, "summary") ?? stringField(record.value, "content");
+          const details = asObject(record.value.details);
+          const filesTouched = [...stringArray(details?.readFiles), ...stringArray(details?.modifiedFiles)];
+          if (text !== null) {
+            pushUniqueTurn(turns, turnKeys, {
+              timestamp: recordTimestamp,
+              project,
+              role: "summary",
+              text,
+              filesTouched: [...new Set(filesTouched)],
+              commands: [],
+              sourcePath: file.path,
+              sourceLine: record.line
+            });
+          }
+          continue;
+        }
+        if (type !== null && KNOWN_METADATA2.has(type)) {
+          continue;
+        }
+        filePartial = true;
+        addIssue(issues, issueKeys, {
+          sourcePath: file.path,
+          sourceLine: record.line,
+          code: "unknown-record",
+          detail: `skipped record type ${type ?? "<missing>"}`
+        });
+      }
+      const status = !recognizedHeader || !supportedVersion ? "unsupported" : filePartial ? "partial" : "ok";
+      files.push({ path: file.path, status });
+      if (!recognizedHeader) {
+        addIssue(issues, issueKeys, {
+          sourcePath: file.path,
+          sourceLine: null,
+          code: "unsupported-structure",
+          detail: "no recognizable pi session header"
+        });
+      }
+    }
+    return { turns: finishTurns(turns), issues, files };
+  }
+};
+
+// src/readers/registry.ts
+var readers = [claudeCodeReader, codexReader, piReader];
+var byHarness = new Map(readers.map((reader) => [reader.harness, reader]));
+function getReader(harness) {
+  return byHarness.get(harness);
+}
+
+// src/retrieval/catalog.ts
+import { createHash as createHash2 } from "crypto";
+import { createReadStream as createReadStream2 } from "fs";
+import { stat as stat2 } from "fs/promises";
+import { join as join3, relative as relative2, sep as sep2 } from "path";
+var snapshotHarnesses = new Set(
+  adapters.filter((adapter) => adapter.mutationModel === "db-snapshot").map((adapter) => adapter.id)
+);
+var UUID_PATTERN = new RegExp(`^${UUID_SOURCE}$`, "i");
+var UUID_IN_FILENAME_PATTERN = new RegExp(`(${UUID_SOURCE})(?:\\.jsonl)?\\.zst$`, "i");
+function portable(path) {
+  return sep2 === "/" ? path : path.split(sep2).join("/");
+}
+async function walkZstd(root, directory = root) {
+  const paths = [];
+  for (const entry of (await readDirectoryOrEmpty(directory)).sort((a, b) => a.name.localeCompare(b.name))) {
+    const path = join3(directory, entry.name);
+    if (entry.isDirectory()) {
+      paths.push(...await walkZstd(root, path));
+    } else if (entry.isFile() && entry.name.endsWith(".zst")) {
+      paths.push(portable(relative2(root, path)));
+    }
+  }
+  return paths;
+}
+function inferUnit(harness, harnessPath) {
+  const parts = harnessPath.split("/");
+  if (harness === "claude-code") {
+    const directoryId = parts.find((part) => UUID_PATTERN.test(part));
+    if (directoryId !== void 0) {
+      return { id: directoryId, role: "sidecar" };
+    }
+    const match2 = UUID_IN_FILENAME_PATTERN.exec(parts.at(-1) ?? "");
+    return match2?.[1] === void 0 ? null : { id: match2[1], role: "main" };
+  }
+  const match = UUID_IN_FILENAME_PATTERN.exec(parts.at(-1) ?? "");
+  return match?.[1] === void 0 ? null : { id: match[1], role: "main" };
+}
+function indexedFile(archiveRoot, machine, record, storedSize, storedMtimeMs) {
+  const machinePath = portable(record.path);
+  return {
+    path: `${machine}/${machinePath}`,
+    archivePath: join3(archiveRoot, machine, ...machinePath.split("/")),
+    machine,
+    harness: record.harness,
+    unit: record.unit,
+    role: record.role,
+    storedSize,
+    storedMtimeMs,
+    archiveSha256: record.sha256
+  };
+}
+function rawFile(archiveRoot, machine, machinePath, storedSize, storedMtimeMs) {
+  const [harnessValue, ...rest] = machinePath.split("/");
+  if (!isHarnessId(harnessValue) || snapshotHarnesses.has(harnessValue) || rest.length === 0) {
+    return null;
+  }
+  const inferred = inferUnit(harnessValue, rest.join("/"));
+  if (inferred === null) {
+    return null;
+  }
+  return {
+    path: `${machine}/${machinePath}`,
+    archivePath: join3(archiveRoot, machine, ...machinePath.split("/")),
+    machine,
+    harness: harnessValue,
+    unit: inferred.id,
+    role: inferred.role,
+    storedSize,
+    storedMtimeMs,
+    archiveSha256: null
+  };
+}
+async function sha256(path) {
+  const hash = createHash2("sha256");
+  for await (const chunk of createReadStream2(path)) {
+    hash.update(chunk);
+  }
+  return hash.digest("hex");
+}
+async function readArchiveCatalog(config, options = {}) {
+  const files = /* @__PURE__ */ new Map();
+  for (const machineEntry of (await readDirectoryOrEmpty(config.archiveRoot)).sort(
+    (a, b) => a.name.localeCompare(b.name)
+  )) {
+    if (!machineEntry.isDirectory()) {
+      continue;
+    }
+    const machine = machineEntry.name;
+    const machineRoot = join3(config.archiveRoot, machine);
+    const index = await readIndex(join3(machineRoot, "index.jsonl"));
+    const rawPaths = await walkZstd(machineRoot);
+    const rawStats = /* @__PURE__ */ new Map();
+    for (const machinePath of rawPaths) {
+      const stored = await stat2(join3(machineRoot, ...machinePath.split("/")));
+      rawStats.set(machinePath, { size: stored.size, mtimeMs: stored.mtimeMs });
+    }
+    for (const record of index.records.values()) {
+      if (record.machine !== machine || record.role === "database" || snapshotHarnesses.has(record.harness)) {
+        continue;
+      }
+      const machinePath = portable(record.path);
+      const stored = rawStats.get(machinePath);
+      if (stored !== void 0) {
+        const file = indexedFile(config.archiveRoot, machine, record, stored.size, stored.mtimeMs);
+        files.set(file.path, file);
+      }
+    }
+    for (const machinePath of rawPaths) {
+      const path = `${machine}/${machinePath}`;
+      if (files.has(path)) {
+        continue;
+      }
+      const stored = rawStats.get(machinePath);
+      const file = rawFile(config.archiveRoot, machine, machinePath, stored.size, stored.mtimeMs);
+      if (file !== null) {
+        files.set(file.path, file);
+      }
+    }
+  }
+  const units = /* @__PURE__ */ new Map();
+  for (const file of files.values()) {
+    const key = `${file.machine}/${file.harness}/${file.unit}`;
+    const current = units.get(key);
+    if (current === void 0) {
+      units.set(key, { key, machine: file.machine, harness: file.harness, id: file.unit, files: [file] });
+    } else {
+      current.files.push(file);
+    }
+  }
+  for (const unit of units.values()) {
+    unit.files.sort((a, b) => a.role === b.role ? a.path.localeCompare(b.path) : a.role === "main" ? -1 : 1);
+    if (options.hashFiles) {
+      for (const file of unit.files) {
+        file.archiveSha256 = await sha256(file.archivePath);
+      }
+    }
+  }
+  return [...units.values()].sort((a, b) => a.key.localeCompare(b.key));
+}
+
+// src/retrieval/database.ts
+var SCHEMA_VERSION = 1;
+function newDatabase(path) {
+  const sqlite = createRequire(import.meta.url)("node:sqlite");
+  return new sqlite.DatabaseSync(path);
+}
+var SCHEMA = `
+PRAGMA user_version = 1;
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE archive_files (
+  path              TEXT PRIMARY KEY,
+  machine           TEXT NOT NULL,
+  harness           TEXT NOT NULL,
+  unit              TEXT NOT NULL,
+  role              TEXT NOT NULL CHECK (role IN ('main', 'sidecar')),
+  stored_size       INTEGER NOT NULL,
+  stored_mtime_ms   REAL NOT NULL,
+  archive_sha256    TEXT,
+  reader_version    INTEGER NOT NULL,
+  parse_status      TEXT NOT NULL CHECK (parse_status IN ('ok', 'partial', 'unsupported', 'corrupt')),
+  indexed_at        TEXT NOT NULL
+) STRICT;
+
+CREATE TABLE units (
+  key               TEXT PRIMARY KEY,
+  machine           TEXT NOT NULL,
+  harness           TEXT NOT NULL,
+  id                TEXT NOT NULL,
+  started_at        TEXT,
+  updated_at        TEXT,
+  UNIQUE (machine, harness, id)
+) STRICT;
+
+CREATE TABLE turns (
+  id                INTEGER PRIMARY KEY,
+  unit              TEXT NOT NULL REFERENCES units(key) ON DELETE CASCADE,
+  turn              INTEGER NOT NULL,
+  source_path       TEXT NOT NULL REFERENCES archive_files(path) ON DELETE CASCADE,
+  source_line       INTEGER NOT NULL,
+  timestamp         TEXT,
+  project           TEXT,
+  role              TEXT NOT NULL CHECK (role IN ('user', 'assistant', 'tool', 'summary')),
+  text              TEXT NOT NULL,
+  files_touched     TEXT NOT NULL,
+  commands          TEXT NOT NULL,
+  UNIQUE (unit, turn)
+) STRICT;
+
+CREATE TABLE parse_issues (
+  id                INTEGER PRIMARY KEY,
+  source_path       TEXT NOT NULL REFERENCES archive_files(path) ON DELETE CASCADE,
+  source_line       INTEGER,
+  code              TEXT NOT NULL,
+  detail            TEXT NOT NULL
+) STRICT;
+
+CREATE INDEX turns_filter
+  ON turns (project, timestamp, unit, turn);
+
+CREATE INDEX units_filter
+  ON units (harness, machine, id);
+
+CREATE VIRTUAL TABLE turns_fts USING fts5(
+  unit UNINDEXED,
+  turn UNINDEXED,
+  role,
+  text,
+  files_touched,
+  commands,
+  content = 'turns',
+  content_rowid = 'id',
+  tokenize = 'unicode61 remove_diacritics 2'
+);
+
+CREATE TRIGGER turns_ai AFTER INSERT ON turns BEGIN
+  INSERT INTO turns_fts(rowid, unit, turn, role, text, files_touched, commands)
+  VALUES (new.id, new.unit, new.turn, new.role, new.text, new.files_touched, new.commands);
+END;
+
+CREATE TRIGGER turns_ad AFTER DELETE ON turns BEGIN
+  INSERT INTO turns_fts(turns_fts, rowid, unit, turn, role, text, files_touched, commands)
+  VALUES ('delete', old.id, old.unit, old.turn, old.role, old.text, old.files_touched, old.commands);
+END;
+
+CREATE TRIGGER turns_au AFTER UPDATE ON turns BEGIN
+  INSERT INTO turns_fts(turns_fts, rowid, unit, turn, role, text, files_touched, commands)
+  VALUES ('delete', old.id, old.unit, old.turn, old.role, old.text, old.files_touched, old.commands);
+  INSERT INTO turns_fts(rowid, unit, turn, role, text, files_touched, commands)
+  VALUES (new.id, new.unit, new.turn, new.role, new.text, new.files_touched, new.commands);
+END;
+`;
+function retrievalDatabasePath(home) {
+  return join4(home.cachePath, "retrieval.sqlite");
+}
+function assertFts5() {
+  const database = newDatabase(":memory:");
+  try {
+    const options = database.prepare("PRAGMA compile_options").all();
+    if (!options.some((row) => Object.values(row).includes("ENABLE_FTS5"))) {
+      throw new PackbatError(
+        "retrieval requires SQLite FTS5; use the official Node >=22.16 build or a Node build compiled with ENABLE_FTS5"
+      );
+    }
+  } finally {
+    database.close();
+  }
+}
+async function prepareDirectory(path) {
+  await mkdir3(dirname3(path), { recursive: true, mode: 448 });
+  await chmod(dirname3(path), 448);
+}
+function initialize(path) {
+  const database = newDatabase(path);
+  database.exec(SCHEMA);
+  return database;
+}
+async function createFreshAt(path) {
+  await prepareDirectory(path);
+  const database = initialize(path);
+  await chmod(path, 384);
+  return database;
+}
+async function openCurrent(path) {
+  try {
+    await stat3(path);
+  } catch (error) {
+    if (isEnoent(error)) {
+      return null;
+    }
+    throw error;
+  }
+  const database = newDatabase(path);
+  try {
+    const version2 = database.prepare("PRAGMA user_version").get().user_version;
+    if (version2 !== SCHEMA_VERSION) {
+      database.close();
+      return null;
+    }
+    database.exec("PRAGMA foreign_keys = ON");
+    return database;
+  } catch {
+    database.close();
+    return null;
+  }
+}
+function timestampBounds(turns) {
+  const values = turns.flatMap((turn) => turn.timestamp === null ? [] : [turn.timestamp]).sort();
+  return { startedAt: values[0] ?? null, updatedAt: values.at(-1) ?? null };
+}
+async function replaceUnitAsync(database, unit) {
+  const reader = getReader(unit.harness);
+  const result = await reader.read(unit);
+  const statuses = new Map(result.files.map((file) => [file.path, file.status]));
+  const bounds = timestampBounds(result.turns);
+  const indexedAt = (/* @__PURE__ */ new Date()).toISOString();
+  database.exec("BEGIN IMMEDIATE");
+  try {
+    database.prepare("DELETE FROM units WHERE key = ?").run(unit.key);
+    database.prepare("DELETE FROM archive_files WHERE machine = ? AND harness = ? AND unit = ?").run(unit.machine, unit.harness, unit.id);
+    const insertFile = database.prepare(`
+			INSERT INTO archive_files (
+				path, machine, harness, unit, role, stored_size, stored_mtime_ms, archive_sha256,
+				reader_version, parse_status, indexed_at
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+		`);
+    for (const file of unit.files) {
+      insertFile.run(
+        file.path,
+        file.machine,
+        file.harness,
+        file.unit,
+        file.role,
+        file.storedSize,
+        file.storedMtimeMs,
+        file.archiveSha256,
+        reader.version,
+        statuses.get(file.path) ?? "corrupt",
+        indexedAt
+      );
+    }
+    database.prepare("INSERT INTO units (key, machine, harness, id, started_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)").run(unit.key, unit.machine, unit.harness, unit.id, bounds.startedAt, bounds.updatedAt);
+    const insertTurn = database.prepare(`
+			INSERT INTO turns (
+				unit, turn, source_path, source_line, timestamp, project, role, text, files_touched, commands
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+		`);
+    for (const turn of result.turns) {
+      insertTurn.run(
+        unit.key,
+        turn.turn,
+        turn.sourcePath,
+        turn.sourceLine,
+        turn.timestamp,
+        turn.project,
+        turn.role,
+        turn.text,
+        JSON.stringify(turn.filesTouched),
+        JSON.stringify(turn.commands)
+      );
+    }
+    const insertIssue = database.prepare(
+      "INSERT INTO parse_issues (source_path, source_line, code, detail) VALUES (?, ?, ?, ?)"
+    );
+    for (const issue of result.issues) {
+      if (statuses.has(issue.sourcePath)) {
+        insertIssue.run(issue.sourcePath, issue.sourceLine, issue.code, issue.detail);
+      }
+    }
+    database.exec("COMMIT");
+  } catch (error) {
+    database.exec("ROLLBACK");
+    throw error;
+  }
+}
+function cachedFiles(database) {
+  return database.prepare(
+    "SELECT path, machine, harness, unit, role, stored_size, stored_mtime_ms, archive_sha256, reader_version FROM archive_files"
+  ).all();
+}
+function isChanged(file, cached) {
+  return cached === void 0 || cached.machine !== file.machine || cached.harness !== file.harness || cached.unit !== file.unit || cached.role !== file.role || cached.stored_size !== file.storedSize || cached.stored_mtime_ms !== file.storedMtimeMs || cached.archive_sha256 !== file.archiveSha256 || cached.reader_version !== getReader(file.harness).version;
+}
+async function refresh(database, config, hashFiles = false) {
+  const units = await readArchiveCatalog(config, { hashFiles });
+  const byKey = new Map(units.map((unit) => [unit.key, unit]));
+  const currentFiles = new Map(units.flatMap((unit) => unit.files.map((file) => [file.path, file])));
+  const cached = cachedFiles(database);
+  const cachedByPath = new Map(cached.map((file) => [file.path, file]));
+  const changedKeys = /* @__PURE__ */ new Set();
+  for (const unit of units) {
+    if (unit.files.some((file) => isChanged(file, cachedByPath.get(file.path)))) {
+      changedKeys.add(unit.key);
+    }
+  }
+  for (const old of cached) {
+    if (!currentFiles.has(old.path)) {
+      changedKeys.add(`${old.machine}/${old.harness}/${old.unit}`);
+    }
+  }
+  for (const key of [...changedKeys].sort()) {
+    const unit = byKey.get(key);
+    if (unit !== void 0) {
+      await replaceUnitAsync(database, unit);
+    } else {
+      database.exec("BEGIN IMMEDIATE");
+      try {
+        database.prepare("DELETE FROM units WHERE key = ?").run(key);
+        const [machine, harness, ...idParts] = key.split("/");
+        database.prepare("DELETE FROM archive_files WHERE machine = ? AND harness = ? AND unit = ?").run(machine, harness, idParts.join("/"));
+        database.exec("COMMIT");
+      } catch (error) {
+        database.exec("ROLLBACK");
+        throw error;
+      }
+    }
+  }
+}
+function warnings(database) {
+  const rows = database.prepare(`
+			SELECT p.code, u.key AS unit, p.source_path AS source, p.source_line AS line, p.detail,
+				f.harness, f.reader_version AS readerVersion
+			FROM parse_issues p
+			JOIN archive_files f ON f.path = p.source_path
+			JOIN units u ON u.machine = f.machine AND u.harness = f.harness AND u.id = f.unit
+			ORDER BY u.key, p.source_path, p.source_line, p.id
+		`).all();
+  const unknowns = /* @__PURE__ */ new Set();
+  return rows.flatMap((row) => {
+    if (row.code === "unknown-record") {
+      const key = `${row.harness}\0${row.readerVersion}\0${row.detail}`;
+      if (unknowns.has(key)) return [];
+      unknowns.add(key);
+    }
+    return [{ code: row.code, unit: row.unit, source: row.source, line: row.line, detail: row.detail }];
+  });
+}
+async function buildFresh(path, config) {
+  const database = await createFreshAt(path);
+  try {
+    await refresh(database, config, true);
+    return database;
+  } catch (error) {
+    database.close();
+    throw error;
+  }
+}
+async function openAndRefresh(home, config) {
+  const path = retrievalDatabasePath(home);
+  await prepareDirectory(path);
+  let database = await openCurrent(path);
+  if (database === null) {
+    const report = await rebuildRetrieval(home, config);
+    void report;
+    database = newDatabase(path);
+    database.exec("PRAGMA foreign_keys = ON");
+    return database;
+  }
+  await refresh(database, config);
+  return database;
+}
+async function rebuildRetrieval(home, config) {
+  const started = performance.now();
+  const target = retrievalDatabasePath(home);
+  await prepareDirectory(target);
+  const temporary = join4(dirname3(target), `.${basename2(target)}.tmp-${process.pid}-${randomUUID2()}`);
+  let database = null;
+  try {
+    database = await buildFresh(temporary, config);
+    const counts = database.prepare(
+      "SELECT (SELECT count(*) FROM archive_files) AS files, (SELECT count(*) FROM units) AS units, (SELECT count(*) FROM turns) AS turns"
+    ).get();
+    const foundWarnings = warnings(database);
+    database.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+    database.close();
+    database = null;
+    await chmod(temporary, 384);
+    await rename2(temporary, target);
+    const bytes = (await stat3(target)).size;
+    return {
+      rebuilt: true,
+      files: counts.files,
+      units: counts.units,
+      turns: counts.turns,
+      bytes,
+      elapsedMs: Math.round(performance.now() - started),
+      warnings: foundWarnings
+    };
+  } catch (error) {
+    database?.close();
+    await rm3(temporary, { force: true });
+    throw error;
+  }
+}
+function queryTerms(query) {
+  return [...query.matchAll(/[\p{L}\p{N}_-]+/gu)].map((match) => match[0]).filter((term) => !["AND", "OR", "NOT", "NEAR", "role", "text", "files_touched", "commands"].includes(term));
+}
+function snippet(text, query) {
+  const points = Array.from(text);
+  if (points.length <= 320) {
+    return text;
+  }
+  const lower = text.toLocaleLowerCase();
+  const match = queryTerms(query).map((term) => lower.indexOf(term.toLocaleLowerCase())).find((index) => index >= 0);
+  if (match === void 0) {
+    return `${points.slice(0, 319).join("")}\u2026`;
+  }
+  const pointIndex = Array.from(text.slice(0, match)).length;
+  let start = Math.max(0, pointIndex - 159);
+  let end = Math.min(points.length, start + 320);
+  start = Math.max(0, end - 320);
+  const leading = start > 0;
+  const trailing = end < points.length;
+  const budget = 320 - (leading ? 1 : 0) - (trailing ? 1 : 0);
+  end = Math.min(points.length, start + budget);
+  return `${leading ? "\u2026" : ""}${points.slice(start, end).join("")}${end < points.length ? "\u2026" : ""}`;
+}
+function searchDatabase(database, query, filters) {
+  const conditions = ["turns_fts MATCH ?"];
+  const parameters = [query];
+  if (filters.harness !== null) {
+    conditions.push("u.harness = ?");
+    parameters.push(filters.harness);
+  }
+  if (filters.machine !== null) {
+    conditions.push("u.machine = ?");
+    parameters.push(filters.machine);
+  }
+  if (filters.project !== null) {
+    conditions.push("t.project = ?");
+    parameters.push(filters.project);
+  }
+  if (filters.since !== null) {
+    conditions.push("t.timestamp IS NOT NULL AND t.timestamp >= ?");
+    parameters.push(filters.since);
+  }
+  let rows;
+  try {
+    rows = database.prepare(`
+				SELECT u.key, u.id AS unit, u.harness, u.machine, t.project, t.turn, t.timestamp,
+					t.role, t.text, t.files_touched, t.commands
+				FROM turns_fts
+				JOIN turns t ON t.id = turns_fts.rowid
+				JOIN units u ON u.key = t.unit
+				WHERE ${conditions.join(" AND ")}
+				ORDER BY bm25(turns_fts), t.timestamp DESC, u.key ASC, t.turn ASC
+				LIMIT 51
+			`).all(...parameters);
+  } catch (error) {
+    throw new PackbatError(`invalid search query: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const truncated = rows.length > 50;
+  return {
+    results: rows.slice(0, 50).map((row) => ({
+      key: row.key,
+      unit: row.unit,
+      harness: row.harness,
+      machine: row.machine,
+      project: row.project,
+      turn: row.turn,
+      timestamp: row.timestamp,
+      role: row.role,
+      snippet: snippet(row.text, query),
+      filesTouched: JSON.parse(row.files_touched),
+      commands: JSON.parse(row.commands)
+    })),
+    truncated,
+    warnings: warnings(database)
+  };
+}
+function closeDatabase(database) {
+  database.close();
+}
+
+// src/commands/search.ts
+var USAGE3 = `Usage: packbat search <query> [--harness <id>] [--machine <name>] [--project <path>] [--since <RFC3339>] [--json]
+       packbat search --rebuild [--json]
+`;
+function usageError3(message) {
+  process.stderr.write(`packbat search: ${message}
+
+${USAGE3}`);
+  return null;
+}
+function optionValue(argv, index, option) {
+  const value = argv[index + 1];
+  if (value === void 0 || value.startsWith("--")) {
+    usageError3(`${option} requires a value`);
+    return null;
+  }
+  return value;
+}
+function parseSince(value) {
+  const date = /^(\d{4})-(\d{2})-(\d{2})/.exec(value);
+  if (date === null) return null;
+  const year = Number(date[1]);
+  const month = Number(date[2]);
+  const day = Number(date[3]);
+  if (month < 1 || month > 12 || day < 1 || day > new Date(Date.UTC(year, month, 0)).getUTCDate()) return null;
+  if (/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+    const parsed2 = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
+    return Number.isNaN(parsed2.getTime()) ? null : parsed2.toISOString();
+  }
+  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(value)) {
+    return null;
+  }
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? null : parsed.toISOString();
+}
+function parseOptions3(argv) {
+  const options = {
+    query: null,
+    harness: null,
+    machine: null,
+    project: null,
+    since: null,
+    json: false,
+    rebuild: false
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === "--json") {
+      if (options.json) return usageError3("--json may only be passed once");
+      options.json = true;
+    } else if (argument === "--rebuild") {
+      if (options.rebuild) return usageError3("--rebuild may only be passed once");
+      options.rebuild = true;
+    } else if (argument === "--harness") {
+      if (options.harness !== null) return usageError3("--harness may only be passed once");
+      const value = optionValue(argv, index, argument);
+      if (value === null) return null;
+      if (!isHarnessId(value)) return usageError3(`--harness must be one of ${HARNESS_IDS.join(", ")}`);
+      options.harness = value;
+      index += 1;
+    } else if (argument === "--machine") {
+      if (options.machine !== null) return usageError3("--machine may only be passed once");
+      const value = optionValue(argv, index, argument);
+      if (value === null) return null;
+      options.machine = value;
+      index += 1;
+    } else if (argument === "--project") {
+      if (options.project !== null) return usageError3("--project may only be passed once");
+      const value = optionValue(argv, index, argument);
+      if (value === null) return null;
+      options.project = resolve2(value);
+      index += 1;
+    } else if (argument === "--since") {
+      if (options.since !== null) return usageError3("--since may only be passed once");
+      const value = optionValue(argv, index, argument);
+      if (value === null) return null;
+      const since = parseSince(value);
+      if (since === null) return usageError3("--since must be RFC3339 or YYYY-MM-DD");
+      options.since = since;
+      index += 1;
+    } else if (argument.startsWith("-")) {
+      return usageError3(`unknown option ${argument}`);
+    } else if (options.query !== null) {
+      return usageError3("only one query may be passed");
+    } else {
+      options.query = argument;
+    }
+  }
+  if (options.rebuild) {
+    if (options.query !== null || options.harness !== null || options.machine !== null || options.project !== null || options.since !== null) {
+      return usageError3("--rebuild only accepts --json");
+    }
+  } else if (options.query === null) {
+    return usageError3("a query is required");
+  }
+  return options;
+}
+function printHit(hit) {
+  process.stdout.write(`${hit.key} \xB7 turn ${hit.turn} \xB7 ${hit.role}`);
+  if (hit.timestamp !== null) process.stdout.write(` \xB7 ${hit.timestamp}`);
+  process.stdout.write("\n");
+  if (hit.project !== null) process.stdout.write(`${hit.project}
+`);
+  process.stdout.write(`${hit.snippet}
+`);
+  if (hit.filesTouched.length > 0) process.stdout.write(`files: ${hit.filesTouched.join(", ")}
+`);
+  if (hit.commands.length > 0) process.stdout.write(`commands: ${hit.commands.join(" | ")}
+`);
+  process.stdout.write("\n");
+}
+async function runSearch(argv) {
+  const options = parseOptions3(argv);
+  if (options === null) return 1;
+  assertFts5();
+  const home = resolveHome();
+  const config = loadConfig(home);
+  const locked = await withRetrievalLock(home.statePath, async () => {
+    if (options.rebuild) {
+      const report = await rebuildRetrieval(home, config);
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify({ v: 1, ...report })}
+`);
+      } else {
+        process.stdout.write(
+          `rebuilt ${report.files} files, ${report.units} units, ${report.turns} turns \xB7 ${report.bytes} bytes \xB7 ${report.elapsedMs} ms
+`
+        );
+      }
+      return 0;
+    }
+    const database = await openAndRefresh(home, config);
+    try {
+      const filters = {
+        harness: options.harness,
+        machine: options.machine,
+        project: options.project,
+        since: options.since
+      };
+      const result = searchDatabase(database, options.query, filters);
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify({ v: 1, query: options.query, filters, ...result })}
+`);
+      } else {
+        for (const hit of result.results) printHit(hit);
+      }
+      return 0;
+    } finally {
+      closeDatabase(database);
+    }
+  });
+  if (!locked.acquired) {
+    process.stderr.write("packbat search: retrieval is already running\n");
+    return 1;
+  }
+  return locked.value;
+}
+
+// src/retrieval/show.ts
+function resolveShowUnit(units, value) {
+  const exact = units.find((unit) => unit.key === value);
+  if (exact !== void 0) {
+    return exact;
+  }
+  const matches = units.filter((unit) => unit.id.startsWith(value));
+  if (matches.length === 0) {
+    throw new PackbatError(`no archived unit matches "${value}"`);
+  }
+  if (matches.length > 1) {
+    throw new PackbatError(
+      `archive unit "${value}" is ambiguous:
+${matches.map((unit) => `  ${unit.key}`).join("\n")}`
+    );
+  }
+  return matches[0];
+}
+function assertServeable(unit, result) {
+  const searchablePaths = new Set(
+    unit.files.filter((file) => file.path.endsWith(".jsonl.zst")).map((file) => file.path)
+  );
+  const failed = result.files.filter(
+    (file) => searchablePaths.has(file.path) && (file.status === "unsupported" || file.status === "corrupt")
+  );
+  if (failed.length !== searchablePaths.size) {
+    return;
+  }
+  const lines = failed.map((file) => {
+    const codes = result.issues.filter((issue) => issue.sourcePath === file.path).map((issue) => issue.code).filter((code, index, all) => all.indexOf(code) === index);
+    return `  ${file.path}: ${codes.join(", ") || file.status}`;
+  });
+  throw new PackbatError(`archived unit cannot be read:
+${lines.join("\n")}`);
+}
+async function readShowUnit(unit) {
+  const result = await getReader(unit.harness).read(unit);
+  assertServeable(unit, result);
+  const projects = [...new Set(result.turns.flatMap((turn) => turn.project === null ? [] : [turn.project]))].sort();
+  const timestamps = result.turns.flatMap((turn) => turn.timestamp === null ? [] : [turn.timestamp]).sort((left, right) => left.localeCompare(right));
+  return {
+    v: 1,
+    unit: {
+      key: unit.key,
+      id: unit.id,
+      harness: unit.harness,
+      machine: unit.machine,
+      projects,
+      startedAt: timestamps[0] ?? null,
+      updatedAt: timestamps.at(-1) ?? null
+    },
+    turns: result.turns.map((turn) => ({
+      turn: turn.turn,
+      timestamp: turn.timestamp,
+      project: turn.project,
+      role: turn.role,
+      text: turn.text,
+      filesTouched: turn.filesTouched,
+      commands: turn.commands
+    })),
+    warnings: result.issues.map((issue) => ({
+      code: issue.code,
+      unit: unit.key,
+      source: issue.sourcePath,
+      line: issue.sourceLine,
+      detail: issue.detail
+    }))
+  };
+}
+
+// src/commands/show.ts
+var USAGE4 = "Usage: packbat show <unit-or-key> [--json]\n";
+function parseOptions4(argv) {
+  let value = null;
+  let json = false;
+  for (const argument of argv) {
+    if (argument === "--json") {
+      if (json) {
+        process.stderr.write(`packbat show: --json may only be passed once
+
+${USAGE4}`);
+        return null;
+      }
+      json = true;
+    } else if (argument.startsWith("-")) {
+      process.stderr.write(`packbat show: unknown option ${argument}
+
+${USAGE4}`);
+      return null;
+    } else if (value !== null) {
+      process.stderr.write(`packbat show: only one unit or key may be passed
+
+${USAGE4}`);
+      return null;
+    } else {
+      value = argument;
+    }
+  }
+  if (value === null) {
+    process.stderr.write(`packbat show: a unit or key is required
+
+${USAGE4}`);
+    return null;
+  }
+  return { value, json };
+}
+function printShow(result) {
+  process.stdout.write(`${result.unit.key}
+`);
+  process.stdout.write(`${result.unit.harness} \xB7 ${result.unit.machine}
+`);
+  if (result.unit.projects.length > 0) process.stdout.write(`projects: ${result.unit.projects.join(", ")}
+`);
+  for (const turn of result.turns) {
+    process.stdout.write(`
+${turn.turn} \xB7 ${turn.role}`);
+    if (turn.timestamp !== null) process.stdout.write(` \xB7 ${turn.timestamp}`);
+    if (turn.project !== null) process.stdout.write(` \xB7 ${turn.project}`);
+    process.stdout.write(`
+${turn.text}
+`);
+    if (turn.filesTouched.length > 0) process.stdout.write(`files: ${turn.filesTouched.join(", ")}
+`);
+    if (turn.commands.length > 0) process.stdout.write(`commands: ${turn.commands.join(" | ")}
+`);
+  }
+}
+async function runShow(argv) {
+  const options = parseOptions4(argv);
+  if (options === null) return 1;
+  assertFts5();
+  const home = resolveHome();
+  const config = loadConfig(home);
+  const unit = resolveShowUnit(await readArchiveCatalog(config), options.value);
+  const result = await readShowUnit(unit);
+  if (options.json) process.stdout.write(`${JSON.stringify(result)}
+`);
+  else printShow(result);
+  return 0;
+}
+
+// src/commands/status.ts
+var USAGE5 = "Usage: packbat status [--json]\n";
+function parseOptions5(argv) {
+  if (argv.length === 0) {
+    return { json: false };
+  }
+  if (argv.length === 1 && argv[0] === "--json") {
+    return { json: true };
+  }
+  process.stderr.write(`packbat status: only --json is accepted
+
+${USAGE5}`);
+  return null;
+}
+function stampJson(stamp, now) {
+  if (stamp.kind !== "value") {
+    return null;
+  }
+  return {
+    finishedAt: stamp.value.finishedAt,
+    ageMs: ageMs(stamp.finishedAtMs, now),
+    ok: stamp.value.ok,
+    archived: stamp.value.archived,
+    unchanged: stamp.value.unchanged,
+    failed: stamp.value.failed
+  };
+}
+function lastRunLine(stamp, now) {
+  if (stamp.kind === "missing") {
+    return "never";
+  }
+  if (stamp.kind === "invalid") {
+    return stamp.detail;
+  }
+  return `${formatAge(ageMs(stamp.finishedAtMs, now))} \xB7 ${stamp.value.ok ? "ok" : "failed"} \xB7 archived ${stamp.value.archived}, unchanged ${stamp.value.unchanged}, failed ${stamp.value.failed}`;
+}
+function lastSuccessLine(stamp, now) {
+  if (stamp.kind === "missing") {
+    return "never";
+  }
+  if (stamp.kind === "invalid") {
+    return stamp.detail;
+  }
+  return formatAge(ageMs(stamp.finishedAtMs, now));
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) {
+    return `${bytes} B`;
+  }
+  if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)} KiB`;
+  }
+  return `${(bytes / 1024 / 1024).toFixed(1)} MiB`;
+}
+async function runStatus(argv) {
+  const options = parseOptions5(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, harnesses, offbox] = await Promise.all([
+    checkLive(context, installed, { probe: false }),
+    checkFresh(context),
+    readHarnessTallies(context),
+    checkOffbox(context)
+  ]);
+  const report = {
+    v: 2,
+    machine: config.machine,
+    archiveRoot: config.archiveRoot,
+    schedule: {
+      installed: installed.fact.status === "ok",
+      installedDetail: installed.fact.detail,
+      live: "not-checked",
+      liveDetail: live.detail
+    },
+    lastRun: stampJson(fresh.lastRun, context.now),
+    lastSuccess: stampJson(fresh.lastSuccess, context.now),
+    fresh: { status: fresh.fact.status, detail: fresh.fact.detail },
+    harnesses,
+    offbox: offbox.map((item) => ({ status: item.status, detail: item.detail }))
+  };
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(report)}
+`);
+    return 0;
+  }
+  process.stdout.write(`machine: ${config.machine}
+`);
+  process.stdout.write(`archive: ${config.archiveRoot}
+`);
+  process.stdout.write(`schedule: ${installed.fact.detail} \xB7 ${live.detail}
+`);
+  process.stdout.write(`last run: ${lastRunLine(fresh.lastRun, context.now)}
+`);
+  process.stdout.write(`last success: ${lastSuccessLine(fresh.lastSuccess, context.now)}
+`);
+  for (const tally of harnesses) {
+    process.stdout.write(
+      `${tally.harness}: ${tally.units} unit${tally.units === 1 ? "" : "s"} \xB7 ${tally.files} file${tally.files === 1 ? "" : "s"} \xB7 ${formatBytes(tally.storedBytes)}
+`
+    );
+  }
+  for (const item of offbox) {
+    process.stdout.write(`offbox: ${item.detail}
+`);
+  }
+  return 0;
+}
+
+// src/main.ts
+var HELP = `Packbat \u2014 every agent session, kept.
+
+Usage: packbat <command> [options]
+
+Commands:
+  init      set up archiving: detect harnesses, schedule the sweep, off-box or skip
+  sync      run one sweep now (the scheduled job runs this)
+  doctor    prove the schedule is alive and nothing is being missed
+  restore   put an archived session back where its harness resumes it
+  status    one-screen health summary
+  search    find text across archived sessions
+  show      read one archived session
+
+Options:
+  -h, --help     show this help
+  -v, --version  show version
+
+Run \`packbat <command> --help\` for command options.
+`;
+var commands = {
+  init: runInit,
+  sync: runSync,
+  doctor: runDoctor,
+  restore: runRestore,
+  status: runStatus,
+  search: runSearch,
+  show: runShow
+};
+function version() {
+  const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+  return pkg.version;
+}
+for (const stream of [process.stdout, process.stderr]) {
+  stream.on("error", (error) => {
+    if (error.code === "EPIPE") {
+      process.exit(0);
+    }
+    throw error;
+  });
+}
+async function main(argv) {
+  const [first, ...rest] = argv;
+  if (first === void 0 || first === "--help" || first === "-h") {
+    process.stdout.write(HELP);
+    return first === void 0 ? 1 : 0;
+  }
+  if (first === "--version" || first === "-v") {
+    process.stdout.write(`${version()}
+`);
+    return 0;
+  }
+  const command = commands[first];
+  if (command === void 0) {
+    process.stderr.write(`packbat: unknown command "${first}"
+
+${HELP}`);
+    return 1;
+  }
+  return command(rest);
+}
+main(process.argv.slice(2)).then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (error) => {
+    if (error instanceof PackbatError) {
+      process.stderr.write(`packbat: ${error.message}
+`);
+    } else {
+      process.stderr.write(
+        `packbat: unexpected error
+${error instanceof Error ? error.stack ?? error.message : String(error)}
+`
+      );
+    }
+    process.exitCode = 1;
+  }
+);