gsd-pi 2.74.0-dev.2b524c3 → 2.74.0-dev.b741afb

package/src/resources/extensions/gsd/tests/commands-session-report.test.ts

@@ -0,0 +1,82 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+// Test the formatting logic used by session-report.
+// The actual handler requires runtime context (metrics module), so we
+// test the core formatting and aggregation patterns.
+
+test("session-report: format cost correctly", () => {
+  // Simple cost formatting test
+  const formatCost = (cost: number): string => {
+    if (cost < 0.01) return "<$0.01";
+    return `$${cost.toFixed(2)}`;
+  };
+
+  assert.equal(formatCost(0), "<$0.01");
+  assert.equal(formatCost(0.005), "<$0.01");
+  assert.equal(formatCost(1.5), "$1.50");
+  assert.equal(formatCost(10.999), "$11.00");
+});
+
+test("session-report: format token count", () => {
+  const formatTokenCount = (count: number): string => {
+    if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
+    if (count >= 1_000) return `${(count / 1_000).toFixed(1)}K`;
+    return String(count);
+  };
+
+  assert.equal(formatTokenCount(500), "500");
+  assert.equal(formatTokenCount(1500), "1.5K");
+  assert.equal(formatTokenCount(1_200_000), "1.2M");
+});
+
+test("session-report: aggregate by model", () => {
+  interface UnitMetric {
+    model: string;
+    cost: number;
+  }
+
+  const units: UnitMetric[] = [
+    { model: "opus", cost: 1.0 },
+    { model: "opus", cost: 0.8 },
+    { model: "sonnet", cost: 0.3 },
+    { model: "sonnet", cost: 0.5 },
+    { model: "sonnet", cost: 0.2 },
+  ];
+
+  const byModel = new Map<string, { count: number; cost: number }>();
+  for (const u of units) {
+    const existing = byModel.get(u.model) ?? { count: 0, cost: 0 };
+    existing.count++;
+    existing.cost += u.cost;
+    byModel.set(u.model, existing);
+  }
+
+  const opus = byModel.get("opus")!;
+  assert.equal(opus.count, 2);
+  assert.ok(Math.abs(opus.cost - 1.8) < 0.01);
+
+  const sonnet = byModel.get("sonnet")!;
+  assert.equal(sonnet.count, 3);
+  assert.ok(Math.abs(sonnet.cost - 1.0) < 0.01);
+});
+
+test("session-report: --json flag detection", () => {
+  const args1 = "--json";
+  const args2 = "--save --json";
+  const args3 = "something else";
+
+  assert.ok(args1.includes("--json"));
+  assert.ok(args2.includes("--json"));
+  assert.ok(!args3.includes("--json"));
+});
+
+test("session-report: --save flag detection", () => {
+  const args1 = "--save";
+  const args2 = "--save --json";
+  const args3 = "";
+
+  assert.ok(args1.includes("--save"));
+  assert.ok(args2.includes("--save"));
+  assert.ok(!args3.includes("--save"));
+});

package/src/resources/extensions/gsd/tests/commands-ship.test.ts

@@ -0,0 +1,71 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+// Test the PR content generation logic used by /gsd ship.
+// Full integration requires gh CLI + git, so we test the text generation.
+
+test("ship: generates TL;DR format", () => {
+  // Simulate generatePRContent output structure
+  const milestoneId = "M001";
+  const milestoneTitle = "User authentication system";
+
+  const title = `feat: ${milestoneTitle}`;
+  assert.equal(title, "feat: User authentication system");
+  assert.ok(title.length < 80); // PR title should be short
+});
+
+test("ship: --dry-run flag detection", () => {
+  const args1 = "--dry-run";
+  const args2 = "--draft --dry-run";
+  const args3 = "--draft";
+
+  assert.ok(args1.includes("--dry-run"));
+  assert.ok(args2.includes("--dry-run"));
+  assert.ok(!args3.includes("--dry-run"));
+});
+
+test("ship: --base flag parsing", () => {
+  const args = "--base develop --draft";
+  const baseMatch = args.match(/--base\s+(\S+)/);
+  assert.ok(baseMatch);
+  assert.equal(baseMatch[1], "develop");
+});
+
+test("ship: --base flag absent defaults", () => {
+  const args = "--draft";
+  const baseMatch = args.match(/--base\s+(\S+)/);
+  assert.equal(baseMatch, null);
+});
+
+test("ship: --force flag detection", () => {
+  const args1 = "--force";
+  const args2 = "";
+
+  assert.ok(args1.includes("--force"));
+  assert.ok(!args2.includes("--force"));
+});
+
+test("ship: change type checklist format", () => {
+  const checklist = [
+    "- [x] `feat` — New feature or capability",
+    "- [ ] `fix` — Bug fix",
+    "- [ ] `refactor` — Code restructuring",
+    "- [ ] `test` — Adding or updating tests",
+    "- [ ] `docs` — Documentation only",
+    "- [ ] `chore` — Build, CI, or tooling changes",
+  ];
+
+  // Verify format matches CONTRIBUTING.md expectations
+  for (const line of checklist) {
+    assert.match(line, /^- \[[ x]\] `\w+` — .+$/);
+  }
+});
+
+test("ship: PR body contains required sections", () => {
+  const requiredSections = ["## TL;DR", "## Change type"];
+  const body = "## TL;DR\n\n**What:** Ship M001\n\n## Change type\n\n- [x] `feat`";
+
+  for (const section of requiredSections) {
+    assert.ok(body.includes(section), `Missing section: ${section}`);
+  }
+});

