@golba98/codexa 1.0.2 → 1.0.3

package/src/core/terminal/terminalTitle.test.ts

@@ -1,328 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  acquireTerminalTitleGuard,
-  buildTerminalTitleSequence,
-  computeTerminalTitle,
-  deriveTerminalTitle,
-  formatTerminalTitleLabel,
-  getIntendedTerminalTitle,
-  normalizeTerminalTitle,
-  reassertTerminalTitle,
-  reassertIntendedTerminalTitle,
-  sanitizeTerminalTitle,
-  setIntendedTerminalTitle,
-  setTerminalTitle,
-  startTerminalTitleStartupGuard,
-  beginColdStartSequence,
-  createTerminalTitleSequenceStripper,
-  stripTerminalTitleSequences,
-  stripTerminalTitleSequencesFromChunk,
-  traceTerminalTitleSequences,
-  writeCodexaTerminalTitle,
-  writeGuardedTerminalOutput,
-  __resetTerminalTitleCache,
-} from "./terminalTitle.js";
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-test("buildTerminalTitleSequence emits OSC 0 and OSC 2 with sanitized title text", () => {
-  const sequence = buildTerminalTitleSequence("Codexa\u0007!");
-  assert.equal(sequence, "\x1b]0;Codexa !\x07\x1b]2;Codexa !\x07");
-  assert.equal(sanitizeTerminalTitle("  Codexa  "), "Codexa");
-});
-
-test("title normalization never exposes raw Windows paths", () => {
-  assert.equal(normalizeTerminalTitle("C:\\WINDOWS\\system"), "Codexa");
-  assert.equal(normalizeTerminalTitle("c:/Users/example"), "Codexa");
-  assert.equal(normalizeTerminalTitle("\\\\server\\share"), "Codexa");
-  assert.equal(buildTerminalTitleSequence("C:\\WINDOWS\\system"), buildTerminalTitleSequence("Codexa"));
-});
-
-test("stripTerminalTitleSequences removes OSC 0 title sequences with BEL terminator", () => {
-  assert.equal(
-    stripTerminalTitleSequences("hello\x1b]0;C:\\WINDOWS\\system\x07world"),
-    "helloworld",
-  );
-});
-
-test("stripTerminalTitleSequences removes OSC 2 title sequences with BEL terminator", () => {
-  assert.equal(
-    stripTerminalTitleSequences("hello\x1b]2;Codex\x07world"),
-    "helloworld",
-  );
-});
-
-test("stripTerminalTitleSequences preserves normal ANSI SGR colour sequences", () => {
-  const input = "\x1b[31mred\x1b[0m";
-  assert.equal(stripTerminalTitleSequences(input), input);
-});
-
-test("stripTerminalTitleSequences removes title OSC from mixed output while preserving SGR", () => {
-  assert.equal(
-    stripTerminalTitleSequences("start\x1b]0;C:\\WINDOWS\\system\x07middle\x1b[32mok\x1b[0mend"),
-    "startmiddle\x1b[32mok\x1b[0mend",
-  );
-});
-
-test("stripTerminalTitleSequences removes OSC title sequences with ST terminator", () => {
-  assert.equal(
-    stripTerminalTitleSequences("hello\x1b]0;C:\\WINDOWS\\system\x1b\\world"),
-    "helloworld",
-  );
-});
-
-test("stripTerminalTitleSequencesFromChunk handles Buffer input", () => {
-  assert.equal(
-    stripTerminalTitleSequencesFromChunk(Buffer.from("hello\x1b]0;C:\\WINDOWS\\system\x07world", "utf8")),
-    "helloworld",
-  );
-});
-
-test("createTerminalTitleSequenceStripper removes title sequences split across chunks", () => {
-  const stripper = createTerminalTitleSequenceStripper({
-    source: "test",
-    stream: "stdout",
-    origin: "child",
-  });
-
-  assert.equal(stripper.process("hello\x1b]0;C:\\WINDOWS"), "hello");
-  assert.equal(stripper.process("\\system\x07world"), "world");
-  assert.equal(stripper.flush(), "");
-});
-
-test("formatTerminalTitleLabel follows the workspace leaf and app-name rules", () => {
-  assert.equal(
-    formatTerminalTitleLabel("C:\\Development\\1-JavaScript\\13-Custom-CLI-Normal", "dir"),
-    "13-Custom-CLI-Normal",
-  );
-  assert.equal(
-    formatTerminalTitleLabel("C:\\Development\\1-JavaScript\\13-Custom-CLI-Normal", "name"),
-    "Codexa",
-  );
-  assert.equal(
-    formatTerminalTitleLabel("C:\\Development\\1-JavaScript\\13-Custom-CLI-Normal", "simple"),
-    "Codexa",
-  );
-});
-
-test("deriveTerminalTitle follows terminal title mode on startup", () => {
-  const workspaceRoot = "C:\\Development\\1-JavaScript\\13-Custom-CLI-Normal";
-
-  assert.equal(deriveTerminalTitle(workspaceRoot, "dir"), "13-Custom-CLI-Normal");
-  assert.equal(deriveTerminalTitle(workspaceRoot, "name"), "Codexa");
-  assert.equal(deriveTerminalTitle(workspaceRoot, "simple"), "Codexa");
-});
-
-test("computeTerminalTitle follows the requested mapping", () => {
-  const workspaceName = "13-Custom-CLI-Normal";
-  assert.equal(computeTerminalTitle({ terminalTitleMode: "dir", workspaceName }), "13-Custom-CLI-Normal");
-  assert.equal(computeTerminalTitle({ terminalTitleMode: "name" }), "Codexa");
-  assert.equal(computeTerminalTitle({ terminalTitleMode: "simple" }), "Codexa");
-  assert.equal(computeTerminalTitle({ terminalTitleMode: "dir", appName: "Other" }), "Other");
-});
-
-test("reassertTerminalTitle writes both title sequences without mutating process title", () => {
-  const writes: string[] = [];
-  const originalTitle = process.title;
-
-  try {
-    reassertTerminalTitle("Codexa", (chunk) => {
-      writes.push(chunk);
-    });
-
-    assert.equal(process.title, originalTitle);
-    assert.deepEqual(writes, [buildTerminalTitleSequence("Codexa")]);
-  } finally {
-    process.title = originalTitle;
-  }
-});
-
-test("acquireTerminalTitleGuard asserts immediately, ticks while active, and reasserts on release", async () => {
-  let calls = 0;
-  const release = acquireTerminalTitleGuard(10, () => {
-    calls += 1;
-  });
-
-  await sleep(35);
-  release();
-
-  const callsAfterRelease = calls;
-  await sleep(20);
-
-  assert.ok(callsAfterRelease >= 3, `expected at least 3 title assertions, got ${callsAfterRelease}`);
-  assert.equal(calls, callsAfterRelease);
-});
-
-test("acquireTerminalTitleGuard release is idempotent", () => {
-  let calls = 0;
-  const release = acquireTerminalTitleGuard(50, () => {
-    calls += 1;
-  });
-
-  release();
-  const callsAfterFirstRelease = calls;
-  release();
-
-  assert.equal(callsAfterFirstRelease, 2);
-  assert.equal(calls, callsAfterFirstRelease);
-});
-
-test("setTerminalTitle deduplicates identical title writes", () => {
-  const writes: string[] = [];
-  __resetTerminalTitleCache();
-
-  setTerminalTitle("Codexa", { write: (chunk) => writes.push(chunk) });
-  setTerminalTitle("Codexa", { write: (chunk) => writes.push(chunk) });
-  setTerminalTitle("Other", { write: (chunk) => writes.push(chunk) });
-
-  assert.equal(writes.length, 2);
-  assert.equal(writes[0], buildTerminalTitleSequence("Codexa"));
-  assert.equal(writes[1], buildTerminalTitleSequence("Other"));
-});
-
-test("writeCodexaTerminalTitle delegates to central title writer with force support", () => {
-  const writes: string[] = [];
-  __resetTerminalTitleCache();
-
-  writeCodexaTerminalTitle("Codexa", { force: true, reason: "test", write: (chunk) => writes.push(chunk) });
-
-  assert.deepEqual(writes, [buildTerminalTitleSequence("Codexa")]);
-});
-
-test("intended terminal title fallback is safe and later replaced by workspace title", () => {
-  const writes: string[] = [];
-  __resetTerminalTitleCache();
-
-  setIntendedTerminalTitle("C:\\WINDOWS\\system", {
-    force: true,
-    reason: "test-fallback",
-    write: (chunk) => writes.push(chunk),
-  });
-  assert.equal(getIntendedTerminalTitle(), "Codexa");
-  assert.equal(writes.at(-1), buildTerminalTitleSequence("Codexa"));
-
-  setIntendedTerminalTitle("13-Custom-CLI-Normal", {
-    force: true,
-    reason: "test-workspace",
-    write: (chunk) => writes.push(chunk),
-  });
-  assert.equal(getIntendedTerminalTitle(), "13-Custom-CLI-Normal");
-  assert.equal(writes.at(-1), buildTerminalTitleSequence("13-Custom-CLI-Normal"));
-});
-
-test("busy idle reassertion keeps the same intended title", () => {
-  const writes: string[] = [];
-  __resetTerminalTitleCache();
-
-  setIntendedTerminalTitle("13-Custom-CLI-Normal", {
-    force: true,
-    write: (chunk) => writes.push(chunk),
-  });
-  reassertIntendedTerminalTitle({ reason: "busy-start", write: (chunk) => writes.push(chunk) });
-  reassertIntendedTerminalTitle({ reason: "busy-end", write: (chunk) => writes.push(chunk) });
-
-  assert.equal(getIntendedTerminalTitle(), "13-Custom-CLI-Normal");
-  assert.deepEqual(writes, [
-    buildTerminalTitleSequence("13-Custom-CLI-Normal"),
-    buildTerminalTitleSequence("13-Custom-CLI-Normal"),
-    buildTerminalTitleSequence("13-Custom-CLI-Normal"),
-  ]);
-});
-
-test("writeGuardedTerminalOutput strips external title OSC and preserves SGR", () => {
-  const writes: string[] = [];
-  const result = writeGuardedTerminalOutput(
-    (chunk) => {
-      writes.push(chunk);
-      return true;
-    },
-    "start\x1b]0;C:\\WINDOWS\\system\x07middle\x1b[32mok\x1b[0mend",
-    { source: "test", stream: "stdout", origin: "child" },
-  );
-
-  assert.equal(result, true);
-  assert.deepEqual(writes, ["startmiddle\x1b[32mok\x1b[0mend"]);
-});
-
-test("setTerminalTitle force option bypasses dedup", () => {
-  const writes: string[] = [];
-  __resetTerminalTitleCache();
-
-  setTerminalTitle("Codexa", { write: (chunk) => writes.push(chunk) });
-  setTerminalTitle("Codexa", { force: true, write: (chunk) => writes.push(chunk) });
-  setTerminalTitle("Codexa", { force: true, write: (chunk) => writes.push(chunk) });
-
-  assert.equal(writes.length, 3);
-  writes.forEach((w) => assert.equal(w, buildTerminalTitleSequence("Codexa")));
-});
-
-test("beginColdStartSequence writes immediately then retries", async () => {
-  const writes: string[] = [];
-  __resetTerminalTitleCache();
-
-  const cancel = beginColdStartSequence("Codexa", { write: (chunk) => writes.push(chunk) });
-  
-  assert.equal(writes.length, 1, "should write immediately");
-  
-  await sleep(60);
-  assert.equal(writes.length, 2, "should have retried at 50ms");
-  
-  cancel();
-  await sleep(300);
-  assert.equal(writes.length, 2, "should not have retried further after cancel");
-});
-
-test("startup guard reasserts intended title until cancelled", async () => {
-  const writes: string[] = [];
-  __resetTerminalTitleCache();
-
-  setIntendedTerminalTitle("13-Custom-CLI-Normal", {
-    force: true,
-    write: (chunk) => writes.push(chunk),
-  });
-  const cancel = startTerminalTitleStartupGuard({
-    intervalMs: 10,
-    durationMs: 100,
-    write: (chunk) => writes.push(chunk),
-  });
-
-  await sleep(25);
-  cancel();
-  const writesAfterCancel = writes.length;
-  await sleep(25);
-
-  assert.ok(writesAfterCancel >= 3, `expected guard to reassert title, got ${writesAfterCancel} writes`);
-  assert.equal(writes.length, writesAfterCancel);
-  assert.ok(writes.every((chunk) => chunk === buildTerminalTitleSequence("13-Custom-CLI-Normal")));
-});
-
-test("stripTerminalTitleSequences handles very long unterminated OSC without hanging", () => {
-  const long = "\x1b]0;" + "A".repeat(100_000);
-  const start = Date.now();
-  const result = stripTerminalTitleSequences(long);
-  assert.ok(Date.now() - start < 100, "must complete in under 100 ms");
-  assert.ok(result.includes("\x1b]0;"), "unterminated sequence passes through unchanged");
-});
-
-test("stripTerminalTitleSequences strips OSC sequence with empty title", () => {
-  assert.equal(stripTerminalTitleSequences("pre\x1b]0;\x07post"), "prepost");
-  assert.equal(stripTerminalTitleSequences("pre\x1b]2;\x1b\\post"), "prepost");
-});
-
-test("createTerminalTitleSequenceStripper handles OSC split across chunks with ST terminator", () => {
-  const stripper = createTerminalTitleSequenceStripper({ source: "test", stream: "stdout", origin: "child" });
-  assert.equal(stripper.process("hello\x1b]2;MyTitle"), "hello");
-  assert.equal(stripper.process("\x1b\\world"), "world");
-  assert.equal(stripper.flush(), "");
-});
-
-test("traceTerminalTitleSequences does not hang on crafted adversarial input", () => {
-  const crafted = "\x1b]0;" + "X".repeat(10_000) + "\x1b]2;" + "Y".repeat(10_000);
-  const start = Date.now();
-  const found = traceTerminalTitleSequences(crafted, { source: "test", stream: "stdout", origin: "child" });
-  assert.ok(Date.now() - start < 100, "must complete in under 100 ms");
-  assert.equal(found, false, "no complete sequences in adversarial input");
-});

