@indigoai-us/hq-cloud 6.14.3 → 6.14.5

package/src/cli/reindex.ts

@@ -2,9 +2,9 @@
  * hq reindex — surfaces namespaced skills as Claude Code skill wrappers under
  * .claude/skills/<ns>:<skill>/ (one symlink per source file), mirrors
  * personal/{knowledge,policies,workers,settings}/<entry> into core/<type>/,
- * prunes orphan wrappers + legacy command symlinks, captures this root's Claude
- * Code session logs into workspace/.session-logs, and regenerates the workers
- * registry.
+ * prunes orphan wrappers + legacy command symlinks, captures this HQ tree's
+ * coding-harness session logs (Claude Code / Codex / Grok) into
+ * workspace/.session-logs/<harness>/, and regenerates the workers registry.
  *
  * The logic historically lived in a bundled bash script (scripts/reindex.sh)
  * that this module exec'd via `bash`. It is now implemented natively in
@@ -199,46 +199,216 @@ function safeSymlink(target: string, linkPath: string, label: string): boolean {
   }
 }
 
-// Copy every file/folder under Claude Code's session-log directory for this HQ
-// root (`<claude-config>/projects/<encoded-root>`) into
-// `workspace/.session-logs`, so the raw session transcripts are captured inside
+// Capture the raw session transcripts of every supported coding harness for
+// this HQ tree into `workspace/.session-logs/<harness>/`, so they live inside
 // the HQ tree (where sync/search can see them) on each reindex.
 //
-// Contract (per the feature request):
-//   - copies ALL files and folders from the projects dir into the dest,
-//   - OVERWRITES existing dest files (force), and
-//   - NEVER deletes dest entries that lack a source counterpart — this is a
-//     one-way overlay, not a mirror, so anything already parked in
-//     workspace/.session-logs survives even after Claude Code rotates or prunes
-//     its own projects dir.
+// Scope — "this HQ tree" = the HQ root cwd OR any working directory UNDER it
+// (worktrees, repo subdirs). Harnesses key their logs by cwd differently, so
+// each helper re-derives the same scope in its own encoding.
 //
-// Best-effort: any failure warns to stderr and is swallowed so it can never
-// fail the reindex. `<claude-config>` honors CLAUDE_CONFIG_DIR, else ~/.claude.
+// Contract (per the feature request), applied by every helper:
+//   - copies ALL matching files/folders into `.session-logs/<harness>/…`,
+//   - OVERWRITES existing dest files, and
+//   - NEVER deletes dest entries that lack a source counterpart — a one-way
+//     overlay, not a mirror, so anything already parked in `.session-logs`
+//     survives even after a harness rotates or prunes its own store.
+//
+// Best-effort throughout: any failure warns to stderr and is swallowed so it
+// can never fail the reindex. Each harness is independent — one failing must
+// not stop the others. Home dirs honor CLAUDE_CONFIG_DIR / CODEX_HOME /
+// GROK_HOME, else ~/.claude, ~/.codex, ~/.grok.
 function copySessionLogs(root: string): void {
-  // Claude Code names a project's log dir by replacing every non-alphanumeric
-  // character in the project's cwd with '-' (e.g. /home/ec2-user/hq ->
-  // -home-ec2-user-hq). Re-derive that slug so we target THIS root's logs.
-  const slug = root.replace(/[^a-zA-Z0-9]/g, "-");
-  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
-  const src = path.join(claudeConfigDir, "projects", slug);
-  if (!isDir(src)) return; // no session logs for this root yet — nothing to do
+  const destBase = path.join(root, "workspace", ".session-logs");
+  for (const capture of [
+    copyClaudeSessionLogs,
+    copyCodexSessionLogs,
+    copyGrokSessionLogs,
+  ]) {
+    try {
+      capture(root, destBase);
+    } catch (err) {
+      warn(`reindex: session-log capture step failed (${(err as Error).message}); skipping.`);
+    }
+  }
+}
 
-  const dest = path.join(root, "workspace", ".session-logs");
-  if (!safeMkdir(dest, "workspace/.session-logs directory")) return;
+/** `fs.statSync` without throwing (follows symlinks; null when missing). */
+function statOrNull(p: string): fs.Stats | null {
+  try {
+    return fs.statSync(p);
+  } catch {
+    return null;
+  }
+}
 
