gsd-pi 2.77.0-dev.1d17f366c → 2.77.0-dev.58d3d4d6c

package/src/resources/extensions/gsd/tests/slice-cadence.test.ts

@@ -0,0 +1,242 @@
+/**
+ * Tests for slice-cadence collapse — #4765.
+ *
+ * Covers mergeSliceToMain (squash + advance), resquashMilestoneOnMain,
+ * and the preference accessors.
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, realpathSync, readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import {
+  mergeSliceToMain,
+  resquashMilestoneOnMain,
+  getCollapseCadence,
+  getMilestoneResquash,
+} from "../slice-cadence.ts";
+import { MergeConflictError } from "../git-service.ts";
+import { summarizeWorktreeTelemetry } from "../worktree-telemetry.ts";
+
+function git(args: string[], cwd: string): string {
+  return execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+/** Create a temp git repo with an initial commit on main. */
+function createRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "slice-cad-test-")));
+  git(["init"], dir);
+  git(["config", "user.email", "test@test.com"], dir);
+  git(["config", "user.name", "Test"], dir);
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  git(["add", "."], dir);
+  git(["commit", "-m", "init"], dir);
+  git(["branch", "-M", "main"], dir);
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  return dir;
+}
+
+function enterMilestoneBranch(dir: string, milestoneId: string): void {
+  git(["checkout", "-b", `milestone/${milestoneId}`], dir);
+}
+
+function commitFile(dir: string, file: string, content: string, msg: string): string {
+  writeFileSync(join(dir, file), content);
+  git(["add", "."], dir);
+  git(["commit", "-m", msg], dir);
+  return git(["rev-parse", "HEAD"], dir);
+}
+
+describe("getCollapseCadence / getMilestoneResquash", () => {
+  test("defaults to milestone cadence", () => {
+    assert.equal(getCollapseCadence(undefined), "milestone");
+    assert.equal(getCollapseCadence(null), "milestone");
+    assert.equal(getCollapseCadence({}), "milestone");
+    assert.equal(getCollapseCadence({ git: {} }), "milestone");
+  });
+  test("reads slice cadence when set", () => {
+    assert.equal(getCollapseCadence({ git: { collapse_cadence: "slice" } }), "slice");
+  });
+  test("milestone_resquash defaults to true when not set", () => {
+    assert.equal(getMilestoneResquash(undefined), true);
+    assert.equal(getMilestoneResquash({ git: {} }), true);
+    assert.equal(getMilestoneResquash({ git: { milestone_resquash: true } }), true);
+  });
+  test("milestone_resquash can be disabled explicitly", () => {
+    assert.equal(getMilestoneResquash({ git: { milestone_resquash: false } }), false);
+  });
+});
+
+describe("mergeSliceToMain", () => {
+  let dir: string;
+  let originalCwd: string;
+
+  beforeEach(() => {
+    dir = createRepo();
+    originalCwd = process.cwd();
+  });
+
+  afterEach(() => {
+    try { process.chdir(originalCwd); } catch { /* */ }
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("squashes one slice's commits onto main and advances the milestone branch", () => {
+    enterMilestoneBranch(dir, "M001");
+    commitFile(dir, "feature.txt", "slice 1 work\n", "feat: S01 work");
+
+    process.chdir(dir);
+    const result = mergeSliceToMain(dir, "M001", "S01");
+
+    assert.equal(result.skipped, false);
+    assert.ok(result.commitSha, "expected a commit SHA");
+    assert.equal(result.milestoneBranch, "milestone/M001");
+    assert.equal(result.mainBranch, "main");
+
+    const mainLog = git(["log", "main", "--oneline"], dir);
+    assert.ok(mainLog.includes("S01 of M001 (slice-cadence)"), `main log: ${mainLog}`);
+    assert.equal(readFileSync(join(dir, "feature.txt"), "utf-8"), "slice 1 work\n");
+
+    const mainSha = git(["rev-parse", "main"], dir);
+    const milestoneSha = git(["rev-parse", "milestone/M001"], dir);
+    assert.equal(milestoneSha, mainSha, "milestone branch must be advanced to main");
+
+    const summary = summarizeWorktreeTelemetry(dir);
+    assert.equal(summary.slicesMerged, 1);
+    assert.equal(summary.sliceMergeConflicts, 0);
+  });
+
+  test("handles sequential slice merges cleanly", () => {
+    enterMilestoneBranch(dir, "M001");
+    commitFile(dir, "a.txt", "slice 1\n", "feat: S01");
+
+    process.chdir(dir);
+    mergeSliceToMain(dir, "M001", "S01");
+
+    git(["checkout", "milestone/M001"], dir);
+    commitFile(dir, "b.txt", "slice 2\n", "feat: S02");
+
+    const result = mergeSliceToMain(dir, "M001", "S02");
+    assert.equal(result.skipped, false);
+
+    const mainLog = git(["log", "main", "--oneline"], dir);
+    assert.ok(mainLog.includes("S01 of M001"));
+    assert.ok(mainLog.includes("S02 of M001"));
+
+    assert.equal(readFileSync(join(dir, "a.txt"), "utf-8"), "slice 1\n");
+    assert.equal(readFileSync(join(dir, "b.txt"), "utf-8"), "slice 2\n");
+
+    const summary = summarizeWorktreeTelemetry(dir);
+    assert.equal(summary.slicesMerged, 2);
+  });
+
+  test("returns skipped when milestone branch has no commits ahead of main", () => {
+    enterMilestoneBranch(dir, "M001");
+
+    process.chdir(dir);
+    const result = mergeSliceToMain(dir, "M001", "S01");
+
+    assert.equal(result.skipped, true);
+    assert.equal(result.skippedReason, "no-commits-ahead");
+    assert.equal(result.commitSha, null);
+  });
+
+  test("throws MergeConflictError on a real conflict and leaves no merge artifacts", () => {
+    writeFileSync(join(dir, "shared.txt"), "main version\n");
+    git(["add", "."], dir);
+    git(["commit", "-m", "main-seed"], dir);
+
+    enterMilestoneBranch(dir, "M001");
+    commitFile(dir, "shared.txt", "slice version\n", "feat: S01 conflicting");
+
+    git(["checkout", "main"], dir);
+    commitFile(dir, "shared.txt", "main evolved\n", "main evolved");
+    git(["checkout", "milestone/M001"], dir);
+
+    process.chdir(dir);
+    assert.throws(
+      () => mergeSliceToMain(dir, "M001", "S01"),
+      (err: unknown) => err instanceof MergeConflictError,
+    );
+
+    const gitDir = join(dir, ".git");
+    for (const f of ["SQUASH_MSG", "MERGE_MSG", "MERGE_HEAD"]) {
+      assert.ok(!existsSync(join(gitDir, f)), `${f} should be cleaned up`);
+    }
+
+    const summary = summarizeWorktreeTelemetry(dir);
+    assert.equal(summary.sliceMergeConflicts, 1);
+  });
+
+  test("restores cwd even when merge fails (dirty working tree)", () => {
+    enterMilestoneBranch(dir, "M001");
+    commitFile(dir, "feature.txt", "slice 1\n", "feat: S01");
+    // Introduce an untracked file AFTER the slice commit so it's still
+    // present when mergeSliceToMain runs its status check.
+    writeFileSync(join(dir, "dirty.txt"), "uncommitted\n");
+
+    process.chdir(dir);
+    const cwdBefore = process.cwd();
+    assert.throws(() => mergeSliceToMain(dir, "M001", "S01"));
+    assert.equal(process.cwd(), cwdBefore, "cwd must be restored on failure");
+  });
+});
+
+describe("resquashMilestoneOnMain", () => {
+  let dir: string;
+  let originalCwd: string;
+
+  beforeEach(() => {
+    dir = createRepo();
+    originalCwd = process.cwd();
+  });
+
+  afterEach(() => {
+    try { process.chdir(originalCwd); } catch { /* */ }
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("collapses N slice commits on main into one milestone commit", () => {
+    const startSha = git(["rev-parse", "main"], dir);
+
+    enterMilestoneBranch(dir, "M001");
+    commitFile(dir, "a.txt", "slice 1\n", "feat: S01");
+    process.chdir(dir);
+    mergeSliceToMain(dir, "M001", "S01");
+
+    git(["checkout", "milestone/M001"], dir);
+    commitFile(dir, "b.txt", "slice 2\n", "feat: S02");
+    mergeSliceToMain(dir, "M001", "S02");
+
+    const beforeCount = parseInt(git(["rev-list", "--count", `${startSha}..main`], dir), 10);
+    assert.equal(beforeCount, 2);
+
+    const result = resquashMilestoneOnMain(dir, "M001", startSha);
+    assert.equal(result.resquashed, true);
+    assert.ok(result.newSha);
+
+    git(["checkout", "main"], dir);
+    const afterCount = parseInt(git(["rev-list", "--count", `${startSha}..main`], dir), 10);
+    assert.equal(afterCount, 1, "slice commits collapsed into one milestone commit");
+
+    const msg = git(["log", "-1", "--format=%s", "main"], dir);
+    assert.ok(msg.includes("M001") && msg.includes("2 slices"), `commit message should describe the resquash; got: ${msg}`);
+
+    assert.equal(readFileSync(join(dir, "a.txt"), "utf-8"), "slice 1\n");
+    assert.equal(readFileSync(join(dir, "b.txt"), "utf-8"), "slice 2\n");
+
+    const summary = summarizeWorktreeTelemetry(dir);
+    assert.equal(summary.milestoneResquashes, 1);
+  });
+
+  test("no-op when startSha equals HEAD", () => {
+    const startSha = git(["rev-parse", "main"], dir);
+    process.chdir(dir);
+    const result = resquashMilestoneOnMain(dir, "M001", startSha);
+    assert.equal(result.resquashed, false);
+    assert.equal(result.newSha, null);
+  });
+});

package/src/resources/extensions/gsd/tests/slice-context-injection.test.ts

@@ -11,6 +11,7 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const autoPromptsPath = join(__dirname, "..", "auto-prompts.ts");
@@ -32,7 +33,7 @@ describe("slice CONTEXT.md injection into prompt builders (#3452)", () => {
       assert.ok(fnStart !== -1, `${builder} should exist in auto-prompts.ts`);
 
       // Get a reasonable chunk after the function start
-      const chunk = source.slice(fnStart, fnStart + 3000);
+      const chunk = extractSourceRegion(source, `export async function ${builder}`);
 
       // ADR-011: buildPlanSlicePrompt / buildRefineSlicePrompt now delegate to
       // a shared helper (renderSlicePrompt) that performs the slice CONTEXT
@@ -42,7 +43,7 @@ describe("slice CONTEXT.md injection into prompt builders (#3452)", () => {
         ? (() => {
             const helperStart = source.indexOf("async function renderSlicePrompt");
             assert.ok(helperStart !== -1, "renderSlicePrompt helper must exist");
-            return source.slice(helperStart, helperStart + 3000);
+            return extractSourceRegion(source, "async function renderSlicePrompt");
           })()
         : chunk;
 

package/src/resources/extensions/gsd/tests/smart-entry-draft.test.ts

@@ -4,6 +4,7 @@ import { tmpdir } from "node:os";
 
 import { deriveState } from "../state.js";
 import { resolveMilestoneFile } from "../paths.js";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 let passed = 0;
 let failed = 0;
@@ -81,7 +82,7 @@ assert(
 
 // Check the branch has draft-aware menu options
 const branchIdx = guidedFlowSource.indexOf('state.phase === "needs-discussion"');
-const branchChunk = guidedFlowSource.slice(branchIdx, branchIdx + 4000);
+const branchChunk = extractSourceRegion(guidedFlowSource, 'state.phase === "needs-discussion"');
 
 assert(
   branchChunk.includes("discuss_draft"),

package/src/resources/extensions/gsd/tests/stop-auto-race-null-unit.test.ts

@@ -13,7 +13,7 @@
 
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import { createTestContext } from "./test-helpers.ts";
+import { createTestContext, extractSourceRegion } from "./test-helpers.ts";
 
 const { assertTrue, report } = createTestContext();
 
@@ -35,7 +35,7 @@ assertTrue(
 );
 
 // Extract the region from the closeout comment to the next section comment
-const closeoutRegion = phasesSrc.slice(closeoutIdx, closeoutIdx + 500);
+const closeoutRegion = extractSourceRegion(phasesSrc, closeoutComment);
 assertTrue(
   closeoutRegion.includes("if (s.currentUnit)"),
   "closeoutUnit call is guarded by `if (s.currentUnit)` check (#2939)",
@@ -52,7 +52,7 @@ assertTrue(
   "phases.ts contains the 'Zero tool-call guard' comment block",
 );
 
-const zeroToolRegion = phasesSrc.slice(zeroToolIdx, zeroToolIdx + 600);
+const zeroToolRegion = extractSourceRegion(phasesSrc, zeroToolComment);
 
 // The non-null assertion `s.currentUnit!.startedAt` must be replaced with
 // optional chaining `s.currentUnit?.startedAt`

package/src/resources/extensions/gsd/tests/subagent-model-dispatch.test.ts

@@ -15,6 +15,7 @@ import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { validatePreferences } from "../preferences-validation.ts";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const promptsSrc = readFileSync(join(__dirname, "..", "auto-prompts.ts"), "utf-8");
@@ -59,7 +60,7 @@ test("reactive_execution: subagent_model rejects empty string", () => {
 test("buildReactiveExecutePrompt: accepts subagentModel parameter", () => {
   const fnStart = promptsSrc.indexOf("export async function buildReactiveExecutePrompt");
   assert.ok(fnStart !== -1, "buildReactiveExecutePrompt should be exported");
-  const signature = promptsSrc.slice(fnStart, fnStart + 300);
+  const signature = extractSourceRegion(promptsSrc, "export async function buildReactiveExecutePrompt", { fromIdx: fnStart });
   assert.ok(
     signature.includes("subagentModel"),
     "buildReactiveExecutePrompt should accept a subagentModel parameter",
@@ -69,7 +70,7 @@ test("buildReactiveExecutePrompt: accepts subagentModel parameter", () => {
 test("buildParallelResearchSlicesPrompt: accepts subagentModel parameter", () => {
   const fnStart = promptsSrc.indexOf("export async function buildParallelResearchSlicesPrompt");
   assert.ok(fnStart !== -1, "buildParallelResearchSlicesPrompt should be exported");
-  const signature = promptsSrc.slice(fnStart, fnStart + 300);
+  const signature = extractSourceRegion(promptsSrc, "export async function buildParallelResearchSlicesPrompt", { fromIdx: fnStart });
   assert.ok(
     signature.includes("subagentModel"),
     "buildParallelResearchSlicesPrompt should accept a subagentModel parameter",
@@ -79,7 +80,7 @@ test("buildParallelResearchSlicesPrompt: accepts subagentModel parameter", () =>
 test("buildGateEvaluatePrompt: accepts subagentModel parameter", () => {
   const fnStart = promptsSrc.indexOf("export async function buildGateEvaluatePrompt");
   assert.ok(fnStart !== -1, "buildGateEvaluatePrompt should be exported");
-  const signature = promptsSrc.slice(fnStart, fnStart + 300);
+  const signature = extractSourceRegion(promptsSrc, "export async function buildGateEvaluatePrompt", { fromIdx: fnStart });
   assert.ok(
     signature.includes("subagentModel"),
     "buildGateEvaluatePrompt should accept a subagentModel parameter",
@@ -129,7 +130,7 @@ test("auto-dispatch: passes model to buildReactiveExecutePrompt", () => {
   // Find the reactive-execute dispatch rule
   const ruleStart = dispatchSrc.indexOf("reactive-execute (parallel dispatch)");
   assert.ok(ruleStart !== -1, "reactive-execute dispatch rule should exist");
-  const ruleBlock = dispatchSrc.slice(ruleStart, ruleStart + 1000);
+  const ruleBlock = extractSourceRegion(dispatchSrc, "reactive-execute (parallel dispatch)", { fromIdx: ruleStart });
   assert.ok(
     ruleBlock.includes("subagent_model") || ruleBlock.includes("subagentModel"),
     "reactive-execute rule should resolve and pass the subagent model",
@@ -140,7 +141,7 @@ test("auto-dispatch: passes model to buildParallelResearchSlicesPrompt", () => {
   const callIdx = dispatchSrc.indexOf("buildParallelResearchSlicesPrompt(");
   assert.ok(callIdx !== -1, "buildParallelResearchSlicesPrompt call should exist");
   // The call site should pass a model argument (not just 4 args)
-  const callSite = dispatchSrc.slice(callIdx, callIdx + 300);
+  const callSite = extractSourceRegion(dispatchSrc, "buildParallelResearchSlicesPrompt(", { fromIdx: callIdx });
   assert.ok(
     callSite.includes("subagentModel") || callSite.includes("resolveModelWithFallbacksForUnit"),
     "buildParallelResearchSlicesPrompt call should include model argument",
@@ -150,7 +151,7 @@ test("auto-dispatch: passes model to buildParallelResearchSlicesPrompt", () => {
 test("auto-dispatch: passes model to buildGateEvaluatePrompt", () => {
   const callIdx = dispatchSrc.indexOf("buildGateEvaluatePrompt(");
   assert.ok(callIdx !== -1, "buildGateEvaluatePrompt call should exist");
-  const callSite = dispatchSrc.slice(callIdx, callIdx + 300);
+  const callSite = extractSourceRegion(dispatchSrc, "buildGateEvaluatePrompt(", { fromIdx: callIdx });
   assert.ok(
     callSite.includes("subagentModel") || callSite.includes("resolveModelWithFallbacksForUnit"),
     "buildGateEvaluatePrompt call should include model argument",

package/src/resources/extensions/gsd/tests/sync-worktree-skip-current.test.ts

@@ -13,6 +13,7 @@ import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { resolve } from 'node:path'
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const src = readFileSync(
   resolve(process.cwd(), 'src', 'resources', 'extensions', 'gsd', 'auto-worktree.ts'),
@@ -33,14 +34,14 @@ describe('syncWorktreeStateBack skips current milestone (#3641)', () => {
     assert.ok(fnStart !== -1)
 
     // Get a reasonable portion of the function
-    const fnBlock = src.slice(fnStart, fnStart + 3000)
+    const fnBlock = extractSourceRegion(src, 'function syncWorktreeStateBack(', { fromIdx: fnStart })
 
     // Find the for loop iterating milestones
     const loopIdx = fnBlock.indexOf('for (const mid of wtMilestones)')
     assert.ok(loopIdx !== -1, 'milestone iteration loop must exist')
 
     // After the loop, there should be the skip guard
-    const loopBody = fnBlock.slice(loopIdx, loopIdx + 300)
+    const loopBody = extractSourceRegion(fnBlock, 'for (const mid of wtMilestones)', { fromIdx: loopIdx })
     assert.ok(
       loopBody.includes('mid === milestoneId'),
       'mid === milestoneId skip guard must exist inside the milestone loop',
@@ -55,7 +56,7 @@ describe('syncWorktreeStateBack skips current milestone (#3641)', () => {
     const fnStart = src.indexOf('function syncWorktreeStateBack(')
     assert.ok(fnStart !== -1)
 
-    const fnBlock = src.slice(fnStart, fnStart + 3000)
+    const fnBlock = extractSourceRegion(src, 'function syncWorktreeStateBack(', { fromIdx: fnStart })
 
     assert.ok(
       fnBlock.includes('syncMilestoneDir('),

package/src/resources/extensions/gsd/tests/test-helpers.test.ts

@@ -0,0 +1,147 @@
+/**
+ * Tests for test-helpers.ts — the source-inspection and timing helpers
+ * introduced in #4773 / #4774 to replace brittle fixed-byte slice and
+ * magic-number sleep patterns in the test suite.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { extractSourceRegion, waitForCondition, findLine } from "./test-helpers.ts";
+
+// ─── extractSourceRegion ──────────────────────────────────────────────────
+
+test("extractSourceRegion returns empty string when start anchor missing", () => {
+  assert.equal(extractSourceRegion("const x = 1;", "missing"), "");
+});
+
+test("extractSourceRegion uses explicit end anchor when provided", () => {
+  const src = "START_TOKEN\nbody line\nEND_TOKEN tail";
+  const region = extractSourceRegion(src, "START_TOKEN", "END_TOKEN");
+  assert.ok(region.includes("START_TOKEN"));
+  assert.ok(region.includes("body line"));
+  assert.ok(!region.includes("END_TOKEN"));
+});
+
+test("extractSourceRegion stops at next private method boundary", () => {
+  const src = [
+    "class Foo {",
+    "  private alpha(): void {",
+    "    const a = 1;",
+    "    someCall();",
+    "  }",
+    "",
+    "  private beta(): void {",
+    "    const b = 2;",
+    "  }",
+    "}",
+  ].join("\n");
+
+  // Anchor on alpha's declaration; helper should stop at the next
+  // private method (beta), not on alpha itself.
+  const region = extractSourceRegion(src, "private alpha");
+  assert.ok(region.includes("alpha"));
+  assert.ok(region.includes("someCall()"));
+  assert.ok(!region.includes("beta"));
+});
+
+test("extractSourceRegion stops at next top-level function", () => {
+  const src = [
+    "function alpha() {",
+    "  throw new Error('alpha');",
+    "}",
+    "",
+    "function beta() {",
+    "  return 2;",
+    "}",
+  ].join("\n");
+
+  const region = extractSourceRegion(src, "function alpha");
+  assert.ok(region.includes("throw new Error"));
+  assert.ok(!region.includes("beta"));
+});
+
+test("extractSourceRegion returns to end-of-source when no terminator found", () => {
+  const src = "just one line";
+  assert.equal(extractSourceRegion(src, "just"), "just one line");
+});
+
+// ─── waitForCondition ─────────────────────────────────────────────────────
+
+test("waitForCondition returns immediately when condition is true", async () => {
+  const result = await waitForCondition(() => true);
+  assert.equal(result, true);
+});
+
+test("waitForCondition waits and returns when condition becomes true", async () => {
+  let flipped = false;
+  setTimeout(() => { flipped = true; }, 30);
+  const result = await waitForCondition(() => flipped, { intervalMs: 5 });
+  assert.equal(result, true);
+});
+
+test("waitForCondition throws after timeout with description", async () => {
+  await assert.rejects(
+    waitForCondition(() => false, { timeoutMs: 50, intervalMs: 5, description: "the flag to flip" }),
+    /waiting for the flag to flip/i,
+  );
+});
+
+test("waitForCondition surfaces last error on timeout", async () => {
+  await assert.rejects(
+    waitForCondition(
+      () => { throw new Error("probe failed"); },
+      { timeoutMs: 30, intervalMs: 5, description: "probe" },
+    ),
+    /probe failed/,
+  );
+});
+
+test("waitForCondition returns the truthy value (not just true)", async () => {
+  let n = 0;
+  const result = await waitForCondition(() => {
+    n++;
+    return n >= 3 ? { ready: true, iteration: n } : null;
+  }, { intervalMs: 5 });
+  // The helper only resolves when the condition returns a truthy value, so
+  // result cannot be null here. Assert it and narrow for the follow-ups.
+  assert.ok(result, "waitForCondition must resolve with a truthy value, not null");
+  assert.equal(result.ready, true);
+  assert.equal(result.iteration, 3);
+});
+
+// ─── findLine ─────────────────────────────────────────────────────────────
+
+test("findLine locates a line by regex", () => {
+  const output = "header\nstatus: ok\nfooter";
+  const match = findLine(output, /^status:/);
+  assert.equal(match.index, 1);
+  assert.equal(match.text, "status: ok");
+});
+
+test("findLine locates a line by predicate", () => {
+  const output = "a\nb\nc";
+  const match = findLine(output, (l) => l === "b");
+  assert.equal(match.index, 1);
+  assert.equal(match.text, "b");
+});
+
+test("findLine throws with preview when no line matches", () => {
+  assert.throws(
+    () => findLine("a\nb\nc", /NOTFOUND/),
+    /First 10 lines/,
+  );
+});
+
+test("findLine resets lastIndex between lines for /g regex patterns", () => {
+  // Without the reset, RegExp.test with /g flag stateful-advances lastIndex
+  // and can skip matches on subsequent calls. Verify the reset keeps
+  // per-line testing deterministic.
+  const output = "foo\nfoo\nfoo";
+  const globalRe = /foo/g;
+  const match = findLine(output, globalRe);
+  assert.equal(match.index, 0);
+  // Second call on the same pattern must also match — would fail without reset
+  const match2 = findLine(output, globalRe);
+  assert.equal(match2.index, 0);
+});