feat(trekresearch): replace single follow-up pass with bounded conversation loop

tests/commands/trekresearch.test.mjs

@@ -54,6 +54,118 @@ test('trekresearch — low-effort path references --quick equivalent', () => {
     'heading-bounded slice must still fail on a genuine removal');
 });
 
+// --- Step 7: Phase 5 bounded conversation loop (heading-bounded slices) ---
+
+// Same bounding discipline as the Composition-rule pin above: slice from the
+// phase heading to the NEXT phase heading, never a fixed character window.
+function phaseSlice(doc, startHeading, endHeading) {
+  const start = doc.indexOf(startHeading);
+  assert.ok(start >= 0, `${startHeading} missing`);
+  const end = doc.indexOf(endHeading, start);
+  assert.ok(end > start, `${endHeading} missing — could not bound ${startHeading}`);
+  return doc.slice(start, end);
+}
+
+function phase5(doc) {
+  return phaseSlice(doc, '## Phase 5 —', '## Phase 6 —');
+}
+
+test('trekresearch — Phase 5 loop is gated on effort == high and names both primitives', () => {
+  const p5 = phase5(read());
+  assert.match(p5, /effort == 'high'/, 'Phase 5 loop must be gated on effort == \'high\'');
+  assert.match(p5, /research-loop-cap\.mjs/, 'Phase 5 must call the loop-cap shim per turn');
+  assert.match(p5, /query-privacy-gate\.mjs/, 'Phase 5 must route outbound queries through the privacy gate');
+  assert.match(p5, /\$\{CLAUDE_PLUGIN_ROOT\}/, 'shim invocations must use the ${CLAUDE_PLUGIN_ROOT} path form');
+});
+
+test('trekresearch — Phase 5 declares the loop bound and all three exits', () => {
+  const p5 = phase5(read());
+  assert.match(p5, /### Loop bound/, 'Phase 5 must carry a `### Loop bound` sub-heading');
+  assert.match(
+    p5,
+    /\*\*Maximum 3 turns per under-illuminated dimension\.\*\*/,
+    'the bound must be stated verbatim',
+  );
+  // Three exits — converged / cap exhausted / operator stop.
+  assert.match(p5, /converged/i, 'exit 1 (converged) must be documented');
+  assert.match(p5, /exhaust/i, 'exit 2 (cap exhausted) must be documented');
+  assert.match(p5, /operator stop/i, 'exit 3 (operator stop) must be documented');
+  // Exhaustion must reach the operator — a silent cap is indistinguishable
+  // from convergence, which is the failure this loop exists to avoid.
+  assert.match(
+    p5,
+    /visibl|visible|print/i,
+    'cap exhaustion must be written visibly to the operator',
+  );
+});
+
+test('trekresearch — Phase 5 marks empty turns without re-targeting the same dimension', () => {
+  const p5 = phase5(read());
+  assert.match(p5, /`empty`/, 'a finding-less or citation-less turn must be marked `empty`');
+  assert.match(p5, /empty_turns/, 'empty turns must be counted (empty_turns)');
+  assert.match(
+    p5,
+    /does NOT re-target|not re-target/i,
+    'an empty turn must not re-target the same dimension',
+  );
+});
+
+test('trekresearch — Phase 5 states the no-brief default and the moot precedence matrix', () => {
+  const p5 = phase5(read());
+  // (a) no-brief default
+  assert.match(p5, /effort = 'standard'/, 'no-brief default effort must be stated');
+  assert.match(
+    p5,
+    /--project/,
+    'the no-brief default must be anchored to the absence of --project/brief.md',
+  );
+  // (b) precedence matrix — each entry independently makes the loop moot,
+  //     mirroring the --engine moot gate in Phase 4.
+  for (const token of ['--quick', '--local', 'external_research_enabled']) {
+    assert.ok(p5.includes(token), `moot matrix must name ${token}`);
+  }
+  assert.match(p5, /moot/i, 'the matrix must use the same moot vocabulary as the engine gate');
+  // (c) interaction rule — effort: high without model under a cheap profile.
+  assert.match(
+    p5,
+    /effort: high/,
+    'the interaction rule for a brief carrying effort: high without model must be stated',
+  );
+});
+
+test('trekresearch — Phase 5 restates the honesty rule for loop output', () => {
+  const p5 = phase5(read());
+  // Whitespace-tolerant: the pin is on the sentence, not on where the
+  // paragraph happens to wrap.
+  assert.match(
+    p5,
+    /more\s+turns\s+do\s+not\s+make\s+a\s+finding\s+more\s+credible/i,
+    'the honesty hard rule must be restated for the loop output',
+  );
+});
+
+test('trekresearch — Phase 5 pins survive only while the prose does (mutation control)', () => {
+  const text = read();
+  const mutated = text.replace(/research-loop-cap\.mjs/g, 'removed-cap.mjs');
+  assert.doesNotMatch(
+    phase5(mutated),
+    /research-loop-cap\.mjs/,
+    'heading-bounded Phase 5 slice must still fail on a genuine removal',
+  );
+});
+
+test('trekresearch — High-effort behavior keeps the standard/low effort sentences verbatim', () => {
+  const text = read();
+  assert.ok(
+    text.includes('Standard effort (or absent): use the existing conditional triggers.'),
+    'the standard-effort sentence must survive the Phase 5 rewrite verbatim',
+  );
+  assert.ok(
+    text.includes('Low effort: inline research only, no agent swarm'),
+    'the low-effort sentence must survive the Phase 5 rewrite verbatim',
+  );
+});
+
 // --- v5.1.1 runtime SC4 + SC7 ---
 
 test('trekresearch — SC4: low-effort fixture → resolver returns {effort: low, model: sonnet}', () => {