+// Overlay-copy a whole directory tree: mkdir dest, then recursive+force cpSync
+// (overwrite existing, never prune dest-only entries). Best-effort — warns and
+// returns on any failure. Shared by the Claude + Grok per-cwd-folder captures.
+function copyTreeOverlay(src: string, dest: string, label: string): void {
+  if (!safeMkdir(dest, `${label} directory`)) return;
   try {
-    // recursive: copy the whole tree; force: overwrite existing dest files.
-    // cpSync copies src INTO dest and never removes dest-only entries — exactly
-    // the "overwrite, but don't delete extras" contract we want.
     fs.cpSync(src, dest, { recursive: true, force: true });
   } catch (err) {
     warn(
-      `reindex: could not copy session logs from '${src}' to '${dest}' ` +
+      `reindex: could not copy ${label} from '${src}' to '${dest}' ` +
         `(${(err as NodeJS.ErrnoException).code ?? "error"}: ${(err as Error).message}); skipping.`,
     );
   }
 }
 
+// Claude Code: `<claude-config>/projects/<encoded-cwd>/…`, where the cwd is
+// encoded by replacing every non-alphanumeric char with '-'. Because that map
+// is per-character, a descendant cwd's dir name is exactly the root's encoded
+// name + '-' + <encoded-subpath> — so "this HQ tree" is the exact-root dir OR
+// any dir whose name starts with `<slug>-`. Copy each into `.session-logs/claude/`.
+function copyClaudeSessionLogs(root: string, destBase: string): void {
+  const configDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
+  const projectsDir = path.join(configDir, "projects");
+  if (!isDir(projectsDir)) return;
+
+  const slug = root.replace(/[^a-zA-Z0-9]/g, "-");
+  for (const entry of globEntries(projectsDir)) {
+    if (entry !== slug && !entry.startsWith(`${slug}-`)) continue;
+    const src = path.join(projectsDir, entry);
+    if (!isDir(src)) continue;
+    copyTreeOverlay(src, path.join(destBase, "claude", entry), "claude session logs");
+  }
+}
+
+// Grok: `<grok-home>/sessions/<url-encoded-cwd>/<session-uuid>/…`, where the cwd
+// is URL-encoded (encodeURIComponent: '/' -> '%2F'). A descendant cwd's key is
+// the root's key + '%2F' + <encoded-subpath>, so match the exact-root key OR
+// that prefix. Copy each matching cwd folder into `.session-logs/grok/`.
+function copyGrokSessionLogs(root: string, destBase: string): void {
+  const grokHome = process.env.GROK_HOME || path.join(os.homedir(), ".grok");
+  const sessionsDir = path.join(grokHome, "sessions");
+  if (!isDir(sessionsDir)) return;
+
+  const key = encodeURIComponent(root);
+  for (const entry of globEntries(sessionsDir)) {
+    if (entry !== key && !entry.startsWith(`${key}%2F`)) continue;
+    const src = path.join(sessionsDir, entry);
+    if (!isDir(src)) continue;
+    copyTreeOverlay(src, path.join(destBase, "grok", entry), "grok session logs");
+  }
+}
+
+// Codex: `<codex-home>/sessions/YYYY/MM/DD/rollout-*.jsonl` — a DATE tree, not
+// per-project. The working dir is only recorded inside each rollout's first
+// line (`session_meta`, at `payload.cwd`). Walk the tree and capture a rollout
+// iff its recorded cwd is the HQ root or under it, mirroring the date-relative
+// path under `.session-logs/codex/`. A rollout already copied and unchanged is
+// skipped by mtime, so a steady-state reindex only classifies newly-written
+// rollouts — the full-tree cwd scan is a one-time first-run cost.
+function copyCodexSessionLogs(root: string, destBase: string): void {
+  const codexHome = process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
+  const sessionsDir = path.join(codexHome, "sessions");
+  if (!isDir(sessionsDir)) return;
+
+  const destDir = path.join(destBase, "codex");
+  const rootPrefix = root.endsWith(path.sep) ? root : root + path.sep;
+
+  for (const abs of walkFiles(sessionsDir)) {
+    if (!abs.endsWith(".jsonl")) continue;
+    const srcStat = statOrNull(abs);
+    if (!srcStat) continue;
+
+    const dest = path.join(destDir, path.relative(sessionsDir, abs));
+    // Cheap skip: already captured and unchanged since (dest mtime is the copy
+    // time, so it stays >= src mtime until the rollout is appended to again).
+    const destStat = statOrNull(dest);
+    if (destStat && destStat.mtimeMs >= srcStat.mtimeMs) continue;
+
+    const cwd = readCodexRolloutCwd(abs);
+    if (cwd === null) continue;
+    if (cwd !== root && !cwd.startsWith(rootPrefix)) continue;
+
+    if (!safeMkdir(path.dirname(dest), "codex session-log dir")) continue;
+    try {
+      fs.copyFileSync(abs, dest);
+    } catch (err) {
+      warn(
+        `reindex: could not copy codex session log '${abs}' -> '${dest}' ` +
+          `(${(err as NodeJS.ErrnoException).code ?? "error"}: ${(err as Error).message}); skipping.`,
+      );
+    }
+  }
+}
+
+// Recursively collect every regular file under `dir` (absolute paths). Symlinks
+// are not followed (lstat gate) so a stray link can't escape the tree or loop.
+// Missing/unreadable dirs yield []. Best-effort — mirrors globEntries' tolerance.
+function walkFiles(dir: string): string[] {
+  const out: string[] = [];
+  let names: string[];
+  try {
+    names = fs.readdirSync(dir);
+  } catch {
+    return out;
+  }
+  for (const name of names) {
+    const abs = path.join(dir, name);
+    const st = lstatOrNull(abs);
+    if (!st) continue;
+    if (st.isDirectory()) out.push(...walkFiles(abs));
+    else if (st.isFile()) out.push(abs);
+  }
+  return out;
+}
+
+// Extract `payload.cwd` (Codex ≥ the session_meta format; falls back to a
+// top-level `cwd`) from a rollout's first line, reading only that line. Codex
+// records cwd early, before the large `base_instructions` blob, but the line
+// can still be tens of KB — so read up to a generous cap and stop at the first
+// newline. Returns null on any parse/read failure (the rollout is then skipped).
+function readCodexRolloutCwd(file: string): string | null {
+  const line = readFirstLine(file, 4 * 1024 * 1024);
+  if (line === null) return null;
+  try {
+    const obj = JSON.parse(line) as { cwd?: unknown; payload?: { cwd?: unknown } };
+    const cwd = obj?.payload?.cwd ?? obj?.cwd;
+    return typeof cwd === "string" ? cwd : null;
+  } catch {
+    return null;
+  }
+}
+
+// Read the first line of `file` (up to `capBytes`), returning it WITHOUT the
+// trailing newline, or null on error / empty. Byte-accumulates and decodes once
+// so a multibyte char split across a read boundary can't corrupt the result.
+function readFirstLine(file: string, capBytes: number): string | null {
+  let fd: number | null = null;
+  try {
+    fd = fs.openSync(file, "r");
+    const chunks: Buffer[] = [];
+    const chunk = Buffer.allocUnsafe(65536);
+    let total = 0;
+    while (total < capBytes) {
+      const n = fs.readSync(fd, chunk, 0, chunk.length, total);
+      if (n <= 0) break;
+      const nl = chunk.indexOf(0x0a, 0);
+      if (nl !== -1 && nl < n) {
+        chunks.push(Buffer.from(chunk.subarray(0, nl)));
+        return Buffer.concat(chunks).toString("utf8");
+      }
+      chunks.push(Buffer.from(chunk.subarray(0, n)));
+      total += n;
+    }
+    return chunks.length ? Buffer.concat(chunks).toString("utf8") : null;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== null) {
+      try {
+        fs.closeSync(fd);
+      } catch {
+        /* best-effort */
+      }
+    }
+  }
+}
+
 // --- legacy `.claude/commands/<ns>/<skill>.md` symlink matcher --------------
 // Mirrors the bash `case` patterns; `*` matches any chars (including `/`).
 function isLegacyCommandTarget(t: string): boolean {

package/src/cli/rescue-clone-diagnostics.test.ts

@@ -0,0 +1,120 @@
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { runRescue } from "./rescue-core.js";
+
+function runRescueCapture(argv: string[], env: NodeJS.ProcessEnv) {
+  let stdout = "";
+  let stderr = "";
+  const origOut = process.stdout.write.bind(process.stdout);
+  const origErr = process.stderr.write.bind(process.stderr);
+  process.stdout.write = ((chunk: unknown) => {
+    stdout += String(chunk);
+    return true;
+  }) as typeof process.stdout.write;
+  process.stderr.write = ((chunk: unknown) => {
+    stderr += String(chunk);
+    return true;
+  }) as typeof process.stderr.write;
+  let status: number;
+  try {
+    status = runRescue(argv, { env }).status;
+  } finally {
+    process.stdout.write = origOut;
+    process.stderr.write = origErr;
+  }
+  return { status, stdout, stderr };
+}
+
+describe("rescue clone diagnostics", () => {
+  let workDir: string;
+  let hqRoot: string;
+
+  beforeAll(() => {
+    workDir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-rescue-clone-diagnostics-"));
+    hqRoot = path.join(workDir, "hq");
+    fs.mkdirSync(path.join(hqRoot, "companies"), { recursive: true });
+    fs.mkdirSync(path.join(hqRoot, "core"), { recursive: true });
+  });
+
+  afterAll(() => {
+    if (workDir) fs.rmSync(workDir, { recursive: true, force: true });
+  });
+
+  function envWithGit(name: string, script: string): NodeJS.ProcessEnv {
+    const shimDir = path.join(workDir, name);
+    fs.mkdirSync(shimDir, { recursive: true });
+    fs.writeFileSync(path.join(shimDir, "git"), script, { mode: 0o755 });
+    return {
+      ...process.env,
+      GH_TOKEN: "ghp_clone_secret_123",
+      PATH: `${shimDir}:${process.env.PATH ?? ""}`,
+    };
+  }
+
+  function rescueArgs(extra: string[] = []): string[] {
+    return [
+      "--hq-root", hqRoot,
+      "--source", "test/repo",
+      "--ref", "main",
+      "--dry-run",
+      "--yes",
+      "--no-backup",
+      ...extra,
+    ];
+  }
+
+  it("surfaces redacted stderr when the full-history clone fails", () => {
+    const env = envWithGit(
+      "full-history",
+      `#!/usr/bin/env bash
+printf 'fatal: clone args: %s\n' "$*" >&2
+printf 'mirror: https://user:url-secret@example.com/repo.git\n' >&2
+printf 'Authorization: Bearer header-secret\n' >&2
+exit 42
+`,
+    );
+
+    const r = runRescueCapture(rescueArgs(), env);
+
+    expect(r.status).toBe(5);
+    expect(r.stderr).toContain("fatal: clone args:");
+    expect(r.stderr).toContain("https://***@github.com/test/repo.git");
+    expect(r.stderr).toContain("mirror: https://***@example.com/repo.git");
+    expect(r.stderr).toContain("Authorization: ***");
+    expect(r.stderr).toContain("error: clone failed");
+    expect(r.stderr.indexOf("fatal: clone args:")).toBeLessThan(
+      r.stderr.indexOf("error: clone failed"),
+    );
+    expect(r.stderr).not.toContain("ghp_clone_secret_123");
+    expect(r.stderr).not.toContain("url-secret");
+    expect(r.stderr).not.toContain("header-secret");
+  });
+
+  it("surfaces stderr from the shallow attempt and stdout from the failed fallback", () => {
+    const env = envWithGit(
+      "shallow-fallback",
+      `#!/usr/bin/env bash
+if [ "$2" = "--depth" ]; then
+  printf 'fatal: shallow clone diagnostic\n' >&2
+  exit 41
+fi
+printf 'fatal: fallback clone diagnostic for %s\n' "$*"
+exit 42
+`,
+    );
+
+    const r = runRescueCapture(rescueArgs(["--no-history-check"]), env);
+
+    expect(r.status).toBe(5);
+    expect(r.stderr).toContain("fatal: shallow clone diagnostic");
+    expect(r.stderr).toContain("fatal: fallback clone diagnostic");
+    expect(r.stderr).toContain("https://***@github.com/test/repo.git");
+    expect(r.stderr).toContain("error: clone failed");
+    expect(r.stderr.indexOf("fatal: fallback clone diagnostic")).toBeLessThan(
+      r.stderr.indexOf("error: clone failed"),
+    );
+    expect(r.stderr).not.toContain("ghp_clone_secret_123");
+  });
+});

package/src/cli/rescue-core.ts

@@ -105,6 +105,14 @@ function run(
   };
 }
 
