gsd-pi 2.18.0 → 2.20.0

package/dist/resources/extensions/gsd/tests/triage-resolution.test.ts

@@ -0,0 +1,215 @@
+/**
+ * Unit tests for GSD Triage Resolution — resolution execution and file overlap detection.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, readFileSync, writeFileSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { appendCapture, markCaptureResolved, loadAllCaptures } from "../captures.ts";
+// Import only the functions that don't depend on @gsd/pi-coding-agent
+// (triage-ui.ts imports next-action-ui.ts which imports the unavailable package)
+import { executeInject, executeReplan, detectFileOverlap, loadDeferredCaptures, loadReplanCaptures, buildQuickTaskPrompt } from "../triage-resolution.ts";
+
+function makeTempDir(prefix: string): string {
+  const dir = join(
+    tmpdir(),
+    `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function setupPlanFile(tmp: string, mid: string, sid: string, content: string): string {
+  const planDir = join(tmp, ".gsd", "milestones", mid, "slices", sid);
+  mkdirSync(planDir, { recursive: true });
+  const planPath = join(planDir, `${sid}-PLAN.md`);
+  writeFileSync(planPath, content, "utf-8");
+  return planPath;
+}
+
+const SAMPLE_PLAN = `# S01: Test Slice
+
+**Goal:** Test
+**Demo:** Test
+
+## Must-Haves
+
+- Something works
+
+## Tasks
+
+- [x] **T01: First task** \`est:1h\`
+  - Why: Setup
+  - Files: \`src/foo.ts\`, \`src/bar.ts\`
+  - Do: Build it
+  - Done when: Tests pass
+
+- [ ] **T02: Second task** \`est:1h\`
+  - Why: Feature
+  - Files: \`src/baz.ts\`, \`src/qux.ts\`
+  - Do: Build it
+  - Done when: Tests pass
+
+- [ ] **T03: Third task** \`est:30m\`
+  - Why: Polish
+  - Files: \`src/qux.ts\`, \`src/config.ts\`
+  - Do: Build it
+  - Done when: Tests pass
+
+## Files Likely Touched
+
+- \`src/foo.ts\`
+- \`src/bar.ts\`
+`;
+
+// ─── executeInject ────────────────────────────────────────────────────────────
+
+test("resolution: executeInject appends a new task to the plan", () => {
+  const tmp = makeTempDir("res-inject");
+  try {
+    const planPath = setupPlanFile(tmp, "M001", "S01", SAMPLE_PLAN);
+    const captureId = appendCapture(tmp, "add retry logic");
+    const captures = loadAllCaptures(tmp);
+    const capture = captures[0];
+
+    const newId = executeInject(tmp, "M001", "S01", capture);
+
+    assert.strictEqual(newId, "T04", "should be T04 (next after T03)");
+
+    const updated = readFileSync(planPath, "utf-8");
+    assert.ok(updated.includes("**T04:"), "should have T04 in plan");
+    assert.ok(updated.includes(capture.text), "should include capture text");
+    assert.ok(updated.includes("## Files Likely Touched"), "should preserve files section");
+
+    // T04 should appear before Files Likely Touched
+    const t04Pos = updated.indexOf("**T04:");
+    const filesPos = updated.indexOf("## Files Likely Touched");
+    assert.ok(t04Pos < filesPos, "T04 should be before Files section");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("resolution: executeInject returns null when plan doesn't exist", () => {
+  const tmp = makeTempDir("res-inject-noplan");
+  try {
+    const captureId = appendCapture(tmp, "some task");
+    const captures = loadAllCaptures(tmp);
+    const result = executeInject(tmp, "M001", "S01", captures[0]);
+    assert.strictEqual(result, null);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+// ─── executeReplan ────────────────────────────────────────────────────────────
+
+test("resolution: executeReplan writes REPLAN-TRIGGER.md", () => {
+  const tmp = makeTempDir("res-replan");
+  try {
+    setupPlanFile(tmp, "M001", "S01", SAMPLE_PLAN);
+    const captureId = appendCapture(tmp, "approach is wrong, need different strategy");
+    const captures = loadAllCaptures(tmp);
+    const capture = captures[0];
+
+    const result = executeReplan(tmp, "M001", "S01", capture);
+    assert.strictEqual(result, true);
+
+    const triggerPath = join(
+      tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-REPLAN-TRIGGER.md",
+    );
+    assert.ok(existsSync(triggerPath), "trigger file should exist");
+
+    const content = readFileSync(triggerPath, "utf-8");
+    assert.ok(content.includes(capture.id), "should include capture ID");
+    assert.ok(content.includes(capture.text), "should include capture text");
+    assert.ok(content.includes("# Replan Trigger"), "should have header");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+// ─── detectFileOverlap ───────────────────────────────────────────────────────
+
+test("resolution: detectFileOverlap finds overlapping incomplete tasks", () => {
+  const overlaps = detectFileOverlap(["src/qux.ts"], SAMPLE_PLAN);
+  assert.deepStrictEqual(overlaps, ["T02", "T03"]);
+});
+
+test("resolution: detectFileOverlap ignores completed tasks", () => {
+  // T01 is [x] and uses src/foo.ts — should NOT be returned
+  const overlaps = detectFileOverlap(["src/foo.ts"], SAMPLE_PLAN);
+  assert.deepStrictEqual(overlaps, []);
+});
+
+test("resolution: detectFileOverlap returns empty when no overlap", () => {
+  const overlaps = detectFileOverlap(["src/unrelated.ts"], SAMPLE_PLAN);
+  assert.deepStrictEqual(overlaps, []);
+});
+
+test("resolution: detectFileOverlap returns empty for empty affected files", () => {
+  assert.deepStrictEqual(detectFileOverlap([], SAMPLE_PLAN), []);
+});
+
+test("resolution: detectFileOverlap is case-insensitive", () => {
+  const overlaps = detectFileOverlap(["SRC/QUX.TS"], SAMPLE_PLAN);
+  assert.deepStrictEqual(overlaps, ["T02", "T03"]);
+});
+
+// ─── loadDeferredCaptures / loadReplanCaptures ───────────────────────────────
+
+test("resolution: loadDeferredCaptures returns only deferred captures", () => {
+  const tmp = makeTempDir("res-deferred");
+  try {
+    const id1 = appendCapture(tmp, "deferred one");
+    const id2 = appendCapture(tmp, "note one");
+    const id3 = appendCapture(tmp, "deferred two");
+
+    markCaptureResolved(tmp, id1, "defer", "deferred to S03", "future work");
+    markCaptureResolved(tmp, id2, "note", "acknowledged", "just a note");
+    markCaptureResolved(tmp, id3, "defer", "deferred to S04", "later");
+
+    const deferred = loadDeferredCaptures(tmp);
+    assert.strictEqual(deferred.length, 2);
+    assert.strictEqual(deferred[0].id, id1);
+    assert.strictEqual(deferred[1].id, id3);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("resolution: loadReplanCaptures returns only replan captures", () => {
+  const tmp = makeTempDir("res-replan-load");
+  try {
+    const id1 = appendCapture(tmp, "needs replan");
+    const id2 = appendCapture(tmp, "just a note");
+
+    markCaptureResolved(tmp, id1, "replan", "replan triggered", "approach changed");
+    markCaptureResolved(tmp, id2, "note", "acknowledged", "info only");
+
+    const replans = loadReplanCaptures(tmp);
+    assert.strictEqual(replans.length, 1);
+    assert.strictEqual(replans[0].id, id1);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+// ─── buildQuickTaskPrompt ────────────────────────────────────────────────────
+
+test("resolution: buildQuickTaskPrompt includes capture text and ID", () => {
+  const prompt = buildQuickTaskPrompt({
+    id: "CAP-abc123",
+    text: "add retry logic to OAuth",
+    timestamp: "2026-03-15T20:00:00Z",
+    status: "resolved",
+    classification: "quick-task",
+  });
+
+  assert.ok(prompt.includes("CAP-abc123"), "should include capture ID");
+  assert.ok(prompt.includes("add retry logic to OAuth"), "should include capture text");
+  assert.ok(prompt.includes("Quick Task"), "should have Quick Task header");
+  assert.ok(prompt.includes("Do NOT modify"), "should warn about plan files");
+});

package/dist/resources/extensions/gsd/tests/unit-runtime.test.ts

@@ -1,4 +1,4 @@
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import {
@@ -65,6 +65,30 @@ console.log("\n=== runtime record cleanup ===");
   assertEq(loaded, null, "record removed");
 }
 
+console.log("\n=== hook unit type sanitization (slash in unitType) ===");
+{
+  // Hook units have unitType like "hook/code-review" with a slash
+  // This should NOT create a subdirectory - the slash must be sanitized
+  const hookRecord = writeUnitRuntimeRecord(base, "hook/code-review", "M100/S02/T10", 2000, { phase: "dispatched" });
+  assertEq(hookRecord.unitType, "hook/code-review", "unitType preserved in record");
+  assertEq(hookRecord.unitId, "M100/S02/T10", "unitId preserved in record");
+  
+  const loaded = readUnitRuntimeRecord(base, "hook/code-review", "M100/S02/T10");
+  assertTrue(loaded !== null, "hook record readable");
+  assertEq(loaded!.phase, "dispatched", "hook phase correct");
+  
+  // Verify the file is in the units dir, not in a subdirectory
+  const unitsDir = join(base, ".gsd", "runtime", "units");
+  const files = readdirSync(unitsDir);
+  const hookFile = files.find((f: string) => f.includes("hook-code-review"));
+  assertTrue(hookFile !== undefined, "hook file exists with sanitized name");
+  assertTrue(!files.some((f: string) => f === "hook"), "no 'hook' subdirectory created");
+  
+  clearUnitRuntimeRecord(base, "hook/code-review", "M100/S02/T10");
+  const cleared = readUnitRuntimeRecord(base, "hook/code-review", "M100/S02/T10");
+  assertEq(cleared, null, "hook record removed");
+}
+
 // ─── Must-have durability integration tests ───────────────────────────────
 
 // Create a separate temp base for must-have tests to avoid interference

package/dist/resources/extensions/gsd/tests/visualizer-critical-path.test.ts

@@ -0,0 +1,145 @@
+// Tests for critical path algorithm.
+// Tests computeCriticalPath with known DAG structures.
+
+import { computeCriticalPath } from "../visualizer-data.js";
+import type { VisualizerMilestone } from "../visualizer-data.js";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+function makeMs(id: string, status: "complete" | "active" | "pending", dependsOn: string[], slices: any[] = []): VisualizerMilestone {
+  return { id, title: id, status, dependsOn, slices };
+}
+
+function makeSlice(id: string, done: boolean, depends: string[] = []) {
+  return { id, title: id, done, active: false, risk: "low", depends, tasks: [] };
+}
+
+// ─── Linear chain ───────────────────────────────────────────────────────────
+
+console.log("\n=== Critical Path: Linear Chain ===");
+
+{
+  // M001 -> M002 -> M003
+  const milestones = [
+    makeMs("M001", "complete", []),
+    makeMs("M002", "active", ["M001"], [
+      makeSlice("S01", true),
+      makeSlice("S02", false, ["S01"]),
+    ]),
+    makeMs("M003", "pending", ["M002"]),
+  ];
+
+  const cp = computeCriticalPath(milestones);
+  assertTrue(cp.milestonePath.length > 0, "linear chain has critical path");
+  assertTrue(cp.milestonePath.includes("M002"), "M002 is on critical path");
+  assertTrue(cp.milestonePath.includes("M003"), "M003 is on critical path");
+  assertEq(cp.milestoneSlack.get("M002"), 0, "M002 has zero slack");
+  assertEq(cp.milestoneSlack.get("M003"), 0, "M003 has zero slack");
+}
+
+// ─── Diamond DAG ────────────────────────────────────────────────────────────
+
+console.log("\n=== Critical Path: Diamond DAG ===");
+
+{
+  // M001 -> M002 -> M004
+  // M001 -> M003 -> M004
+  // M002 has 3 incomplete slices, M003 has 1 incomplete slice
+  const milestones = [
+    makeMs("M001", "complete", []),
+    makeMs("M002", "active", ["M001"], [
+      makeSlice("S01", false),
+      makeSlice("S02", false),
+      makeSlice("S03", false),
+    ]),
+    makeMs("M003", "pending", ["M001"], [
+      makeSlice("S01", false),
+    ]),
+    makeMs("M004", "pending", ["M002", "M003"]),
+  ];
+
+  const cp = computeCriticalPath(milestones);
+  assertTrue(cp.milestonePath.length >= 2, "diamond DAG has critical path");
+  // M002 has weight 3 (3 incomplete), M003 has weight 1
+  // Critical path should go through M002 (longer)
+  assertTrue(cp.milestonePath.includes("M002"), "M002 (heavier) is on critical path");
+
+  // M003 should have non-zero slack since it's lighter
+  const m003Slack = cp.milestoneSlack.get("M003") ?? -1;
+  assertTrue(m003Slack > 0, "M003 has positive slack (lighter branch)");
+}
+
+// ─── Independent branches ───────────────────────────────────────────────────
+
+console.log("\n=== Critical Path: Independent Branches ===");
+
+{
+  // M001 (no deps), M002 (no deps), M003 (no deps)
+  const milestones = [
+    makeMs("M001", "active", [], [makeSlice("S01", false)]),
+    makeMs("M002", "pending", [], [makeSlice("S01", false), makeSlice("S02", false)]),
+    makeMs("M003", "pending", [], [makeSlice("S01", false)]),
+  ];
+
+  const cp = computeCriticalPath(milestones);
+  assertTrue(cp.milestonePath.length >= 1, "independent branches have at least one critical node");
+  // M002 has the most incomplete slices, should be critical
+  assertTrue(cp.milestonePath.includes("M002"), "M002 (longest) is on critical path");
+}
+
+// ─── Slice-level critical path ──────────────────────────────────────────────
+
+console.log("\n=== Critical Path: Slice-level ===");
+
+{
+  // Active milestone with slice dependencies: S01 -> S02 -> S04, S01 -> S03
+  const milestones = [
+    makeMs("M001", "active", [], [
+      makeSlice("S01", true),
+      makeSlice("S02", false, ["S01"]),
+      makeSlice("S03", false, ["S01"]),
+      makeSlice("S04", false, ["S02"]),
+    ]),
+  ];
+
+  const cp = computeCriticalPath(milestones);
+  assertTrue(cp.slicePath.length > 0, "has slice-level critical path");
+  assertTrue(cp.slicePath.includes("S02"), "S02 is on slice critical path");
+  assertTrue(cp.slicePath.includes("S04"), "S04 is on slice critical path");
+
+  // S03 should have non-zero slack (it's a shorter branch)
+  const s03Slack = cp.sliceSlack.get("S03") ?? -1;
+  assertTrue(s03Slack > 0, "S03 has positive slack (shorter branch)");
+}
+
+// ─── Empty milestones ───────────────────────────────────────────────────────
+
+console.log("\n=== Critical Path: Empty ===");
+
+{
+  const cp = computeCriticalPath([]);
+  assertEq(cp.milestonePath.length, 0, "empty milestones produce empty path");
+  assertEq(cp.slicePath.length, 0, "empty milestones produce empty slice path");
+}
+
+// ─── Single milestone ───────────────────────────────────────────────────────
+
+console.log("\n=== Critical Path: Single Milestone ===");
+
+{
+  const milestones = [
+    makeMs("M001", "active", [], [
+      makeSlice("S01", false),
+      makeSlice("S02", false),
+    ]),
+  ];
+
+  const cp = computeCriticalPath(milestones);
+  assertTrue(cp.milestonePath.length === 1, "single milestone is its own critical path");
+  assertEq(cp.milestonePath[0], "M001", "M001 is the critical node");
+}
+
+// ─── Report ─────────────────────────────────────────────────────────────────
+
+report();

package/dist/resources/extensions/gsd/tests/visualizer-data.test.ts

@@ -0,0 +1,290 @@
+// Tests for GSD visualizer data loader.
+// Verifies the VisualizerData interface shape and source-file contracts.
+
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createTestContext } from "./test-helpers.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const { assertTrue, report } = createTestContext();
+
+const dataPath = join(__dirname, "..", "visualizer-data.ts");
+const dataSrc = readFileSync(dataPath, "utf-8");
+
+console.log("\n=== visualizer-data.ts source contracts ===");
+
+// Interface exports
+assertTrue(
+  dataSrc.includes("export interface VisualizerData"),
+  "exports VisualizerData interface",
+);
+
+assertTrue(
+  dataSrc.includes("export interface VisualizerMilestone"),
+  "exports VisualizerMilestone interface",
+);
+
+assertTrue(
+  dataSrc.includes("export interface VisualizerSlice"),
+  "exports VisualizerSlice interface",
+);
+
+assertTrue(
+  dataSrc.includes("export interface VisualizerTask"),
+  "exports VisualizerTask interface",
+);
+
+// New interfaces
+assertTrue(
+  dataSrc.includes("export interface CriticalPathInfo"),
+  "exports CriticalPathInfo interface",
+);
+
+assertTrue(
+  dataSrc.includes("export interface AgentActivityInfo"),
+  "exports AgentActivityInfo interface",
+);
+
+assertTrue(
+  dataSrc.includes("export interface ChangelogEntry"),
+  "exports ChangelogEntry interface",
+);
+
+assertTrue(
+  dataSrc.includes("export interface ChangelogInfo"),
+  "exports ChangelogInfo interface",
+);
+
+// Function export
+assertTrue(
+  dataSrc.includes("export async function loadVisualizerData"),
+  "exports loadVisualizerData function",
+);
+
+assertTrue(
+  dataSrc.includes("export function computeCriticalPath"),
+  "exports computeCriticalPath function",
+);
+
+// Data source usage
+assertTrue(
+  dataSrc.includes("deriveState"),
+  "uses deriveState for state derivation",
+);
+
+assertTrue(
+  dataSrc.includes("findMilestoneIds"),
+  "uses findMilestoneIds to enumerate milestones",
+);
+
+assertTrue(
+  dataSrc.includes("parseRoadmap"),
+  "uses parseRoadmap for roadmap parsing",
+);
+
+assertTrue(
+  dataSrc.includes("parsePlan"),
+  "uses parsePlan for plan parsing",
+);
+
+assertTrue(
+  dataSrc.includes("parseSummary"),
+  "uses parseSummary for changelog parsing",
+);
+
+assertTrue(
+  dataSrc.includes("getLedger"),
+  "uses getLedger for in-memory metrics",
+);
+
+assertTrue(
+  dataSrc.includes("loadLedgerFromDisk"),
+  "uses loadLedgerFromDisk as fallback",
+);
+
+assertTrue(
+  dataSrc.includes("getProjectTotals"),
+  "uses getProjectTotals for aggregation",
+);
+
+assertTrue(
+  dataSrc.includes("aggregateByPhase"),
+  "uses aggregateByPhase",
+);
+
+assertTrue(
+  dataSrc.includes("aggregateBySlice"),
+  "uses aggregateBySlice",
+);
+
+assertTrue(
+  dataSrc.includes("aggregateByModel"),
+  "uses aggregateByModel",
+);
+
+// Interface fields
+assertTrue(
+  dataSrc.includes("dependsOn: string[]"),
+  "VisualizerMilestone has dependsOn field",
+);
+
+assertTrue(
+  dataSrc.includes("depends: string[]"),
+  "VisualizerSlice has depends field",
+);
+
+assertTrue(
+  dataSrc.includes("totals: ProjectTotals | null"),
+  "VisualizerData has nullable totals",
+);
+
+assertTrue(
+  dataSrc.includes("units: UnitMetrics[]"),
+  "VisualizerData has units array",
+);
+
+// New data model fields
+assertTrue(
+  dataSrc.includes("criticalPath: CriticalPathInfo"),
+  "VisualizerData has criticalPath field",
+);
+
+assertTrue(
+  dataSrc.includes("remainingSliceCount: number"),
+  "VisualizerData has remainingSliceCount field",
+);
+
+assertTrue(
+  dataSrc.includes("agentActivity: AgentActivityInfo | null"),
+  "VisualizerData has agentActivity field",
+);
+
+assertTrue(
+  dataSrc.includes("changelog: ChangelogInfo"),
+  "VisualizerData has changelog field",
+);
+
+// Verify overlay source exists and imports data module
+const overlayPath = join(__dirname, "..", "visualizer-overlay.ts");
+const overlaySrc = readFileSync(overlayPath, "utf-8");
+
+console.log("\n=== visualizer-overlay.ts source contracts ===");
+
+assertTrue(
+  overlaySrc.includes("export class GSDVisualizerOverlay"),
+  "exports GSDVisualizerOverlay class",
+);
+
+assertTrue(
+  overlaySrc.includes("loadVisualizerData"),
+  "overlay uses loadVisualizerData",
+);
+
+assertTrue(
+  overlaySrc.includes("renderProgressView"),
+  "overlay delegates to renderProgressView",
+);
+
+assertTrue(
+  overlaySrc.includes("renderDepsView"),
+  "overlay delegates to renderDepsView",
+);
+
+assertTrue(
+  overlaySrc.includes("renderMetricsView"),
+  "overlay delegates to renderMetricsView",
+);
+
+assertTrue(
+  overlaySrc.includes("renderTimelineView"),
+  "overlay delegates to renderTimelineView",
+);
+
+assertTrue(
+  overlaySrc.includes("renderAgentView"),
+  "overlay delegates to renderAgentView",
+);
+
+assertTrue(
+  overlaySrc.includes("renderChangelogView"),
+  "overlay delegates to renderChangelogView",
+);
+
+assertTrue(
+  overlaySrc.includes("renderExportView"),
+  "overlay delegates to renderExportView",
+);
+
+assertTrue(
+  overlaySrc.includes("handleInput"),
+  "overlay has handleInput method",
+);
+
+assertTrue(
+  overlaySrc.includes("dispose"),
+  "overlay has dispose method",
+);
+
+assertTrue(
+  overlaySrc.includes("wrapInBox"),
+  "overlay has wrapInBox helper",
+);
+
+assertTrue(
+  overlaySrc.includes("activeTab"),
+  "overlay tracks active tab",
+);
+
+assertTrue(
+  overlaySrc.includes("scrollOffsets"),
+  "overlay tracks per-tab scroll offsets",
+);
+
+assertTrue(
+  overlaySrc.includes("filterMode"),
+  "overlay has filterMode state",
+);
+
+assertTrue(
+  overlaySrc.includes("filterText"),
+  "overlay has filterText state",
+);
+
+assertTrue(
+  overlaySrc.includes("filterField"),
+  "overlay has filterField state",
+);
+
+assertTrue(
+  overlaySrc.includes("TAB_COUNT"),
+  "overlay defines TAB_COUNT",
+);
+
+assertTrue(
+  overlaySrc.includes("7 Export"),
+  "overlay has 7 tab labels",
+);
+
+// Verify commands.ts integration
+const commandsPath = join(__dirname, "..", "commands.ts");
+const commandsSrc = readFileSync(commandsPath, "utf-8");
+
+console.log("\n=== commands.ts integration ===");
+
+assertTrue(
+  commandsSrc.includes('"visualize"'),
+  "commands.ts has visualize in subcommands array",
+);
+
+assertTrue(
+  commandsSrc.includes("GSDVisualizerOverlay"),
+  "commands.ts imports GSDVisualizerOverlay",
+);
+
+assertTrue(
+  commandsSrc.includes("handleVisualize"),
+  "commands.ts has handleVisualize handler",
+);
+
+report();