package/src/core/updateCheck.test.ts

@@ -1,194 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  CODEXA_NPM_REGISTRY_URL,
-  CODEXA_UPDATE_COMMAND,
-  checkForUpdates,
-  compareSemver,
-  formatUpdateInstructions,
-  isNewerVersion,
-  type NpmRegistryMetadata,
-} from "./updateCheck.js";
-import { isCacheValid, type UpdateCheckCache } from "../config/updateCheckCache.js";
-
-function metadata(version: string): NpmRegistryMetadata {
-  return { "dist-tags": { latest: version } };
-}
-
-test("checkForUpdates returns update-available when installed version is lower than npm latest", async () => {
-  const result = await checkForUpdates(
-    {},
-    {
-      currentVersion: "1.0.1",
-      fetchNpmMetadataFn: async (url) => {
-        assert.equal(url, CODEXA_NPM_REGISTRY_URL);
-        return metadata("1.0.2");
-      },
-    },
-  );
-
-  assert.equal(result.status, "update-available");
-  assert.equal(result.currentVersion, "1.0.1");
-  assert.equal(result.latestVersion, "1.0.2");
-});
-
-test("checkForUpdates returns up-to-date when installed version equals npm latest", async () => {
-  const result = await checkForUpdates(
-    {},
-    {
-      currentVersion: "1.0.2",
-      fetchNpmMetadataFn: async () => metadata("1.0.2"),
-    },
-  );
-
-  assert.equal(result.status, "up-to-date");
-});
-
-test("checkForUpdates does not show update available when installed version is higher than npm latest", async () => {
-  const result = await checkForUpdates(
-    {},
-    {
-      currentVersion: "1.0.3",
-      fetchNpmMetadataFn: async () => metadata("1.0.2"),
-    },
-  );
-
-  assert.equal(result.status, "up-to-date");
-});
-
-test("checkForUpdates returns error status instead of throwing when npm request fails", async () => {
-  const result = await checkForUpdates(
-    {},
-    {
-      currentVersion: "1.0.1",
-      fetchNpmMetadataFn: async () => {
-        throw new Error("network unavailable");
-      },
-    },
-  );
-
-  assert.equal(result.status, "error");
-  assert.match(result.errorMessage ?? "", /network unavailable/);
-});
-
-test("checkForUpdates returns error when npm latest is missing", async () => {
-  const result = await checkForUpdates(
-    {},
-    {
-      currentVersion: "1.0.1",
-      fetchNpmMetadataFn: async () => ({ "dist-tags": {} }),
-    },
-  );
-
-  assert.equal(result.status, "error");
-  assert.match(result.errorMessage ?? "", /dist-tags\.latest/);
-});
-
-test("checkForUpdates returns unknown immediately when enabled=false", async () => {
-  let called = false;
-  const result = await checkForUpdates(
-    { enabled: false },
-    {
-      currentVersion: "1.0.1",
-      fetchNpmMetadataFn: async () => {
-        called = true;
-        return metadata("1.0.2");
-      },
-    },
-  );
-
-  assert.equal(result.status, "unknown");
-  assert.equal(called, false, "should not call npm when disabled");
-});
-
-test("semver comparison handles numeric and prerelease ordering", () => {
-  assert.equal(isNewerVersion("1.0.10", "1.0.2"), true);
-  assert.equal(isNewerVersion("1.0.2", "1.0.10"), false);
-  assert.equal(compareSemver("1.0.2", "1.0.2"), 0);
-  assert.equal(isNewerVersion("1.0.2", "1.0.2-beta.1"), true);
-  assert.equal(isNewerVersion("1.0.2-beta.1", "1.0.2"), false);
-});
-
-test("isCacheValid returns true when cache is within the interval", () => {
-  const cache: UpdateCheckCache = {
-    lastChecked: Date.now() - 1000 * 60 * 30,
-    currentVersion: "1.0.1",
-    latestVersion: "1.0.1",
-    updateAvailable: false,
-  };
-  assert.equal(isCacheValid(cache, 6), true);
-});
-
-test("isCacheValid returns false when cache is older than the interval", () => {
-  const cache: UpdateCheckCache = {
-    lastChecked: Date.now() - 1000 * 60 * 60 * 7,
-    currentVersion: "1.0.1",
-    latestVersion: "1.0.1",
-    updateAvailable: false,
-  };
-  assert.equal(isCacheValid(cache, 6), false);
-});
-
-test("formatUpdateInstructions formats update-available npm status", () => {
-  const result = formatUpdateInstructions({
-    status: "update-available",
-    currentVersion: "1.0.1",
-    latestVersion: "1.0.2",
-    checkedAt: Date.now(),
-  });
-
-  assert.match(result, /Current installed version: 1\.0\.1/);
-  assert.match(result, /npm latest version:\s+1\.0\.2/);
-  assert.match(result, /Update available: Codexa 1\.0\.2 is available\. You are using 1\.0\.1\./);
-  assert.match(result, new RegExp(`Run: ${CODEXA_UPDATE_COMMAND.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`));
-});
-
-test("formatUpdateInstructions formats up-to-date npm status", () => {
-  const result = formatUpdateInstructions({
-    status: "up-to-date",
-    currentVersion: "1.0.2",
-    latestVersion: "1.0.2",
-    checkedAt: Date.now(),
-  });
-
-  assert.match(result, /Already up to date/);
-  assert.match(result, /npm install -g @golba98\/codexa@latest/);
-});
-
-test("formatUpdateInstructions formats manual npm errors", () => {
-  const result = formatUpdateInstructions({
-    status: "error",
-    currentVersion: "1.0.1",
-    latestVersion: null,
-    errorMessage: "Connection timed out",
-    checkedAt: Date.now(),
-  });
-
-  assert.match(result, /Error checking npm update status: Connection timed out/);
-});
-
-test("/update check path bypasses cache by performing a fresh npm check", async () => {
-  const validCache: UpdateCheckCache = {
-    lastChecked: Date.now(),
-    currentVersion: "1.0.1",
-    latestVersion: "1.0.1",
-    updateAvailable: false,
-  };
-  assert.equal(isCacheValid(validCache, 6), true);
-
-  let calls = 0;
-  const result = await checkForUpdates(
-    { enabled: true },
-    {
-      currentVersion: validCache.currentVersion,
-      fetchNpmMetadataFn: async () => {
-        calls += 1;
-        return metadata("1.0.2");
-      },
-    },
-  );
-
-  assert.equal(calls, 1);
-  assert.equal(result.status, "update-available");
-  assert.equal(result.latestVersion, "1.0.2");
-});

