recallnest 2.3.0 → 2.6.0

package/src/__tests__/pull-from-macbook-sync-only.test.ts

@@ -0,0 +1,679 @@
+import { describe, expect, it } from "bun:test";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+
+const REPO_ROOT = resolve(import.meta.dir, "../..");
+const SCRIPT = join(REPO_ROOT, "scripts", "pull-from-macbook.sh");
+const TEST_TIMEOUT_MS = 30_000;
+
+interface Harness {
+  root: string;
+  home: string;
+  remoteHome: string;
+  report: string;
+  rsyncLog: string;
+  sshLog: string;
+  registrarMarker: string;
+  ingestMarker: string;
+  env: NodeJS.ProcessEnv;
+}
+
+interface RsyncCall {
+  args: string[];
+  sourceArg: string;
+  targetArg: string;
+  dryRun: boolean;
+  ignoreTimes: boolean;
+}
+
+function executable(path: string, source: string): void {
+  writeFileSync(path, source, { mode: 0o700 });
+  chmodSync(path, 0o700);
+}
+
+function fixture(path: string, content: string): void {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, content);
+}
+
+function fakeRsyncSource(): string {
+  return [
+    "#!/usr/bin/env bun",
+    'import { appendFileSync, copyFileSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, renameSync, statSync, symlinkSync, writeFileSync } from "node:fs";',
+    'import { basename, dirname, extname, join, relative, sep } from "node:path";',
+    'const args = process.argv.slice(2);',
+    'const sourceArg = args.at(-2) || "";',
+    'const targetArg = args.at(-1) || "";',
+    'const dryRun = args.includes("--dry-run");',
+    'const ignoreTimes = args.includes("--ignore-times");',
+    'const optionValues = new Set(["-e", "--exclude", "--include", "--out-format", "--rsync-path", "--timeout"]);',
+    'for (let index = 0; index < args.length - 2; index += 1) {',
+    '  const arg = args[index];',
+    '  if (optionValues.has(arg)) { if (index + 1 >= args.length - 2) process.exit(64); index += 1; continue; }',
+    '  if (!arg.startsWith("-")) process.exit(64);',
+    '}',
+    'appendFileSync(process.env.FAKE_RSYNC_LOG, JSON.stringify({ args: args.slice(0, -2), sourceArg, targetArg, dryRun, ignoreTimes }) + "\\n");',
+    'if (!dryRun && process.env.FAKE_CREATE_REPORT_DURING_SYNC && !existsSync(process.env.FAKE_CREATE_REPORT_DURING_SYNC)) writeFileSync(process.env.FAKE_CREATE_REPORT_DURING_SYNC, "racing-writer");',
+    'if (!dryRun && process.env.FAKE_BREAK_MAPPING_TMP) {',
+    '  const report = process.env.FAKE_BREAK_MAPPING_TMP;',
+    '  const prefix = basename(report) + ".tmp.";',
+    '  const temporary = readdirSync(dirname(report))',
+    '    .filter((name) => name.startsWith(prefix) && !name.endsWith(".saved"))',
+    '    .map((name) => join(dirname(report), name))',
+    '    .find((path) => statSync(path).isFile());',
+    '  if (temporary) { renameSync(temporary, temporary + ".saved"); mkdirSync(temporary); }',
+    '}',
+    'if (!sourceArg.startsWith("mac:")) process.exit(64);',
+    'const remoteHome = process.env.FAKE_REMOTE_HOME;',
+    'let remoteRaw = sourceArg.slice(4);',
+    'let sourcePath = remoteRaw;',
+    'if (remoteRaw === "~") sourcePath = remoteHome;',
+    'else if (remoteRaw.startsWith("~/")) sourcePath = join(remoteHome, remoteRaw.slice(2));',
+    'else if (!remoteRaw.startsWith("/")) sourcePath = join(remoteHome, remoteRaw);',
+    'if (!existsSync(sourcePath)) process.exit(23);',
+    'function walk(root) {',
+    '  const files = [];',
+    '  for (const entry of readdirSync(root, { withFileTypes: true })) {',
+    '    const path = join(root, entry.name);',
+    '    if (entry.isDirectory()) files.push(...walk(path));',
+    '    else if (entry.isFile() || entry.isSymbolicLink()) files.push(path);',
+    '  }',
+    '  return files.sort();',
+    '}',
+    'function included(path) {',
+    '  const normalizedSource = sourcePath.split(sep).join("/");',
+    '  const name = basename(path);',
+    '  if (statSync(sourcePath).isFile()) return true;',
+    '  if (normalizedSource.includes("/.gemini/tmp")) return name.startsWith("session-") && extname(name) === ".json";',
+    '  if (normalizedSource.includes("/local-agent-mode-sessions")) return extname(name) === ".jsonl" && name !== "audit.jsonl";',
+    '  if (normalizedSource.includes("/antigravity-cli/brain")) return name === "transcript_full.jsonl";',
+    '  if (normalizedSource.includes("/antigravity-rescue/conversations")) return extname(name) === ".pb";',
+    '  return extname(name) === ".jsonl";',
+    '}',
+    'const sourceIsDirectory = statSync(sourcePath).isDirectory();',
+    'const files = (sourceIsDirectory ? walk(sourcePath) : [sourcePath]).filter(included);',
+    'if (dryRun && !ignoreTimes && process.env.FAKE_RSYNC_MUTATE_ON_VERIFY_SOURCE && sourceArg.includes(process.env.FAKE_RSYNC_MUTATE_ON_VERIFY_SOURCE) && files.length > 0) appendFileSync(files[0], "late-change");',
+    'const prefix = args.some((arg) => arg.includes("__RN_MAP__")) ? "__RN_MAP__" : "__RN_CHANGE__";',
+    'function copySource(source, destination) {',
+    '  mkdirSync(dirname(destination), { recursive: true });',
+    '  if (lstatSync(source).isSymbolicLink()) symlinkSync(readlinkSync(source), destination);',
+    '  else copyFileSync(source, destination);',
+    '}',
+    'const forcedFailure = Boolean(process.env.FAKE_RSYNC_FAIL_SOURCE && sourceArg.includes(process.env.FAKE_RSYNC_FAIL_SOURCE));',
+    'if (!dryRun && forcedFailure && files.length > 0) {',
+    '  const source = files[0];',
+    '  const rel = sourceIsDirectory ? relative(sourcePath, source).split(sep).join("/") : basename(source);',
+    '  const destination = sourceIsDirectory ? join(targetArg, rel) : targetArg;',
+    '  copySource(source, destination);',
+    '  process.exit(23);',
+    '}',
+    'for (const source of files) {',
+    '  const rel = sourceIsDirectory ? relative(sourcePath, source).split(sep).join("/") : basename(source);',
+    '  const destination = sourceIsDirectory ? join(targetArg, rel) : targetArg;',
+    '  if (dryRun) {',
+    '    const changed = !existsSync(destination) || !readFileSync(source).equals(readFileSync(destination));',
+    '    const item = lstatSync(source).isSymbolicLink() ? "cL+++++++++" : ">f+++++++++";',
+    '    if (ignoreTimes || changed) process.stdout.write(prefix + item + "|" + rel + "\\n");',
+    '    continue;',
+    '  }',
+    '  copySource(source, destination);',
+    '}',
+  ].join("\n") + "\n";
+}
+
+function fakeSshSource(): string {
+  return [
+    "#!/usr/bin/env bun",
+    'import { appendFileSync, existsSync, statSync } from "node:fs";',
+    'import { join } from "node:path";',
+    'const args = process.argv.slice(2);',
+    'const command = args.join(" ");',
+    'appendFileSync(process.env.FAKE_SSH_LOG, command + "\\n");',
+    'if (process.env.FAKE_SSH_ONLINE !== "1") process.exit(255);',
+    'if (command.includes("echo online")) { console.log("online"); process.exit(0); }',
+    'if (process.env.FAKE_SSH_FAIL_PROBE && command.includes(process.env.FAKE_SSH_FAIL_PROBE)) process.exit(255);',
+    'if (command.includes("$HOME/.codex") && command.includes("session_index.jsonl")) { const path = join(process.env.FAKE_REMOTE_HOME, ".codex/session_index.jsonl"); process.exit(!existsSync(path) ? 2 : statSync(path).isFile() ? 0 : 3); }',
+    'if (command.includes("$HOME/.kimi-code") && command.includes("session_index.jsonl")) { const path = join(process.env.FAKE_REMOTE_HOME, ".kimi-code/session_index.jsonl"); process.exit(!existsSync(path) ? 2 : statSync(path).isFile() ? 0 : 3); }',
+    'if (command.includes("antigravity-rescue")) { const path = join(process.env.FAKE_REMOTE_HOME, "Downloads/antigravity-rescue/conversations"); process.exit(!existsSync(path) ? 2 : statSync(path).isDirectory() ? 0 : 3); }',
+    'process.exit(0);',
+  ].join("\n") + "\n";
+}
+
+function makeHarness(): Harness {
+  const root = mkdtempSync(join(tmpdir(), "pull-sync-only-"));
+  const home = join(root, "home");
+  const remoteHome = join(root, "remote-home");
+  const fakeBin = join(root, "bin");
+  const report = join(root, "mapping.tsv");
+  const rsyncLog = join(root, "rsync.jsonl");
+  const sshLog = join(root, "ssh.log");
+  const registrarMarker = join(root, "registrar-called");
+  const ingestMarker = join(root, "ingest-called");
+
+  mkdirSync(fakeBin, { recursive: true });
+  mkdirSync(join(home, "recallnest", "scripts"), { recursive: true });
+  executable(join(fakeBin, "rsync"), fakeRsyncSource());
+  executable(join(fakeBin, "ssh"), fakeSshSource());
+  executable(
+    join(home, "recallnest", "scripts", "codex-projectless-register.py"),
+    [
+      "#!/bin/bash",
+      'printf "called\\n" > "$FAKE_REGISTRAR_MARKER"',
+    ].join("\n") + "\n",
+  );
+  executable(
+    join(home, "recallnest", "scripts", "incremental-ingest.sh"),
+    [
+      "#!/bin/bash",
+      'printf "called\\n" > "$FAKE_INGEST_MARKER"',
+    ].join("\n") + "\n",
+  );
+
+  fixture(join(remoteHome, ".claude", "projects", "p", "cc.jsonl"), "{\"source\":\"cc\"}\n");
+  fixture(join(remoteHome, ".codex", "sessions", "2026", "codex.jsonl"), "{\"source\":\"codex\"}\n");
+  fixture(join(remoteHome, ".codex", "archived_sessions", "archived.jsonl"), "{\"source\":\"archive\"}\n");
+  fixture(
+    join(remoteHome, ".codex", "session_index.jsonl"),
+    "{\"id\":\"mac-codex\",\"updated_at\":\"2026-08-03T00:00:00Z\"}\n",
+  );
+  fixture(join(remoteHome, ".kimi-code", "sessions", "k1", "wire.jsonl"), "{\"source\":\"kimi\"}\n");
+  fixture(join(remoteHome, ".kimi-code", "session_index.jsonl"), "{\"sessionId\":\"mac-kimi\"}\n");
+  fixture(join(remoteHome, ".gemini", "tmp", "g1", "chats", "session-g.json"), "{\"source\":\"gemini\"}\n");
+  fixture(
+    join(
+      remoteHome,
+      "Library",
+      "Application Support",
+      "Claude",
+      "local-agent-mode-sessions",
+      "d1",
+      ".claude",
+      "projects",
+      "p",
+      "desktop-one.jsonl",
+    ),
+    "{\"source\":\"desktop\"}\n",
+  );
+  fixture(
+    join(remoteHome, ".gemini", "antigravity-cli", "brain", "b1", "transcript_full.jsonl"),
+    "{\"source\":\"agy-brain\"}\n",
+  );
+  fixture(
+    join(remoteHome, "Downloads", "antigravity-rescue", "conversations", "legacy.pb"),
+    "legacy-original",
+  );
+  fixture(
+    join(remoteHome, ".gemini", "antigravity-cli", "conversations", "remote-cli.db"),
+    "remote-cli-original",
+  );
+  fixture(
+    join(remoteHome, ".gemini", "antigravity", "conversations", "remote-app.db"),
+    "remote-app-original",
+  );
+
+  for (let index = 1; index <= 24; index += 1) {
+    fixture(
+      join(home, "machine-data", "macbook-agy", "conversations", "existing-" + index + ".db"),
+      "mini-existing-" + index,
+    );
+  }
+
+  const env: NodeJS.ProcessEnv = {
+    ...process.env,
+    LC_ALL: "C",
+    PULL_FROM_MACBOOK_HOME: home,
+    PULL_FROM_MACBOOK_RSYNC: join(fakeBin, "rsync"),
+    PULL_FROM_MACBOOK_SSH: join(fakeBin, "ssh"),
+    FAKE_REMOTE_HOME: remoteHome,
+    FAKE_RSYNC_LOG: rsyncLog,
+    FAKE_SSH_LOG: sshLog,
+    FAKE_SSH_ONLINE: "1",
+    FAKE_REGISTRAR_MARKER: registrarMarker,
+    FAKE_INGEST_MARKER: ingestMarker,
+    PULL_FROM_MACBOOK_LOG: join(root, "pull.log"),
+    PULL_FROM_MACBOOK_LOG_DIR: join(root, "logs"),
+  };
+
+  return {
+    root,
+    home,
+    remoteHome,
+    report,
+    rsyncLog,
+    sshLog,
+    registrarMarker,
+    ingestMarker,
+    env,
+  };
+}
+
+function run(harness: Harness, args: string[], extraEnv: NodeJS.ProcessEnv = {}) {
+  return spawnSync("/bin/bash", [SCRIPT, ...args], {
+    env: { ...harness.env, ...extraEnv },
+    encoding: "utf8",
+    timeout: 30_000,
+  });
+}
+
+function syncOnly(harness: Harness) {
+  return run(harness, ["--sync-only", "--mapping-report", harness.report]);
+}
+
+function rsyncCalls(harness: Harness): RsyncCall[] {
+  if (!existsSync(harness.rsyncLog)) return [];
+  return readFileSync(harness.rsyncLog, "utf8")
+    .trim()
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => JSON.parse(line) as RsyncCall);
+}
+
+function normalizedRsyncArgs(args: string[]): string[] {
+  return args.filter(
+    (arg) =>
+      arg !== "--dry-run"
+      && arg !== "--ignore-times"
+      && arg !== "--itemize-changes"
+      && !arg.startsWith("--out-format="),
+  );
+}
+
+function unexpectedPositionalArgs(args: string[]): string[] {
+  const valueOptions = new Set(["-e", "--exclude", "--include", "--out-format", "--rsync-path", "--timeout"]);
+  const unexpected: string[] = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (valueOptions.has(arg)) {
+      index += 1;
+      continue;
+    }
+    if (!arg.startsWith("-")) unexpected.push(arg);
+  }
+  return unexpected;
+}
+
+function dbContents(directory: string): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (let index = 1; index <= 24; index += 1) {
+    const name = "existing-" + index + ".db";
+    result[name] = readFileSync(join(directory, name), "utf8");
+  }
+  return result;
+}
+
+describe("pull-from-macbook --sync-only", () => {
+  it("syncs allowed sources, verifies identical rsync arguments, and emits per-file mappings without ingest", () => {
+    const harness = makeHarness();
+    expect(harness.env.HOME).toBe(process.env.HOME);
+    const localDbDir = join(harness.home, "machine-data", "macbook-agy", "conversations");
+    const localDbBefore = dbContents(localDbDir);
+    const remoteCliDb = join(harness.remoteHome, ".gemini", "antigravity-cli", "conversations", "remote-cli.db");
+    const remoteAppDb = join(harness.remoteHome, ".gemini", "antigravity", "conversations", "remote-app.db");
+    const remoteCliBefore = readFileSync(remoteCliDb, "utf8");
+    const remoteAppBefore = readFileSync(remoteAppDb, "utf8");
+
+    const result = syncOnly(harness);
+
+    expect(result.status).toBe(0);
+    expect(existsSync(harness.ingestMarker)).toBe(false);
+    expect(existsSync(harness.registrarMarker)).toBe(false);
+    expect(readFileSync(join(harness.home, ".claude", "projects", "p", "cc.jsonl"), "utf8")).toContain("cc");
+    expect(
+      readFileSync(
+        join(harness.home, "recallnest", "data", "desktop-import", "desktop-one.jsonl"),
+        "utf8",
+      ),
+    ).toContain("desktop");
+    expect(readFileSync(join(harness.home, ".codex", "session_index.jsonl"), "utf8")).toContain("mac-codex");
+    expect(readFileSync(join(harness.home, ".kimi-code", "session_index.jsonl"), "utf8")).toContain("mac-kimi");
+
+    const mapping = readFileSync(harness.report, "utf8");
+    expect(mapping.split("\n")[0]).toBe(
+      "source_kind\tsource_file\tlocal_target\tderived_target\tstatus",
+    );
+    expect(mapping).toContain("claude-code\tmac:~/.claude/projects/p/cc.jsonl");
+    expect(mapping).toContain(
+      join(harness.home, "recallnest", "data", "desktop-import", "desktop-one.jsonl"),
+    );
+    expect(mapping).toContain("desktop-flat\t");
+    expect(mapping).toContain("codex-index-merge\t");
+    for (const line of mapping.trim().split("\n").slice(1)) {
+      expect(line.split("\t")).toHaveLength(5);
+    }
+    const desktopTransportRows = mapping
+      .trim()
+      .split("\n")
+      .slice(1)
+      .map((line) => line.split("\t"))
+      .filter(([sourceKind]) => sourceKind === "claude-desktop");
+    expect(desktopTransportRows.length).toBeGreaterThan(0);
+    expect(
+      desktopTransportRows.every((fields) => fields[4] === "local-verified:derived-pending"),
+    ).toBe(true);
+    expect(statSync(harness.report).mode & 0o777).toBe(0o600);
+    expect(existsSync(join(harness.home, ".codex", ".codex-global-state.json"))).toBe(false);
+
+    const calls = rsyncCalls(harness);
+    const grouped = new Map<string, RsyncCall[]>();
+    for (const call of calls) {
+      grouped.set(call.sourceArg, [...(grouped.get(call.sourceArg) || []), call]);
+    }
+    expect(grouped.size).toBe(10);
+    for (const sourceCalls of grouped.values()) {
+      expect(sourceCalls).toHaveLength(3);
+      const real = sourceCalls.find((call) => !call.dryRun);
+      const verify = sourceCalls.find((call) => call.dryRun && !call.ignoreTimes);
+      const inventory = sourceCalls.find((call) => call.dryRun && call.ignoreTimes);
+      expect(real).toBeDefined();
+      expect(verify).toBeDefined();
+      expect(inventory).toBeDefined();
+      expect(normalizedRsyncArgs(verify!.args)).toEqual(real!.args);
+      expect(normalizedRsyncArgs(inventory!.args)).toEqual(real!.args);
+      expect(verify!.targetArg).toBe(real!.targetArg);
+      expect(inventory!.targetArg).toBe(real!.targetArg);
+      expect(unexpectedPositionalArgs(real!.args)).toEqual([]);
+    }
+    const desktopSource = "mac:Library/Application Support/Claude/local-agent-mode-sessions/";
+    const desktopCalls = grouped.get(desktopSource);
+    expect(desktopCalls).toHaveLength(3);
+    expect(desktopCalls!.every((call) => call.args.includes("-s"))).toBe(true);
+    expect(
+      calls.some((call) =>
+        call.sourceArg.includes("/.gemini/antigravity-cli/conversations/")
+        || call.sourceArg.includes("/.gemini/antigravity/conversations/")
+      ),
+    ).toBe(false);
+    const wrapperSource = readFileSync(SCRIPT, "utf8");
+    expect(wrapperSource).not.toContain("mac:~/.gemini/antigravity-cli/conversations/");
+    expect(wrapperSource).not.toContain("mac:~/.gemini/antigravity/conversations/");
+
+    expect(dbContents(localDbDir)).toEqual(localDbBefore);
+    expect(readFileSync(remoteCliDb, "utf8")).toBe(remoteCliBefore);
+    expect(readFileSync(remoteAppDb, "utf8")).toBe(remoteAppBefore);
+    const sshCalls = readFileSync(harness.sshLog, "utf8");
+    expect(sshCalls).toContain("echo online");
+    expect(sshCalls).toContain("$HOME/.codex");
+    expect(sshCalls).toContain("$HOME/.kimi-code");
+    expect(sshCalls).toContain("antigravity-rescue");
+  }, TEST_TIMEOUT_MS);
+
+  it("fails offline in sync-only mode but keeps the routine offline run successful", () => {
+    const syncHarness = makeHarness();
+    const syncResult = run(
+      syncHarness,
+      ["--sync-only", "--mapping-report", syncHarness.report],
+      { FAKE_SSH_ONLINE: "0" },
+    );
+    expect(syncResult.status).not.toBe(0);
+    expect(readFileSync(syncHarness.report, "utf8")).toContain("transport\tmac\t-\t-\toffline");
+    expect(existsSync(syncHarness.registrarMarker)).toBe(false);
+    expect(existsSync(syncHarness.ingestMarker)).toBe(false);
+    expect(rsyncCalls(syncHarness)).toHaveLength(0);
+
+    const routineHarness = makeHarness();
+    const routineResult = run(routineHarness, [], { FAKE_SSH_ONLINE: "0" });
+    expect(routineResult.status).toBe(0);
+    expect(existsSync(routineHarness.registrarMarker)).toBe(true);
+    expect(existsSync(routineHarness.ingestMarker)).toBe(false);
+
+    const existingReportHarness = makeHarness();
+    fixture(existingReportHarness.report, "keep-existing-report");
+    const existingReportResult = syncOnly(existingReportHarness);
+    expect(existingReportResult.status).not.toBe(0);
+    expect(readFileSync(existingReportHarness.report, "utf8")).toBe("keep-existing-report");
+    expect(existsSync(existingReportHarness.sshLog)).toBe(false);
+
+    const racingReportHarness = makeHarness();
+    const racingReportResult = run(
+      racingReportHarness,
+      ["--sync-only", "--mapping-report", racingReportHarness.report],
+      { FAKE_CREATE_REPORT_DURING_SYNC: racingReportHarness.report },
+    );
+    expect(racingReportResult.status).not.toBe(0);
+    expect(readFileSync(racingReportHarness.report, "utf8")).toBe("racing-writer");
+  }, TEST_TIMEOUT_MS);
+
+  it("fails before flattening when Desktop basenames collide", () => {
+    const harness = makeHarness();
+    fixture(
+      join(
+        harness.remoteHome,
+        "Library",
+        "Application Support",
+        "Claude",
+        "local-agent-mode-sessions",
+        "d2",
+        ".claude",
+        "projects",
+        "other",
+        "Desktop-One.jsonl",
+      ),
+      "{\"source\":\"collision\"}\n",
+    );
+
+    const result = syncOnly(harness);
+
+    expect(result.status).not.toBe(0);
+    expect(readFileSync(harness.report, "utf8")).toContain("basename-collision");
+    expect(
+      existsSync(join(harness.home, "recallnest", "data", "desktop-import", "desktop-one.jsonl")),
+    ).toBe(false);
+    expect(existsSync(harness.ingestMarker)).toBe(false);
+
+    const symlinkHarness = makeHarness();
+    const linkedContent = join(symlinkHarness.remoteHome, "linked-content.jsonl");
+    fixture(linkedContent, "{\"source\":\"must-not-follow\"}\n");
+    const linkedSession = join(
+      symlinkHarness.remoteHome,
+      "Library",
+      "Application Support",
+      "Claude",
+      "local-agent-mode-sessions",
+      "d2",
+      ".claude",
+      "projects",
+      "other",
+      "linked.jsonl",
+    );
+    mkdirSync(dirname(linkedSession), { recursive: true });
+    symlinkSync(linkedContent, linkedSession);
+
+    const symlinkResult = syncOnly(symlinkHarness);
+
+    expect(symlinkResult.status).not.toBe(0);
+    expect(readFileSync(symlinkHarness.report, "utf8")).toContain("unsafe-symlink");
+    expect(
+      existsSync(join(symlinkHarness.home, "recallnest", "data", "desktop-import", "linked.jsonl")),
+    ).toBe(false);
+
+    const destinationHarness = makeHarness();
+    const outsideTarget = join(destinationHarness.root, "outside-target.jsonl");
+    fixture(outsideTarget, "outside-must-not-be-ingested");
+    const destinationLink = join(
+      destinationHarness.home,
+      "recallnest",
+      "data",
+      "desktop-import",
+      "desktop-one.jsonl",
+    );
+    mkdirSync(dirname(destinationLink), { recursive: true });
+    symlinkSync(outsideTarget, destinationLink);
+
+    const destinationResult = syncOnly(destinationHarness);
+
+    expect(destinationResult.status).not.toBe(0);
+    expect(readFileSync(destinationHarness.report, "utf8")).toContain(
+      "unsafe-destination-symlink",
+    );
+    expect(readFileSync(outsideTarget, "utf8")).toBe("outside-must-not-be-ingested");
+  }, TEST_TIMEOUT_MS);
+
+  it("surfaces a Desktop copy failure and does not ingest", () => {
+    const harness = makeHarness();
+    mkdirSync(
+      join(harness.home, "recallnest", "data", "desktop-import", "desktop-one.jsonl"),
+      { recursive: true },
+    );
+
+    const result = syncOnly(harness);
+
+    expect(result.status).not.toBe(0);
+    expect(readFileSync(harness.report, "utf8")).toContain("copy-failed:IsADirectoryError");
+    expect(existsSync(harness.ingestMarker)).toBe(false);
+  }, TEST_TIMEOUT_MS);
+
+  it("does not derive from a failed or partial source sync", () => {
+    const desktopHarness = makeHarness();
+    const desktopImport = join(
+      desktopHarness.home,
+      "recallnest",
+      "data",
+      "desktop-import",
+      "desktop-one.jsonl",
+    );
+    fixture(desktopImport, "known-good-desktop");
+
+    const desktopResult = run(
+      desktopHarness,
+      ["--sync-only", "--mapping-report", desktopHarness.report],
+      { FAKE_RSYNC_FAIL_SOURCE: "local-agent-mode-sessions" },
+    );
+
+    expect(desktopResult.status).not.toBe(0);
+    expect(readFileSync(desktopImport, "utf8")).toBe("known-good-desktop");
+    expect(readFileSync(desktopHarness.report, "utf8")).toContain(
+      "derived-skipped:source-sync-failed",
+    );
+
+    const indexHarness = makeHarness();
+    const kimiIndex = join(indexHarness.home, ".kimi-code", "session_index.jsonl");
+    fixture(kimiIndex, "{\"sessionId\":\"mini-only\"}\n");
+
+    const indexResult = run(
+      indexHarness,
+      ["--sync-only", "--mapping-report", indexHarness.report],
+      { FAKE_RSYNC_FAIL_SOURCE: ".kimi-code/session_index.jsonl" },
+    );
+
+    expect(indexResult.status).not.toBe(0);
+    expect(readFileSync(kimiIndex, "utf8")).toContain("mini-only");
+    expect(readFileSync(kimiIndex, "utf8")).not.toContain("mac-kimi");
+    expect(readFileSync(indexHarness.report, "utf8")).toContain(
+      "kimi-index-merge\t" + join(indexHarness.home, ".kimi-code", "session_index.macbook.jsonl"),
+    );
+    expect(readFileSync(indexHarness.report, "utf8")).toContain(
+      "derived-skipped:source-sync-failed",
+    );
+  }, TEST_TIMEOUT_MS);
+
+  it("distinguishes absent probes from partial, transport, and wrong-type failures", () => {
+    const legacyHarness = makeHarness();
+    const legacyResult = run(
+      legacyHarness,
+      ["--sync-only", "--mapping-report", legacyHarness.report],
+      { FAKE_RSYNC_FAIL_SOURCE: "antigravity-rescue/conversations" },
+    );
+    const legacyMapping = readFileSync(legacyHarness.report, "utf8");
+    expect(legacyResult.status).not.toBe(0);
+    expect(legacyMapping).toContain("agy-legacy-pb\t");
+    expect(legacyMapping).toContain("sync-failed:23");
+    expect(legacyMapping).not.toContain(
+      "agy-legacy-pb\tmac:~/Downloads/antigravity-rescue/conversations/\t"
+      + join(legacyHarness.home, "machine-data", "macbook-agy", "legacy-pb")
+      + "/\t"
+      + join(legacyHarness.home, "machine-data", "macbook-agy", "legacy-pb")
+      + "/\tsource-absent",
+    );
+
+    const probeHarness = makeHarness();
+    const probeResult = run(
+      probeHarness,
+      ["--sync-only", "--mapping-report", probeHarness.report],
+      { FAKE_SSH_FAIL_PROBE: "$HOME/.codex" },
+    );
+    expect(probeResult.status).not.toBe(0);
+    expect(readFileSync(probeHarness.report, "utf8")).toContain("probe-failed:255");
+    expect(
+      rsyncCalls(probeHarness).some((call) =>
+        call.sourceArg === "mac:~/.codex/session_index.jsonl"
+      ),
+    ).toBe(false);
+
+    const wrongTypeHarness = makeHarness();
+    const wrongTypeIndex = join(
+      wrongTypeHarness.remoteHome,
+      ".codex",
+      "session_index.jsonl",
+    );
+    renameSync(wrongTypeIndex, wrongTypeIndex + ".saved");
+    mkdirSync(wrongTypeIndex);
+    const wrongTypeResult = syncOnly(wrongTypeHarness);
+    const wrongTypeMapping = readFileSync(wrongTypeHarness.report, "utf8");
+    expect(wrongTypeResult.status).not.toBe(0);
+    expect(wrongTypeMapping).toContain("probe-failed:3");
+    expect(wrongTypeMapping).not.toContain(
+      "codex-session-index\tmac:~/.codex/session_index.jsonl\t"
+      + join(wrongTypeHarness.home, ".codex", "session_index.macbook.jsonl")
+      + "\t"
+      + join(wrongTypeHarness.home, ".codex", "session_index.jsonl")
+      + "\tsource-absent",
+    );
+
+    const absentHarness = makeHarness();
+    const absentIndex = join(absentHarness.remoteHome, ".codex", "session_index.jsonl");
+    renameSync(absentIndex, absentIndex + ".saved");
+    const absentResult = syncOnly(absentHarness);
+    expect(absentResult.status).toBe(0);
+    expect(readFileSync(absentHarness.report, "utf8")).toContain(
+      "codex-session-index\tmac:~/.codex/session_index.jsonl\t"
+      + join(absentHarness.home, ".codex", "session_index.macbook.jsonl")
+      + "\t"
+      + join(absentHarness.home, ".codex", "session_index.jsonl")
+      + "\tsource-absent",
+    );
+  }, TEST_TIMEOUT_MS);
+
+  it("surfaces mapping append failures without installing a report or ingesting", () => {
+    const harness = makeHarness();
+    const result = run(
+      harness,
+      ["--sync-only", "--mapping-report", harness.report],
+      { FAKE_BREAK_MAPPING_TMP: harness.report },
+    );
+
+    expect(result.status).not.toBe(0);
+    expect(result.stdout + result.stderr).toContain("sync-only 映射报告追加失败");
+    expect(existsSync(harness.report)).toBe(false);
+    expect(existsSync(harness.ingestMarker)).toBe(false);
+  }, TEST_TIMEOUT_MS);
+
+  it("marks files pending when a live source changes after inventory", () => {
+    const liveSourceHarness = makeHarness();
+    const liveSourceResult = run(
+      liveSourceHarness,
+      ["--sync-only", "--mapping-report", liveSourceHarness.report],
+      { FAKE_RSYNC_MUTATE_ON_VERIFY_SOURCE: ".claude/projects/" },
+    );
+    const liveSourceRows = readFileSync(liveSourceHarness.report, "utf8")
+      .trim()
+      .split("\n")
+      .slice(1)
+      .map((line) => line.split("\t"))
+      .filter(([sourceKind]) => sourceKind === "claude-code");
+    expect(liveSourceResult.status).not.toBe(0);
+    expect(liveSourceRows.some((fields) => fields[4] === "pending:1")).toBe(true);
+    expect(liveSourceRows.some((fields) => fields[4] === "verified")).toBe(false);
+  }, TEST_TIMEOUT_MS);
+});