package/src/resources/extensions/gsd/tests/commands-workflow-custom.test.ts

@@ -217,6 +217,20 @@ describe("workflow command handler", () => {
     );
   });
 
+  it("preserves quoted workflow run overrides (#4130)", async () => {
+    const { parseWorkflowRunArgs } = await import("../commands/handlers/workflow.ts");
+    assert.deepStrictEqual(
+      parseWorkflowRunArgs('demo-workflow target="multi word target" region=\'us east\''),
+      {
+        defName: "demo-workflow",
+        overrides: {
+          target: "multi word target",
+          region: "us east",
+        },
+      },
+    );
+  });
+
   it("'/gsd workflow run nonexistent' shows error for missing definition", async () => {
     const { handled, notifications } = await callHandler("workflow run nonexistent-def-12345");
     assert.ok(handled, "should be handled");

package/src/resources/extensions/gsd/tests/extension-bootstrap-isolation.test.ts

@@ -0,0 +1,154 @@
+// Structural contracts for GSD extension bootstrap isolation.
+//
+// The /gsd command must survive failures in the full extension bootstrap
+// (register-extension.ts). This guards against the regression where a
+// Windows-specific import failure in register-shortcuts.ts silently
+// prevented /gsd from being registered at all (#4168, #4172).
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const indexSrc = readFileSync(join(__dirname, "../index.ts"), "utf-8");
+const registerExtSrc = readFileSync(
+  join(__dirname, "../bootstrap/register-extension.ts"),
+  "utf-8",
+);
+
+// ─── index.ts: core /gsd command must be registered before full bootstrap ─────
+
+describe("index.ts bootstrap isolation", () => {
+  test("imports registerGSDCommand from commands/index.js separately", () => {
+    assert.ok(
+      indexSrc.includes('./commands/index.js"') || indexSrc.includes("./commands/index.js'"),
+      "index.ts must import registerGSDCommand from ./commands/index.js",
+    );
+  });
+
+  test("calls registerGSDCommand before importing register-extension.js", () => {
+    const gsdCommandCallPos = indexSrc.indexOf("registerGSDCommand(pi)");
+    const bootstrapImportPos = indexSrc.indexOf(
+      './bootstrap/register-extension.js"',
+    );
+
+    assert.ok(gsdCommandCallPos >= 0, "must call registerGSDCommand(pi)");
+    assert.ok(bootstrapImportPos >= 0, "must import register-extension.js");
+    assert.ok(
+      gsdCommandCallPos < bootstrapImportPos,
+      "registerGSDCommand(pi) must be called BEFORE importing register-extension.js",
+    );
+  });
+
+  test("wraps register-extension.js import in try-catch", () => {
+    // The dynamic import of register-extension.js must be inside a try block
+    const tryPos = indexSrc.indexOf("try {");
+    const bootstrapImportPos = indexSrc.indexOf(
+      './bootstrap/register-extension.js"',
+    );
+    const catchPos = indexSrc.indexOf("catch (err)");
+
+    assert.ok(tryPos >= 0, "must have try block");
+    assert.ok(catchPos >= 0, "must have catch block");
+    assert.ok(
+      tryPos < bootstrapImportPos && bootstrapImportPos < catchPos,
+      "register-extension.js import must be wrapped in try-catch",
+    );
+  });
+
+  test("logs warning on bootstrap failure via workflow-logger", () => {
+    assert.ok(
+      indexSrc.includes("logWarning"),
+      "must use logWarning when bootstrap fails",
+    );
+    assert.ok(
+      indexSrc.includes("Extension setup partially failed"),
+      "warning message must indicate partial failure with /gsd still available",
+    );
+  });
+});
+
+// ─── register-extension.ts: no double-registration + defensive wrapping ───────
+
+describe("register-extension.ts defensive registration", () => {
+  test("does NOT import or call registerGSDCommand (avoids double-registration)", () => {
+    // registerGSDCommand is now called by index.ts, not register-extension.ts
+    assert.ok(
+      !registerExtSrc.includes("import { registerGSDCommand }"),
+      "register-extension.ts must NOT import registerGSDCommand",
+    );
+
+    // Check the function body of registerGsdExtension doesn't call it
+    const funcBodyStart = registerExtSrc.indexOf(
+      "export function registerGsdExtension",
+    );
+    const funcBody = registerExtSrc.slice(funcBodyStart);
+    assert.ok(
+      !funcBody.includes("registerGSDCommand(pi)"),
+      "registerGsdExtension must NOT call registerGSDCommand(pi)",
+    );
+  });
+
+  test("still registers worktree, exit, and kill commands", () => {
+    const funcBodyStart = registerExtSrc.indexOf(
+      "export function registerGsdExtension",
+    );
+    const funcBody = registerExtSrc.slice(funcBodyStart);
+
+    assert.ok(
+      funcBody.includes("registerWorktreeCommand(pi)"),
+      "must register worktree command",
+    );
+    assert.ok(
+      funcBody.includes("registerExitCommand(pi)"),
+      "must register exit command",
+    );
+    assert.ok(
+      funcBody.includes('"kill"'),
+      "must register kill command",
+    );
+  });
+
+  test("wraps non-critical registrations in individual try-catch blocks", () => {
+    const funcBodyStart = registerExtSrc.indexOf(
+      "export function registerGsdExtension",
+    );
+    const funcBody = registerExtSrc.slice(funcBodyStart);
+
+    // Each non-critical registration should be wrapped with error handling
+    const registrationNames = [
+      "dynamic-tools",
+      "db-tools",
+      "journal-tools",
+      "query-tools",
+      "shortcuts",
+      "hooks",
+    ];
+
+    for (const name of registrationNames) {
+      assert.ok(
+        funcBody.includes(`"${name}"`),
+        `non-critical registration "${name}" must be present`,
+      );
+    }
+
+    // Must have try-catch inside the registration loop
+    assert.ok(
+      funcBody.includes("try {") && funcBody.includes("catch (err)"),
+      "must have try-catch for non-critical registrations",
+    );
+  });
+
+  test("logs warning when a non-critical registration fails", () => {
+    assert.ok(
+      registerExtSrc.includes("Failed to register"),
+      "must log descriptive warning for individual registration failures",
+    );
+    assert.ok(
+      registerExtSrc.includes("logWarning"),
+      "must use logWarning from workflow-logger",
+    );
+  });
+});

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

@@ -0,0 +1,337 @@
+/**
+ * graph-context.test.ts — Unit tests for inlineGraphSubgraph().
+ *
+ * Covers:
+ *   Group 1: Null-return paths (empty term, zero nodes, missing graph.json)
+ *   Group 2: Correct output formatting (nodes, edges, stale annotation)
+ *   Group 3: Node formatting (description, confidence, no-description)
+ *
+ * Testing strategy:
+ *   @gsd-build/mcp-server is dynamically imported inside inlineGraphSubgraph().
+ *   Because node:test (v22) does not support mock.module() without the
+ *   --experimental-test-module-mocks flag (not enabled in test:unit), we
+ *   exercise the real graphQuery/graphStatus functions by controlling the
+ *   on-disk graph.json that those functions read. This is a clean, deterministic
+ *   approach that avoids all module-level mocking.
+ *
+ *   Fixture layout per test:
+ *     <tmpDir>/.gsd/graphs/graph.json
+ *
+ *   builtAt controls staleness: old timestamp → stale, recent → fresh.
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { inlineGraphSubgraph } from "../graph-context.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+interface TestNode {
+  id: string;
+  label: string;
+  type: string;
+  confidence: string;
+  description?: string;
+  sourceFile?: string;
+}
+
+interface TestEdge {
+  from: string;
+  to: string;
+  type: string;
+  confidence: string;
+}
+
+interface GraphFixture {
+  nodes: TestNode[];
+  edges: TestEdge[];
+  /** ISO timestamp for graph.builtAt. Controls staleness. Default: recent (not stale). */
+  builtAt?: string;
+}
+
+/** Returns an ISO timestamp that is stale (> 24h ago). */
+function staleTimestamp(hoursAgo = 26): string {
+  return new Date(Date.now() - hoursAgo * 60 * 60 * 1000).toISOString();
+}
+
+/** Returns an ISO timestamp that is fresh (< 24h ago). */
+function freshTimestamp(): string {
+  return new Date(Date.now() - 30 * 60 * 1000).toISOString(); // 30 minutes ago
+}
+
+/**
+ * Creates a temp project directory with a .gsd/graphs/graph.json file.
+ * Returns the projectDir path. Caller is responsible for cleanup.
+ */
+function makeProjectDir(fixture: GraphFixture): string {
+  const projectDir = mkdtempSync(join(tmpdir(), "graph-ctx-test-"));
+  const gsdDir = join(projectDir, ".gsd");
+  const graphsDir = join(gsdDir, "graphs");
+  mkdirSync(graphsDir, { recursive: true });
+
+  const graph = {
+    nodes: fixture.nodes,
+    edges: fixture.edges,
+    builtAt: fixture.builtAt ?? freshTimestamp(),
+  };
+
+  writeFileSync(join(graphsDir, "graph.json"), JSON.stringify(graph), "utf-8");
+  return projectDir;
+}
+
+/** Removes a temp directory, suppressing errors on Windows. */
+function cleanup(dir: string): void {
+  try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+}
+
+/** Minimal node factory. */
+function makeNode(overrides: Partial<TestNode> & { id: string; label: string }): TestNode {
+  return {
+    type: "CLASS",
+    confidence: "INFERRED",
+    ...overrides,
+  };
+}
+
+/** Minimal edge factory. */
+function makeEdge(overrides: Partial<TestEdge> & { from: string; to: string }): TestEdge {
+  return {
+    type: "CALLS",
+    confidence: "INFERRED",
+    ...overrides,
+  };
+}
+
+// ─── Group 1: Null returns ────────────────────────────────────────────────────
+
+describe("inlineGraphSubgraph — null returns", () => {
+  it("returns null immediately for empty string term", async () => {
+    // No graph.json needed — exits before any file I/O
+    const result = await inlineGraphSubgraph("/tmp/nonexistent", "", { budget: 3000 });
+    assert.strictEqual(result, null);
+  });
+
+  it("returns null for whitespace-only term", async () => {
+    const result = await inlineGraphSubgraph("/tmp/nonexistent", "   ", { budget: 3000 });
+    assert.strictEqual(result, null);
+  });
+
+  it("returns null when graphQuery returns zero nodes (no matching term in graph)", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [makeNode({ id: "n1", label: "AuthService" })],
+      edges: [],
+    });
+    try {
+      // "zzznomatch999" is intentionally absent from the fixture
+      const result = await inlineGraphSubgraph(projectDir, "zzznomatch999", { budget: 3000 });
+      assert.strictEqual(result, null);
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("returns null (no throw) when graph.json is missing", async () => {
+    // A project dir with no .gsd directory at all — graphQuery returns zero nodes
+    const projectDir = mkdtempSync(join(tmpdir(), "graph-ctx-nofile-"));
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "auth", { budget: 3000 });
+      assert.strictEqual(result, null);
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+});
+
+// ─── Group 2: Correct output formatting ──────────────────────────────────────
+
+describe("inlineGraphSubgraph — correct output", () => {
+  it("returns block with section header and node labels when term matches", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [
+        makeNode({ id: "n1", label: "UserService" }),
+        makeNode({ id: "n2", label: "UserRepository" }),
+      ],
+      edges: [],
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "User", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(result!.includes("### Knowledge Graph Context"), "should include section header");
+      assert.ok(result!.includes("UserService"), "should include first node label");
+      assert.ok(result!.includes("UserRepository"), "should include second node label");
+      assert.ok(result!.includes("Nodes (2)"), "should show node count");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("does not include Relations section when edges array is empty", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [makeNode({ id: "n1", label: "AuthController" })],
+      edges: [],
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Auth", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(!result!.includes("Relations"), "should not include Relations section for zero edges");
+      assert.ok(!result!.includes("⚠"), "should not include stale warning for fresh graph");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("includes Relations section when edges are present", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [
+        makeNode({ id: "n1", label: "AuthService" }),
+        makeNode({ id: "n2", label: "UserRepo" }),
+      ],
+      edges: [makeEdge({ from: "n1", to: "n2", type: "CALLS" })],
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Auth", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(result!.includes("Relations (1)"), "should show edge count");
+      assert.ok(result!.includes("→[CALLS]→"), "should include edge type in arrow notation");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("includes stale annotation when graph was built more than 24h ago", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [makeNode({ id: "n1", label: "AuthService" })],
+      edges: [],
+      builtAt: staleTimestamp(26), // 26 hours ago → stale
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Auth", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(result!.includes("⚠ Graph last built"), "should include stale annotation");
+      assert.ok(result!.includes("h ago"), "should include hours-ago text");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("does not include stale annotation for a fresh graph", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [makeNode({ id: "n1", label: "AuthService" })],
+      edges: [],
+      builtAt: freshTimestamp(), // 30 minutes ago → not stale
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Auth", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(!result!.includes("⚠"), "should not include stale annotation for fresh graph");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("returns valid block even when graph.json has corrupted builtAt (graphStatus throws internally)", async () => {
+    // Write a graph.json with an invalid builtAt — graphStatus will catch and return {exists: false}
+    // inlineGraphSubgraph should still return the node block without stale annotation
+    const projectDir = mkdtempSync(join(tmpdir(), "graph-ctx-corrupt-"));
+    const gsdDir = join(projectDir, ".gsd");
+    const graphsDir = join(gsdDir, "graphs");
+    mkdirSync(graphsDir, { recursive: true });
+
+    const graph = {
+      nodes: [{ id: "n1", label: "AuthController", type: "CLASS", confidence: "INFERRED" }],
+      edges: [],
+      builtAt: "NOT-A-DATE", // invalid ISO — will cause Date.now() - NaN to produce NaN
+    };
+    writeFileSync(join(graphsDir, "graph.json"), JSON.stringify(graph), "utf-8");
+
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Auth", { budget: 3000 });
+      // graphQuery reads the file and finds the node; graphStatus may return {exists: true, stale: false/true}
+      // Either way, function must not throw and must return a string with node content
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(result!.includes("AuthController"), "should include node label");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("passes the budget option to graphQuery (enforces node count limit)", async () => {
+    // Each node uses ~20 tokens. With budget=20, only ~1 node should be returned.
+    // Build a graph with many nodes all matching the same term.
+    const nodes: TestNode[] = Array.from({ length: 10 }, (_, i) =>
+      makeNode({ id: `n${i}`, label: `AuthModule${i}` })
+    );
+    const projectDir = makeProjectDir({ nodes, edges: [] });
+    try {
+      const resultSmall = await inlineGraphSubgraph(projectDir, "Auth", { budget: 20 });
+      const resultLarge = await inlineGraphSubgraph(projectDir, "Auth", { budget: 10000 });
+
+      // Both should return something (at least 1 node matches)
+      assert.ok(resultSmall !== null, "small-budget result should not be null");
+      assert.ok(resultLarge !== null, "large-budget result should not be null");
+
+      // With a very small budget (20 tokens ≈ 1 node), fewer nodes should appear
+      const smallNodeCount = (resultSmall!.match(/- \*\*/g) || []).length;
+      const largeNodeCount = (resultLarge!.match(/- \*\*/g) || []).length;
+      assert.ok(
+        smallNodeCount <= largeNodeCount,
+        `small-budget should return <= nodes than large-budget (got ${smallNodeCount} vs ${largeNodeCount})`,
+      );
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+});
+
+// ─── Group 3: Node formatting ─────────────────────────────────────────────────
+
+describe("inlineGraphSubgraph — node formatting", () => {
+  it("includes description after em-dash when node has description", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [makeNode({ id: "n1", label: "JwtValidator", description: "JWT validation" })],
+      edges: [],
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Jwt", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(result!.includes("— JWT validation"), "should include description after em-dash");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("omits em-dash suffix when node has no description", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [makeNode({ id: "n1", label: "TokenStore" })], // no description
+      edges: [],
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Token", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      const lines = result!.split("\n");
+      const nodeLine = lines.find((l) => l.includes("TokenStore"));
+      assert.ok(nodeLine !== undefined, "node line should be present");
+      assert.ok(!nodeLine.includes("—"), "node line should not include em-dash when no description");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("includes confidence tier in the node output line", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [makeNode({ id: "n1", label: "AuthService", confidence: "EXTRACTED" })],
+      edges: [],
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Auth", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(result!.includes("EXTRACTED"), "should include the confidence tier in node line");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+});