+function redactGitDiagnostic(output: string, ghToken: string): string {
+  let redacted = output;
+  if (ghToken) redacted = redacted.replaceAll(ghToken, "***");
+  return redacted
+    .replace(/\b([a-z][a-z0-9+.-]*:\/\/)[^\s/@]+(?::[^\s/@]*)?@/gi, "$1***@")
+    .replace(/(authorization\s*:\s*)[^\r\n]*/gi, "$1***");
+}
+
 /** `command -v <bin>` — is a binary on PATH? */
 function hasCmd(bin: string, env: NodeJS.ProcessEnv): boolean {
   const r = spawnSync(bin, ["--version"], { env, stdio: "ignore" });
@@ -551,29 +559,45 @@ function doRescue(
     cloneUrlDisplay = cloneUrl;
   }
 
+  const reportGitFailure = (result: ReturnType<typeof run>) => {
+    const diagnostic = result.stderr.trim() || result.stdout.trim();
+    if (diagnostic) err(`${redactGitDiagnostic(diagnostic, ghToken)}\n`);
+  };
+
   out("\n");
   if (cfg.historyCheck) {
     out(`==> Cloning ${cloneUrlDisplay} @${cfg.ref} (full history, blob:none filter) ...\n`);
-    if (run("git", ["clone", "--filter=blob:none", cloneUrl, srcDir], { env }).status !== 0) {
+    const cloneResult = run("git", ["clone", "--filter=blob:none", cloneUrl, srcDir], { env });
+    if (cloneResult.status !== 0) {
+      reportGitFailure(cloneResult);
       err("error: clone failed\n");
       throw new ExitError(5);
     }
-    if (run("git", ["checkout", cfg.ref], { cwd: srcDir, env }).status !== 0) {
+    const checkoutResult = run("git", ["checkout", cfg.ref], { cwd: srcDir, env });
+    if (checkoutResult.status !== 0) {
+      reportGitFailure(checkoutResult);
       err(`error: could not check out ref '${cfg.ref}' from ${cfg.sourceRepo}\n`);
       throw new ExitError(5);
     }
   } else {
     out(`==> Cloning ${cloneUrlDisplay} @${cfg.ref} (shallow) ...\n`);
-    if (
-      run("git", ["clone", "--depth", "1", "--branch", cfg.ref, cloneUrl, srcDir], { env })
-        .status !== 0
-    ) {
+    const shallowCloneResult = run(
+      "git",
+      ["clone", "--depth", "1", "--branch", cfg.ref, cloneUrl, srcDir],
+      { env },
+    );
+    if (shallowCloneResult.status !== 0) {
+      reportGitFailure(shallowCloneResult);
       out("    (shallow branch clone failed; trying full clone + checkout)\n");
-      if (run("git", ["clone", cloneUrl, srcDir], { env }).status !== 0) {
+      const cloneResult = run("git", ["clone", cloneUrl, srcDir], { env });
+      if (cloneResult.status !== 0) {
+        reportGitFailure(cloneResult);
         err("error: clone failed\n");
         throw new ExitError(5);
       }
-      if (run("git", ["checkout", cfg.ref], { cwd: srcDir, env }).status !== 0) {
+      const checkoutResult = run("git", ["checkout", cfg.ref], { cwd: srcDir, env });
+      if (checkoutResult.status !== 0) {
+        reportGitFailure(checkoutResult);
         err(`error: could not check out ref '${cfg.ref}' from ${cfg.sourceRepo}\n`);
         throw new ExitError(5);
       }

package/src/cli/share.test.ts

@@ -684,6 +684,53 @@ describe("share", () => {
     expect(result.filesUploaded).toBe(0);
   });
 
+  it("fresh-install SSE-KMS etag: byte-identical remote is reconciled without a conflict", async () => {
+    const companyRoot = path.join(tmpDir, "companies", "acme");
+    fs.mkdirSync(companyRoot, { recursive: true });
+    const testFile = path.join(companyRoot, "kms-scaffold.md");
+    const scaffoldBytes = "identical-content-encrypted-with-sse-kms";
+    fs.writeFileSync(testFile, scaffoldBytes);
+
+    // A 32-hex SSE-KMS ETag is not the MD5 of the plaintext object.
+    vi.mocked(headRemoteFile).mockResolvedValueOnce({
+      lastModified: new Date(),
+      etag: '"288bfa91684ae21f9ae27c061254d412"',
+      size: scaffoldBytes.length,
+    });
+    vi.mocked(downloadFile).mockImplementationOnce(async (_ctx, _key, dest) => {
+      fs.writeFileSync(dest as string, scaffoldBytes);
+      return undefined as never;
+    });
+
+    const events: unknown[] = [];
+    const result = await share({
+      paths: [testFile],
+      company: "acme",
+      vaultConfig: mockConfig,
+      hqRoot: tmpDir,
+      onConflict: "keep",
+      onEvent: (e) => events.push(e),
+    });
+
+    expect(result.conflictPaths).toEqual([]);
+    expect(result.filesUploaded).toBe(0);
+    expect(uploadFile).not.toHaveBeenCalled();
+    expect(events).toContainEqual({
+      type: "reconciled",
+      path: "kms-scaffold.md",
+      direction: "push",
+    });
+    expect(fs.readdirSync(companyRoot).filter((name) => name.includes(".conflict-"))).toEqual([]);
+
+    const journal = JSON.parse(
+      fs.readFileSync(path.join(stateDir, "sync-journal.acme.json"), "utf-8"),
+    ) as { files: Record<string, { direction: string; remoteEtag?: string }> };
+    expect(journal.files["kms-scaffold.md"]).toMatchObject({
+      direction: "up",
+      remoteEtag: "288bfa91684ae21f9ae27c061254d412",
+    });
+  });
+
   it("fresh-install multipart collision: byte-identical remote is NOT a conflict (reconciled, no mirror)", async () => {
     // Root cause of "HQ installs with conflicts": on a first push the
     // journal is empty, so the fresh-collision branch decides conflict-vs-

package/src/cli/share.ts

@@ -70,11 +70,11 @@ import { isCloudAuthoritative } from "../lib/cloud-authoritative.js";
  * Push-side fresh-collision convergence probe.
  *
  * For a first push (no journal entry) where the remote object already
- * exists AND was multipart-uploaded, the remote etag (`<md5>-<partCount>`)
- * is not a content hash, so we cannot tell "byte-identical" from "genuine
- * divergence" without looking at the bytes. Fetch the remote object once to
- * a throwaway temp file, hash it the same symlink-aware way the planner
- * hashed local, and report whether the two contents DIFFER.
+ * exists, its etag is a version token rather than a reliable content hash,
+ * so we cannot tell "byte-identical" from "genuine divergence" without
+ * looking at the bytes. Fetch the remote object once to a throwaway temp
+ * file, hash it the same symlink-aware way the planner hashed local, and
+ * report whether the two contents DIFFER.
  *
  * Returns `true` on a genuine difference (a real fresh collision) and
  * `false` when the bytes are identical. Fails safe to `true` on any
@@ -1252,34 +1252,24 @@ async function executeUploads(
       const remoteChanged = !!journalEntry && hasRemoteChanged(remoteMeta, journalEntry);
 
       let isFreshCollision = false;
-      let multipartConverged = false;
+      let freshContentConverged = false;
       if (!journalEntry && item.kind === "symlink") {
         isFreshCollision = true;
       } else if (!journalEntry && item.kind === "file") {
-        const remoteEtagNormalized = normalizeEtag(remoteMeta.etag);
-        const isMultipart = /-\d+$/.test(remoteEtagNormalized);
-        if (!isMultipart) {
-          const localBody = fs.readFileSync(absolutePath);
-          const localMd5 = crypto.createHash("md5").update(localBody).digest("hex");
-          if (localMd5 !== remoteEtagNormalized) {
-            isFreshCollision = true;
-          }
+        const remoteDiffers = await remoteContentDiffers(
+          run.ctx,
+          relativePath,
+          localHash,
+          run.hqRoot,
+        );
+        if (remoteDiffers) {
+          isFreshCollision = true;
         } else {
-          const remoteDiffers = await remoteContentDiffers(
-            run.ctx,
-            relativePath,
-            localHash,
-            run.hqRoot,
-          );
-          if (remoteDiffers) {
-            isFreshCollision = true;
-          } else {
-            multipartConverged = true;
-          }
+          freshContentConverged = true;
         }
       }
 
-      if (multipartConverged) {
+      if (freshContentConverged) {
         const lstat = fs.lstatSync(absolutePath);
         updateEntry(
           run.journal,

package/src/cli/sync.test.ts

@@ -3518,6 +3518,17 @@ describe("reportNewFilesToNotify chunking (server cap = 1000 files/report)", ()
     (fetchMock.mock.calls as Array<[string, RequestInit?]>)
       .filter(([u]) => String(u).includes("/v1/notify/file-added"))
       .map(([, init]) => JSON.parse(String(init!.body)).files.length);
+  const notificationTelemetryEvents = (
+    fetchMock: ReturnType<typeof vi.fn>,
+  ): Array<{ eventName: string; properties?: Record<string, unknown> }> =>
+    (fetchMock.mock.calls as Array<[string, RequestInit?]>)
+      .filter(([u]) => String(u).includes("/v1/telemetry/events"))
+      .flatMap(([, init]) =>
+        JSON.parse(String(init!.body)).events as Array<{
+          eventName: string;
+          properties?: Record<string, unknown>;
+        }>,
+      );
 
   afterEach(() => {
     vi.unstubAllGlobals();
@@ -3580,6 +3591,85 @@ describe("reportNewFilesToNotify chunking (server cap = 1000 files/report)", ()
     expect(notifyBatchSizes(fetchMock)).toEqual([1000, 1000, 1]);
   });
 
+  it("does not emit notification telemetry after a successful report", async () => {
+    const fetchMock = vi.fn().mockImplementation(async (url: string) => {
+      if (url.includes("/v1/notify/file-added")) {
+        return { ok: true, status: 200, text: async () => "" };
+      }
+      return {
+        ok: true,
+        status: 200,
+        text: async () => JSON.stringify({ ok: true, written: 1, skipped: [] }),
+      };
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    await reportNewFilesToNotify(cfg, "cmp_X", "acme", mkFiles(1));
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(notificationTelemetryEvents(fetchMock)).toEqual([]);
+  });
+
+  it("emits failure telemetry for a non-successful notification response", async () => {
+    const fetchMock = vi.fn().mockImplementation(async (url: string) => {
+      if (url.includes("/v1/notify/file-added")) {
+        return { ok: false, status: 503, text: async () => "unavailable" };
+      }
+      return {
+        ok: true,
+        status: 200,
+        text: async () => JSON.stringify({ ok: true, written: 1, skipped: [] }),
+      };
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    await reportNewFilesToNotify(cfg, "cmp_X", "acme", mkFiles(1));
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(notificationTelemetryEvents(fetchMock)).toEqual([
+      expect.objectContaining({
+        eventName: "new_files_notification_reported",
+        properties: {
+          status: "failure",
+          fileCount: 1,
+          batchIndex: 1,
+          batchCount: 1,
+          statusCode: 503,
+        },
+      }),
+    ]);
+  });
+
+  it("emits error-class telemetry when notification reporting throws", async () => {
+    const fetchMock = vi.fn().mockImplementation(async (url: string) => {
+      if (url.includes("/v1/notify/file-added")) {
+        throw new TypeError("network down");
+      }
+      return {
+        ok: true,
+        status: 200,
+        text: async () => JSON.stringify({ ok: true, written: 1, skipped: [] }),
+      };
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    await reportNewFilesToNotify(cfg, "cmp_X", "acme", mkFiles(1));
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(notificationTelemetryEvents(fetchMock)).toEqual([
+      expect.objectContaining({
+        eventName: "new_files_notification_reported",
+        properties: {
+          status: "failure",
+          fileCount: 1,
+          batchIndex: 1,
+          batchCount: 1,
+          errorClass: "TypeError",
+        },
+      }),
+    ]);
+  });
+
   it("no request at all when there are no new files", async () => {
     const fetchMock = vi.fn().mockResolvedValue({ ok: true, status: 200, text: async () => "" });
     vi.stubGlobal("fetch", fetchMock);