@indigoai-us/hq-cloud 6.15.0 → 6.15.2

package/src/cli/rescue-drift-reconcile.test.ts

@@ -1,179 +0,0 @@
-/**
- * Integration test for the rescue convergence guard in src/cli/rescue-core.ts.
- *
- * Regression for the false `.drift-*` litter: in `history_floor` mode the
- * rescue overlay flags a scaffold file as USER-EDIT whenever its blob differs
- * from the *old* baseline (floor). HQ's own Stop hooks rewrite scaffold files
- * every session, so a file routinely drifts from the floor yet lands
- * byte-for-byte identical to the *new* upstream HEAD the overlay is about to
- * write — and the old code rescued it into personal/ with a redundant
- * `.drift-<ts>-<pid>` copy. The guard reclassifies "drifted from floor but
- * identical to upstream HEAD" as UNCHANGED (no rescue).
- *
- * The rescue clones its source from GitHub, so we shim `git clone` to clone a
- * local fixture repo instead. Everything runs under --dry-run (no destructive
- * ops, no backup) and we assert the classification the rescue reports.
- */
-import { describe, it, expect, beforeAll, afterAll } from "vitest";
-import { execFileSync } from "child_process";
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { runRescue } from "./rescue-core.js";
-
-function hasGit(): boolean {
-  try {
-    execFileSync("git", ["--version"], { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-const gitAvailable = hasGit();
-
-/** Run the rescue in-process, capturing its stdout/stderr. */
-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.skipIf(!gitAvailable)("rescue drift convergence guard", () => {
-  let workDir: string;
-  let upstream: string;
-  let hqRoot: string;
-  let shimDir: string;
-  let floorSha: string;
-  let env: NodeJS.ProcessEnv;
-
-  const git = (cwd: string, ...args: string[]) =>
-    execFileSync("git", args, {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: {
-        ...process.env,
-        GIT_AUTHOR_NAME: "t",
-        GIT_AUTHOR_EMAIL: "t@t",
-        GIT_COMMITTER_NAME: "t",
-        GIT_COMMITTER_EMAIL: "t@t",
-      },
-    })
-      .toString()
-      .trim();
-
-  beforeAll(() => {
-    workDir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-rescue-drift-"));
-
-    // --- Build a local "upstream" repo: floor commit, then a HEAD commit
-    //     where core/x.md changed (v1 -> v2) and the others stayed put. ---
-    upstream = path.join(workDir, "upstream");
-    fs.mkdirSync(path.join(upstream, "core"), { recursive: true });
-    git(workDir, "init", "-b", "main", "upstream");
-    fs.writeFileSync(path.join(upstream, "core/x.md"), "v1\n");
-    fs.writeFileSync(path.join(upstream, "core/edited.md"), "base\n");
-    fs.writeFileSync(path.join(upstream, "core/keep.md"), "same\n");
-    git(upstream, "add", "-A");
-    git(upstream, "commit", "-m", "floor");
-    floorSha = git(upstream, "rev-parse", "HEAD");
-    // HEAD: only x.md advances.
-    fs.writeFileSync(path.join(upstream, "core/x.md"), "v2\n");
-    git(upstream, "add", "-A");
-    git(upstream, "commit", "-m", "head");
-
-    // --- Build the local HQ root being rescued. ---
-    hqRoot = path.join(workDir, "hq");
-    fs.mkdirSync(path.join(hqRoot, "core"), { recursive: true });
-    // `companies/` + `personal/` make it "look like" an HQ root (script guard);
-    // both are preserved (never walked).
-    fs.mkdirSync(path.join(hqRoot, "personal"), { recursive: true });
-    fs.mkdirSync(path.join(hqRoot, "companies"), { recursive: true });
-    // Drifted from floor ("v1") but byte-identical to upstream HEAD ("v2").
-    // OLD behavior: rescued to personal/x.md (+ .drift on collision).
-    // NEW behavior: reconciled as UNCHANGED — no rescue.
-    fs.writeFileSync(path.join(hqRoot, "core/x.md"), "v2\n");
-    // Genuinely user-edited: differs from both floor and HEAD -> still rescued.
-    fs.writeFileSync(path.join(hqRoot, "core/edited.md"), "MINE\n");
-    // Untouched vs floor -> UNCHANGED.
-    fs.writeFileSync(path.join(hqRoot, "core/keep.md"), "same\n");
-
-    // --- git shim: rewrite `git clone <github-url> dest` to the local fixture. ---
-    // Resolve the real git BEFORE the shim is on PATH so we don't recurse.
-    const realGit = execFileSync("bash", ["-lc", "command -v git"]).toString().trim() || "/usr/bin/git";
-    shimDir = path.join(workDir, "shim");
-    fs.mkdirSync(shimDir, { recursive: true });
-    const shim = `#!/usr/bin/env bash
-if [ "$1" = "clone" ]; then
-  args=()
-  for a in "$@"; do
-    case "$a" in
-      https://github.com/*) a=${JSON.stringify(upstream)} ;;
-    esac
-    args+=("$a")
-  done
-  exec ${JSON.stringify(realGit)} "\${args[@]}"
-fi
-exec ${JSON.stringify(realGit)} "$@"
-`;
-    fs.writeFileSync(path.join(shimDir, "git"), shim, { mode: 0o755 });
-
-    env = { ...process.env, PATH: `${shimDir}:${process.env.PATH ?? ""}` };
-  });
-
-  afterAll(() => {
-    if (workDir) fs.rmSync(workDir, { recursive: true, force: true });
-  });
-
-  function runRescueDry() {
-    return runRescueCapture(
-      [
-        "--hq-root", hqRoot,
-        "--source", "test/repo",
-        "--ref", "main",
-        "--floor-sha", floorSha,
-        "--dry-run",
-        "--yes",
-        "--no-backup",
-      ],
-      env,
-    );
-  }
-
-  it("reconciles a floor-drifted file that is identical to upstream HEAD (no rescue)", () => {
-    const r = runRescueDry();
-    const out = `${r.stdout}\n${r.stderr}`;
-    // Sanity: ran in history_floor mode against our floor.
-    expect(r.status, out).toBe(0);
-    expect(out).toContain(`Baseline: ${floorSha}`);
-
-    // The drifted-but-identical-to-HEAD file is reconciled, NOT rescued.
-    expect(out).toContain("drift reconciled (identical to upstream HEAD; no rescue): core/x.md");
-    expect(out).not.toMatch(/user-edit \(rescue\): core\/x\.md/);
-
-    // The genuinely-edited file is still rescued into personal/.
-    expect(out).toContain("user-edit (rescue): core/edited.md  ->  personal/edited.md");
-
-    // Untouched file classified UNCHANGED.
-    expect(out).toContain("unchanged (preserved in place): core/keep.md");
-
-    // Summary reflects exactly one reconcile.
-    expect(out).toMatch(/drift reconciled \(== upstream\):\s+1 files/);
-  });
-});

package/src/cli/rescue-drop-dir-symlink.test.ts

@@ -1,224 +0,0 @@
-/**
- * Regression for the rescue "drop reindex symlink" fix in
- * src/cli/rescue-core.ts (dropReindexSymlink).
- *
- * The bug: the apply step removed a reindex overlay symlink with
- * `fs.rmSync(localPath, { force: true })`. `rmSync` stat-FOLLOWS on some
- * platforms (notably macOS), so a symlink whose target is a directory — e.g.
- * core/knowledge/ad-creative-engine -> personal/knowledge/ad-creative-engine —
- * is seen as a directory and, with `recursive` unset, throws `EISDIR`
- * ("Path is a directory"). During a rescue apply that abort rolls back the
- * whole update, so /update-hq fails on any install carrying a directory-target
- * overlay symlink. The fix removes the link with lstat + unlink semantics
- * (`fs.unlinkSync`), which drops the link itself regardless of what it points
- * at and never recurses into the target.
- *
- * The macOS `rmSync` follow-behavior is not reproducible with a plain path on
- * Linux CI, so we reproduce it deterministically: `fs` is mocked so `rmSync`
- * throws `EISDIR` on exactly a directory-target symlink (every other call is
- * delegated to the real implementation). Under that fault the OLD code aborts
- * the apply and rolls the whole update back; the fixed code drops the link with
- * `unlinkSync` and the rescue still succeeds.
- *
- * Mirrors rescue-mtime-preserve.test.ts: shim `git clone` to a local fixture
- * and run the real rescue (non-dry-run, --no-backup) so the overlay lays files
- * down and the symlink-drop action really runs.
- */
-import { describe, it, expect, beforeAll, afterAll, vi } from "vitest";
-import { execFileSync } from "child_process";
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { runRescue } from "./rescue-core.js";
-
-// Simulate the reporter's platform (macOS): fs.rmSync stat-follows a
-// symlink-to-directory and throws EISDIR ("Path is a directory"). Only the
-// dir-target symlink trips this; every other rmSync call — and every other fs
-// function — is the real implementation, so clone/overlay/backup all work.
-vi.mock("fs", async (importOriginal) => {
-  const real = await importOriginal<typeof import("fs")>();
-  const patchedRmSync: typeof real.rmSync = ((p: fs.PathLike, opts?: fs.RmOptions) => {
-    try {
-      const lst = real.lstatSync(p as fs.PathLike);
-      if (lst.isSymbolicLink() && real.statSync(p as fs.PathLike).isDirectory()) {
-        const err = new Error(
-          `EISDIR: illegal operation on a directory, Path is a directory: ${String(p)}`,
-        ) as NodeJS.ErrnoException;
-        err.code = "ERR_FS_EISDIR";
-        throw err;
-      }
-    } catch (e) {
-      if ((e as NodeJS.ErrnoException).code === "ERR_FS_EISDIR") throw e;
-      // lstat/stat failed (missing path / broken link) — fall through to real rm.
-    }
-    return real.rmSync(p, opts);
-  }) as typeof real.rmSync;
-  return { ...real, rmSync: patchedRmSync };
-});
-
-function has(bin: string, ...args: string[]): boolean {
-  try {
-    execFileSync(bin, args, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-const toolsAvailable = has("git", "--version") && has("rsync", "--version");
-
-const EPOCH = 1609459200; // 2021-01-01T00:00:00Z
-
-/** Run the rescue in-process, capturing its stdout/stderr. */
-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.skipIf(!toolsAvailable)("rescue drops directory-target reindex symlinks", () => {
-  let workDir: string;
-  let upstream: string;
-  let shimDir: string;
-  let floorSha: string;
-  let env: NodeJS.ProcessEnv;
-
-  const gitAt = (cwd: string, ...args: string[]) =>
-    execFileSync("git", args, {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: {
-        ...process.env,
-        GIT_AUTHOR_NAME: "t",
-        GIT_AUTHOR_EMAIL: "t@t",
-        GIT_COMMITTER_NAME: "t",
-        GIT_COMMITTER_EMAIL: "t@t",
-        GIT_AUTHOR_DATE: `${EPOCH} +0000`,
-        GIT_COMMITTER_DATE: `${EPOCH} +0000`,
-      },
-    })
-      .toString()
-      .trim();
-
-  beforeAll(() => {
-    workDir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-rescue-dirsymlink-"));
-
-    // --- "upstream" repo: a single core/ file so the wipe set includes core/ --
-    upstream = path.join(workDir, "upstream");
-    fs.mkdirSync(path.join(upstream, "core/knowledge"), { recursive: true });
-    gitAt(workDir, "init", "-b", "main", "upstream");
-    fs.writeFileSync(path.join(upstream, "core/knowledge/README.md"), "shipped\n");
-    gitAt(upstream, "add", "-A");
-    gitAt(upstream, "commit", "-m", "floor");
-    floorSha = gitAt(upstream, "rev-parse", "HEAD");
-
-    // --- git shim: redirect `git clone <github-url>` to the local fixture -----
-    const realGit =
-      execFileSync("bash", ["-lc", "command -v git"]).toString().trim() || "/usr/bin/git";
-    shimDir = path.join(workDir, "shim");
-    fs.mkdirSync(shimDir, { recursive: true });
-    const shim = `#!/usr/bin/env bash
-if [ "$1" = "clone" ]; then
-  args=()
-  for a in "$@"; do
-    case "$a" in
-      https://github.com/*) a=${JSON.stringify(upstream)} ;;
-    esac
-    args+=("$a")
-  done
-  exec ${JSON.stringify(realGit)} "\${args[@]}"
-fi
-exec ${JSON.stringify(realGit)} "$@"
-`;
-    fs.writeFileSync(path.join(shimDir, "git"), shim, { mode: 0o755 });
-    env = { ...process.env, PATH: `${shimDir}:${process.env.PATH ?? ""}` };
-  });
-
-  afterAll(() => {
-    if (workDir) fs.rmSync(workDir, { recursive: true, force: true });
-  });
-
-  /**
-   * Build a fresh local HQ root carrying a directory-target reindex symlink
-   * (core/knowledge/ad-creative-engine -> <hqRoot>/personal/knowledge/ad-creative-engine),
-   * whose target directory holds a sentinel file that must survive the drop.
-   */
-  function makeHqRoot(): { hqRoot: string; link: string; targetDir: string; sentinel: string } {
-    const hqRoot = fs.mkdtempSync(path.join(workDir, "hq-"));
-    // HQ-root shape check: companies/ + one of .claude/|core/|personal/.
-    fs.mkdirSync(path.join(hqRoot, "companies"), { recursive: true });
-    fs.mkdirSync(path.join(hqRoot, "core/knowledge"), { recursive: true });
-    // Unchanged vs upstream so the overlay is a no-op for it.
-    fs.writeFileSync(path.join(hqRoot, "core/knowledge/README.md"), "shipped\n");
-
-    const targetDir = path.join(hqRoot, "personal/knowledge/ad-creative-engine");
-    fs.mkdirSync(targetDir, { recursive: true });
-    const sentinel = path.join(targetDir, "brief.md");
-    fs.writeFileSync(sentinel, "authored locally\n");
-
-    const link = path.join(hqRoot, "core/knowledge/ad-creative-engine");
-    // Absolute target that includes "/personal/" — matches the overlay
-    // convention masterSyncSymlinkTarget() recognizes.
-    fs.symlinkSync(targetDir, link);
-
-    return { hqRoot, link, targetDir, sentinel };
-  }
-
-  function rescueArgs(hqRoot: string): string[] {
-    return [
-      "--hq-root", hqRoot,
-      "--source", "test/repo",
-      "--ref", "main",
-      "--floor-sha", floorSha,
-      "--yes",
-      "--no-backup",
-    ];
-  }
-
-  it("sanity: the mocked rmSync reproduces the macOS EISDIR on a dir-target symlink", () => {
-    const { link, targetDir, sentinel } = makeHqRoot();
-    // The old apply path used exactly this call — it must throw under the fault.
-    expect(() => fs.rmSync(link, { force: true })).toThrow(/Path is a directory/);
-    // ...and the fixed path (unlink) removes the link while sparing the target.
-    fs.unlinkSync(link);
-    expect(fs.existsSync(link)).toBe(false);
-    expect(fs.existsSync(targetDir)).toBe(true);
-    expect(fs.readFileSync(sentinel, "utf-8")).toBe("authored locally\n");
-  });
-
-  it("does not abort the apply on a directory-target symlink (drops it, spares the target)", () => {
-    const { hqRoot, link, targetDir, sentinel } = makeHqRoot();
-
-    const r = runRescueCapture(rescueArgs(hqRoot), env);
-
-    // The apply must survive the simulated-macOS rmSync fault: the fix removes
-    // the link with unlink semantics, so the whole update no longer rolls back.
-    // (The old rmSync-based drop throws EISDIR here → non-zero + rollback.)
-    if (r.status !== 0) {
-      throw new Error(`rescue aborted on the dir-target symlink (${r.status}):\n${r.stdout}\n${r.stderr}`);
-    }
-
-    // The link itself is gone (reindex.sh re-lays it later)...
-    expect(fs.existsSync(link)).toBe(false);
-    // ...but the target directory and its contents are untouched — the drop
-    // must never follow/recurse into the target.
-    expect(fs.existsSync(targetDir)).toBe(true);
-    expect(fs.readFileSync(sentinel, "utf-8")).toBe("authored locally\n");
-  });
-});

package/src/cli/rescue-exec-bit-preserve.test.ts

@@ -1,187 +0,0 @@
-/**
- * Regression for the rescue executable-bit guarantee in src/cli/rescue-core.ts
- * (restoreShebangExecBits).
- *
- * rescue rebuilds the tree with `git clone` + `rsync -a`, which faithfully
- * propagates the upstream git tree mode. So a script committed upstream WITHOUT
- * its executable bit (a `.sh` checked in as 100644) is delivered non-executable
- * to every machine -- and a hook the runtime exec's directly then fails with
- * "Permission denied". After the overlay, rescue restores +x on any shipped
- * file that begins with a `#!` shebang (and leaves non-shebang files alone).
- *
- * Mirrors rescue-mtime-preserve.test.ts: shim `git clone` to a local fixture
- * and run the real rescue (non-dry-run, --no-backup) so the overlay lays files
- * down for real.
- */
-import { describe, it, expect, beforeAll, afterAll } from "vitest";
-import { execFileSync } from "child_process";
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { runRescue } from "./rescue-core.js";
-
-function has(bin: string, ...args: string[]): boolean {
-  try {
-    execFileSync(bin, args, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-const toolsAvailable = has("git", "--version") && has("rsync", "--version");
-
-const FLOOR_EPOCH = 1577836800; // 2020-01-01
-const HEAD_EPOCH = 1609459200; // 2021-01-01
-
-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.skipIf(!toolsAvailable)("rescue restores +x on shipped shebang scripts", () => {
-  let workDir: string;
-  let upstream: string;
-  let hqRoot: string;
-  let shimDir: string;
-  let floorSha: string;
-  let env: NodeJS.ProcessEnv;
-
-  const gitAt = (cwd: string, epoch: number, ...args: string[]) =>
-    execFileSync("git", args, {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: {
-        ...process.env,
-        GIT_AUTHOR_NAME: "t",
-        GIT_AUTHOR_EMAIL: "t@t",
-        GIT_COMMITTER_NAME: "t",
-        GIT_COMMITTER_EMAIL: "t@t",
-        GIT_AUTHOR_DATE: `${epoch} +0000`,
-        GIT_COMMITTER_DATE: `${epoch} +0000`,
-      },
-    })
-      .toString()
-      .trim();
-
-  const isExec = (p: string) => (fs.statSync(p).mode & 0o111) !== 0;
-  const mode = (p: string) => fs.statSync(p).mode & 0o777;
-
-  beforeAll(() => {
-    workDir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-rescue-exec-"));
-
-    // --- "upstream" repo ----------------------------------------------------
-    upstream = path.join(workDir, "upstream");
-    fs.mkdirSync(path.join(upstream, "core/scripts"), { recursive: true });
-    fs.mkdirSync(path.join(upstream, "core/docs"), { recursive: true });
-    gitAt(workDir, FLOOR_EPOCH, "init", "-b", "main", "upstream");
-
-    // Shebang script committed WITHOUT +x (the bug: arrives non-executable).
-    const needs = path.join(upstream, "core/scripts/needs-exec.sh");
-    fs.writeFileSync(needs, "#!/bin/bash\necho needs\n", { mode: 0o644 });
-    fs.chmodSync(needs, 0o644);
-    // Shebang script committed WITH +x (control: rsync -a already preserves it).
-    const already = path.join(upstream, "core/scripts/already-exec.sh");
-    fs.writeFileSync(already, "#!/bin/bash\necho already\n");
-    fs.chmodSync(already, 0o755);
-    // Non-shebang data file (control: must NOT be made executable).
-    fs.writeFileSync(path.join(upstream, "core/docs/note.md"), "# note\n", { mode: 0o644 });
-
-    gitAt(upstream, FLOOR_EPOCH, "add", "-A");
-    gitAt(upstream, FLOOR_EPOCH, "commit", "-m", "floor");
-    floorSha = gitAt(upstream, FLOOR_EPOCH, "rev-parse", "HEAD");
-    // A second commit so floor != HEAD (mirrors the mtime fixture).
-    fs.writeFileSync(path.join(upstream, "core/docs/head.md"), "head\n");
-    gitAt(upstream, HEAD_EPOCH, "add", "-A");
-    gitAt(upstream, HEAD_EPOCH, "commit", "-m", "head");
-
-    // Confirm the fixture actually stored the intended tree modes.
-    const lsFloor = gitAt(upstream, HEAD_EPOCH, "ls-tree", "-r", "HEAD");
-    if (!/100644\s+blob\s+\S+\s+core\/scripts\/needs-exec\.sh/.test(lsFloor)) {
-      throw new Error(`fixture needs-exec.sh not stored as 100644:\n${lsFloor}`);
-    }
-    if (!/100755\s+blob\s+\S+\s+core\/scripts\/already-exec\.sh/.test(lsFloor)) {
-      throw new Error(`fixture already-exec.sh not stored as 100755:\n${lsFloor}`);
-    }
-
-    // --- local HQ root being rescued (fresh; upstream files are brand-new) --
-    hqRoot = path.join(workDir, "hq");
-    fs.mkdirSync(path.join(hqRoot, "core"), { recursive: true });
-    fs.mkdirSync(path.join(hqRoot, "personal"), { recursive: true });
-    fs.mkdirSync(path.join(hqRoot, "companies"), { recursive: true });
-
-    // --- git shim: redirect `git clone <github-url>` to the local fixture ---
-    const realGit = execFileSync("bash", ["-lc", "command -v git"]).toString().trim() || "/usr/bin/git";
-    shimDir = path.join(workDir, "shim");
-    fs.mkdirSync(shimDir, { recursive: true });
-    const shim = `#!/usr/bin/env bash
-if [ "$1" = "clone" ]; then
-  args=()
-  for a in "$@"; do
-    case "$a" in
-      https://github.com/*) a=${JSON.stringify(upstream)} ;;
-    esac
-    args+=("$a")
-  done
-  exec ${JSON.stringify(realGit)} "\${args[@]}"
-fi
-exec ${JSON.stringify(realGit)} "$@"
-`;
-    fs.writeFileSync(path.join(shimDir, "git"), shim, { mode: 0o755 });
-    env = { ...process.env, PATH: `${shimDir}:${process.env.PATH ?? ""}` };
-
-    const r = runRescueCapture(
-      [
-        "--hq-root", hqRoot,
-        "--source", "test/repo",
-        "--ref", "main",
-        "--floor-sha", floorSha,
-        "--yes",
-        "--no-backup",
-      ],
-      env,
-    );
-    if (r.status !== 0) {
-      throw new Error(`rescue failed (${r.status}):\n${r.stdout}\n${r.stderr}`);
-    }
-  });
-
-  afterAll(() => {
-    if (workDir) fs.rmSync(workDir, { recursive: true, force: true });
-  });
-
-  it("restores +x on a shebang script shipped as 0644 (the bug)", () => {
-    const f = path.join(hqRoot, "core/scripts/needs-exec.sh");
-    expect(fs.readFileSync(f, "utf-8")).toBe("#!/bin/bash\necho needs\n");
-    expect(isExec(f)).toBe(true);
-    expect(mode(f)).toBe(0o755); // 0644 + (read-bits -> exec-bits)
-  });
-
-  it("leaves an already-executable shebang script executable", () => {
-    const f = path.join(hqRoot, "core/scripts/already-exec.sh");
-    expect(isExec(f)).toBe(true);
-  });
-
-  it("never makes a non-shebang data file executable", () => {
-    const f = path.join(hqRoot, "core/docs/note.md");
-    expect(fs.existsSync(f)).toBe(true);
-    expect(isExec(f)).toBe(false);
-  });
-});