package/src/core/workspaceActivity.test.ts

@@ -1,163 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, unlinkSync, writeFileSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-import test from "node:test";
-import {
-  captureWorkspaceSnapshot,
-  createWorkspaceActivityTracker,
-  createTextDiffExcerpt,
-  diffWorkspaceSnapshots,
-} from "./workspaceActivity.js";
-
-function createTempWorkspace(): string {
-  return mkdtempSync(join(tmpdir(), "codex-workspace-activity-"));
-}
-
-test("detects created files in the workspace snapshot diff", () => {
-  const root = createTempWorkspace();
-  try {
-    const before = captureWorkspaceSnapshot(root);
-    writeFileSync(join(root, "new-file.ts"), "const value = 1;\n", "utf8");
-    const after = captureWorkspaceSnapshot(root);
-    const activity = diffWorkspaceSnapshots(before, after, 123);
-
-    assert.equal(activity.length, 1);
-    assert.equal(activity[0]?.operation, "created");
-    assert.equal(activity[0]?.path, "new-file.ts");
-    assert.equal(activity[0]?.addedLines, 1);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("detects modified files with diff preview", () => {
-  const root = createTempWorkspace();
-  try {
-    const file = join(root, "edited.py");
-    writeFileSync(file, "print('before')\nvalue = 1\n", "utf8");
-    const before = captureWorkspaceSnapshot(root);
-
-    writeFileSync(file, "print('after')\nvalue = 2\nextra = True\n", "utf8");
-    const after = captureWorkspaceSnapshot(root);
-    const activity = diffWorkspaceSnapshots(before, after, 456);
-
-    assert.equal(activity.length, 1);
-    assert.equal(activity[0]?.operation, "modified");
-    assert.equal(activity[0]?.path, "edited.py");
-    assert.equal(activity[0]?.addedLines, 3);
-    assert.equal(activity[0]?.removedLines, 2);
-    assert.equal(activity[0]?.diffLines?.[0]?.kind, "removed");
-    assert.equal(activity[0]?.diffLines?.at(-1)?.kind, "added");
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("detects deleted files", () => {
-  const root = createTempWorkspace();
-  try {
-    const file = join(root, "gone.txt");
-    writeFileSync(file, "goodbye\n", "utf8");
-    const before = captureWorkspaceSnapshot(root);
-
-    unlinkSync(file);
-    const after = captureWorkspaceSnapshot(root);
-    const activity = diffWorkspaceSnapshots(before, after, 789);
-
-    assert.equal(activity.length, 1);
-    assert.equal(activity[0]?.operation, "deleted");
-    assert.equal(activity[0]?.path, "gone.txt");
-    assert.equal(activity[0]?.removedLines, 1);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("ignores excluded directories like node_modules and .git", () => {
-  const root = createTempWorkspace();
-  try {
-    const before = captureWorkspaceSnapshot(root);
-    mkdirSync(join(root, "node_modules"), { recursive: true });
-    mkdirSync(join(root, ".git"), { recursive: true });
-    writeFileSync(join(root, "node_modules", "ignored.js"), "console.log('x')", "utf8");
-    writeFileSync(join(root, ".git", "ignored.txt"), "internal", "utf8");
-    const after = captureWorkspaceSnapshot(root);
-    const activity = diffWorkspaceSnapshots(before, after, 111);
-
-    assert.equal(activity.length, 0);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("workspace activity tracker can reuse a provided initial snapshot", async () => {
-  const root = createTempWorkspace();
-  try {
-    writeFileSync(join(root, "edited.txt"), "before\n", "utf8");
-    writeFileSync(join(root, "gone.txt"), "delete me\n", "utf8");
-    const before = captureWorkspaceSnapshot(root);
-
-    writeFileSync(join(root, "new-file.ts"), "const value = 1;\n", "utf8");
-    writeFileSync(join(root, "edited.txt"), "after\n", "utf8");
-    unlinkSync(join(root, "gone.txt"));
-
-    const activity = await new Promise<ReturnType<typeof diffWorkspaceSnapshots>>((resolve, reject) => {
-      let tracker: ReturnType<typeof createWorkspaceActivityTracker> | null = null;
-      const timeout = setTimeout(() => {
-        tracker?.stop();
-        reject(new Error("Timed out waiting for workspace activity."));
-      }, 500);
-      tracker = createWorkspaceActivityTracker({
-        rootDir: root,
-        initialSnapshot: before,
-        pollIntervalMs: 10,
-        onActivity: (items) => {
-          clearTimeout(timeout);
-          tracker?.stop();
-          resolve(items);
-        },
-      });
-    });
-
-    const operationsByPath = new Map(activity.map((item) => [item.path, item.operation]));
-    assert.equal(operationsByPath.get("new-file.ts"), "created");
-    assert.equal(operationsByPath.get("edited.txt"), "modified");
-    assert.equal(operationsByPath.get("gone.txt"), "deleted");
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("skips inline diff previews for oversized files", () => {
-  const root = createTempWorkspace();
-  try {
-    const file = join(root, "large.txt");
-    const largeContent = `${"a".repeat(129 * 1024)}\n`;
-    writeFileSync(file, largeContent, "utf8");
-    const before = captureWorkspaceSnapshot(root);
-
-    writeFileSync(file, `${largeContent}tail\n`, "utf8");
-    const after = captureWorkspaceSnapshot(root);
-    const activity = diffWorkspaceSnapshots(before, after, 222);
-
-    assert.equal(activity.length, 1);
-    assert.equal(activity[0]?.operation, "modified");
-    assert.equal(activity[0]?.diffLines, undefined);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("creates green/red diff excerpts for mixed edits", () => {
-  const diff = createTextDiffExcerpt(
-    ["alpha", "beta", "gamma"].join("\n"),
-    ["alpha", "beta-2", "gamma", "delta"].join("\n"),
-  );
-
-  assert(diff);
-  assert.equal(diff.addedLines, 2);
-  assert.equal(diff.removedLines, 1);
-  assert.equal(diff.diffLines?.some((line) => line.kind === "added"), true);
-  assert.equal(diff.diffLines?.some((line) => line.kind === "removed"), true);
-});