gsd-pi 2.77.0-dev.c9c8932c6 → 2.77.0-dev.cfd69e714

package/src/resources/extensions/gsd/tests/milestone-scope-classifier.test.ts

@@ -0,0 +1,187 @@
+// GSD-2 — #4781: classifier behavior matrix. Pure-function tests, no I/O.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  classifyMilestoneScope,
+  type MilestoneScopeInput,
+} from "../milestone-scope-classifier.ts";
+
+// ─── Classification matrix ────────────────────────────────────────────────
+
+test("#4781 classifier: single static HTML to-do app → trivial (b23 forensic case)", () => {
+  const input: MilestoneScopeInput = {
+    title: "To-Do App",
+    vision: "A minimal, clean browser-based to-do app. Pure HTML/CSS/JS, no build step, no backend. Tasks persist in localStorage.",
+    successCriteria: [
+      "Open index.html in any browser without a server",
+      "Add tasks by typing and pressing Enter or clicking Add",
+      "Mark tasks complete (toggleable)",
+      "Delete individual tasks",
+      "Tasks survive a page reload via localStorage",
+    ],
+  };
+  const r = classifyMilestoneScope(input);
+  assert.strictEqual(r.variant, "trivial", `expected trivial, got ${r.variant} — reasons: ${r.reasons.join("; ")}`);
+  assert.ok(r.reasons.some(s => s.includes("trivial keywords")), "should cite trivial keywords");
+});
+
+test("#4781 classifier: readme typo fix → trivial", () => {
+  const r = classifyMilestoneScope({
+    title: "Fix README typo",
+    vision: "Correct spelling error in the installation section.",
+    successCriteria: ["Typo fixed", "README renders correctly"],
+  });
+  assert.strictEqual(r.variant, "trivial");
+});
+
+test("#4781 classifier: auth flow single file → standard (override beats trivial)", () => {
+  const r = classifyMilestoneScope({
+    title: "Add login",
+    vision: "Implement authentication flow in a single file with OAuth credentials.",
+    successCriteria: ["User can log in"],
+  });
+  assert.strictEqual(r.variant, "standard", `override should beat single-file signal. reasons: ${r.reasons.join("; ")}`);
+  assert.ok(r.signals.triggeredOverride, "override signals should be flagged");
+  assert.ok(r.reasons.some(s => s.includes("override keywords")));
+});
+
+test("#4781 classifier: security review scope → standard (even if small)", () => {
+  const r = classifyMilestoneScope({
+    title: "Harden session tokens",
+    vision: "Review and patch security vulnerability in one session token helper.",
+    successCriteria: ["No XSS via token"],
+  });
+  assert.strictEqual(r.variant, "standard");
+  assert.ok(r.signals.triggeredOverride);
+});
+
+test("#4781 classifier: schema migration mentioned → standard (override-level signal)", () => {
+  const r = classifyMilestoneScope({
+    title: "User profile v2",
+    vision: "Perform schema migration to split user.name into first_name and last_name across the users table.",
+    successCriteria: ["Migration lands", "Existing rows backfilled", "Rollback path validated"],
+  });
+  // "migration" / "migrate" / "backfill" are OVERRIDE_KEYWORDS, not
+  // COMPLEX_KEYWORDS — migration is override-level (forces at least
+  // `standard`), not complex-level. Safe behavior: migrations need the
+  // full standard pipeline but not the extra ceremony of complex.
+  assert.strictEqual(r.variant, "standard", `reasons: ${r.reasons.join("; ")}`);
+});
+
+test("#4781 classifier: architecture keyword → complex", () => {
+  const r = classifyMilestoneScope({
+    title: "Redesign plugin registry",
+    vision: "Refactor core architecture of the plugin registry to support versioned contracts.",
+  });
+  assert.strictEqual(r.variant, "complex");
+  assert.ok(r.reasons.some(s => s.includes("complex keywords")));
+});
+
+test("#4781 classifier: >=8 files hint → complex", () => {
+  const r = classifyMilestoneScope({
+    title: "Multi-file refactor",
+    vision: "Touch 12 files to extract shared helpers.",
+  });
+  assert.strictEqual(r.variant, "complex");
+  assert.strictEqual(r.signals.fileCountHint, 12);
+});
+
+test("#4781 classifier: backend API mention → standard (not trivial)", () => {
+  const r = classifyMilestoneScope({
+    title: "Health endpoint",
+    vision: "Add a single-file API endpoint returning status.",
+    successCriteria: ["/health returns 200"],
+  });
+  // Single file + no override + but backend mentioned → not trivial
+  assert.strictEqual(r.variant, "standard");
+});
+
+test("#4781 classifier: tests mentioned → standard (not trivial)", () => {
+  const r = classifyMilestoneScope({
+    title: "Landing page",
+    vision: "Ship a static one-page landing page with unit tests for the form validation.",
+  });
+  assert.strictEqual(r.variant, "standard", `reasons: ${r.reasons.join("; ")}`);
+});
+
+test("#4781 classifier: ambiguous prose → standard (safe default)", () => {
+  const r = classifyMilestoneScope({
+    title: "Generic improvements",
+    vision: "Make the system better.",
+    successCriteria: ["It's better"],
+  });
+  assert.strictEqual(r.variant, "standard");
+  assert.ok(r.reasons.includes("no strong signals — default"));
+});
+
+test("#4781 classifier: empty input → standard (safe default)", () => {
+  const r = classifyMilestoneScope({});
+  assert.strictEqual(r.variant, "standard");
+});
+
+// ─── Override precedence over trivial ──────────────────────────────────────
+
+test("#4781 classifier: override + trivial keyword → standard (override wins)", () => {
+  const r = classifyMilestoneScope({
+    title: "Token rotation",
+    vision: "Single file change to rotate the oauth token expiry schedule.",
+  });
+  // "single file" is trivial signal; "oauth" is override signal. Override wins.
+  assert.strictEqual(r.variant, "standard");
+  assert.ok(r.signals.triggeredOverride);
+});
+
+test("#4781 classifier: complex + override → complex (complex wins, flagged)", () => {
+  const r = classifyMilestoneScope({
+    title: "Auth service refactor",
+    vision: "Refactor core authentication architecture across services.",
+  });
+  // Complex (architecture, refactor core) wins over override (auth).
+  assert.strictEqual(r.variant, "complex");
+  // Override still recorded in signals for telemetry.
+  assert.ok(r.signals.triggeredOverride, "override hits should still be tracked in signals");
+});
+
+// ─── File count hint extraction ───────────────────────────────────────────
+
+test("#4781 classifier: 'a single file' hint parsed as 1", () => {
+  const r = classifyMilestoneScope({
+    title: "Tweak",
+    vision: "Update a single file to flip the copy.",
+  });
+  assert.strictEqual(r.signals.fileCountHint, 1);
+});
+
+test("#4781 classifier: 'two files' hint parsed as 2", () => {
+  const r = classifyMilestoneScope({
+    title: "Minor",
+    vision: "Touch two files.",
+  });
+  assert.strictEqual(r.signals.fileCountHint, 2);
+});
+
+test("#4781 classifier: '12 files' hint parsed as 12", () => {
+  const r = classifyMilestoneScope({
+    title: "Bulk",
+    vision: "Update 12 files.",
+  });
+  assert.strictEqual(r.signals.fileCountHint, 12);
+});
+
+// ─── Reasons surface useful debugging info ─────────────────────────────────
+
+test("#4781 classifier: reasons array populated for every branch", () => {
+  const branches: Array<[string, MilestoneScopeInput]> = [
+    ["trivial", { title: "Readme typo", vision: "Fix a single file typo." }],
+    ["standard (override)", { title: "Auth", vision: "Touch auth helper." }],
+    ["complex (keyword)", { title: "Arch", vision: "Refactor core system design." }],
+    ["complex (file count)", { title: "Bulk", vision: "Update 9 files." }],
+    ["standard (default)", { title: "Generic", vision: "General work." }],
+  ];
+  for (const [label, input] of branches) {
+    const r = classifyMilestoneScope(input);
+    assert.ok(r.reasons.length > 0, `${label}: reasons must not be empty`);
+  }
+});

package/src/resources/extensions/gsd/tests/milestone-summary-classifier.test.ts

@@ -0,0 +1,30 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { classifyMilestoneSummaryContent } from "../milestone-summary-classifier.ts";
+
+test("milestone SUMMARY classifier treats explicit failed status as failure", () => {
+  assert.equal(
+    classifyMilestoneSummaryContent([
+      "---",
+      "status: failed",
+      "---",
+      "",
+      "# M001 Summary",
+      "Recovery stopped.",
+    ].join("\n")),
+    "failure",
+  );
+});
+
+test("milestone SUMMARY classifier does not treat historical not-complete prose as failure", () => {
+  assert.equal(
+    classifyMilestoneSummaryContent([
+      "# M001 Summary",
+      "",
+      "This milestone was previously not complete, now resolved.",
+    ].join("\n")),
+    "unknown",
+  );
+});
+

package/src/resources/extensions/gsd/tests/model-cost-table.test.ts

@@ -74,7 +74,7 @@ test("#2885: cost table includes openai-codex provider models", () => {
   const ids = BUNDLED_COST_TABLE.map(e => e.id);
   const codexModels = [
     "gpt-5.1", "gpt-5.1-codex-max", "gpt-5.1-codex-mini",
-    "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.3-codex-spark", "gpt-5.4", "gpt-5.4-mini",
+    "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.3-codex-spark", "gpt-5.4", "gpt-5.4-mini", "gpt-5.5",
   ];
   for (const model of codexModels) {
     assert.ok(ids.includes(model), `cost table should include openai-codex model "${model}"`);
@@ -101,3 +101,11 @@ test("#2885: lookupModelCost returns costs for new models (not 999 fallback)", (
     assert.ok(entry.inputPer1k < 999, `${model} should have a real cost, not the 999 fallback`);
   }
 });
+
+test("gpt-5.5 uses official OpenAI list pricing", () => {
+  const entry = lookupModelCost("gpt-5.5");
+  assert.ok(entry, "lookupModelCost should find gpt-5.5");
+  assert.equal(entry.inputPer1k, 0.005);
+  assert.equal(entry.outputPer1k, 0.03);
+  assert.equal(entry.updatedAt, "2026-04-23");
+});

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

@@ -382,7 +382,7 @@ test("#2885: openai-codex standard-tier models are recognized", () => {
 
 test("#2885: openai-codex heavy-tier models are recognized", () => {
   const config = { ...defaultRoutingConfig(), enabled: true };
-  const heavyModels = ["gpt-5", "gpt-5-pro", "gpt-5.1", "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.4", "o4-mini", "o4-mini-deep-research"];
+  const heavyModels = ["gpt-5", "gpt-5-pro", "gpt-5.1", "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.4", "gpt-5.5", "o4-mini", "o4-mini-deep-research"];
   for (const model of heavyModels) {
     const result = resolveModelForComplexity(
       makeClassification("heavy"),

package/src/resources/extensions/gsd/tests/native-git-bridge-exec-fallback.test.ts

@@ -18,54 +18,12 @@ import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 import { nativeIsRepo, nativeCommit, nativeResetHard } from "../native-git-bridge.js";
 
-// ─── Static analysis ──────────────────────────────────────────────────────
-// Verify the fallback paths of the three affected functions do not call the
-// raw execSync() string-command variant. Replacing all execFileSync( tokens
-// first ensures we match only the bare execSync( form.
-
-const SRC_PATH = join(import.meta.dirname, "..", "native-git-bridge.ts");
-
-function extractFunctionBody(src: string, fnName: string): string {
-  const idx = src.indexOf(`export function ${fnName}`);
-  if (idx === -1) throw new Error(`${fnName} not found in source`);
-  return src.slice(idx, idx + 1500);
-}
-
-function hasRawExecSync(body: string): boolean {
-  const withoutFileSync = body.replace(/execFileSync\(/g, "__FILESYNC__");
-  return withoutFileSync.includes("execSync(");
-}
-
-describe("native-git-bridge #4180: fallback paths use execFileSync not execSync", () => {
-  const src = readFileSync(SRC_PATH, "utf-8");
-
-  test("nativeIsRepo fallback does not use raw execSync", () => {
-    const body = extractFunctionBody(src, "nativeIsRepo");
-    assert.equal(
-      hasRawExecSync(body),
-      false,
-      "nativeIsRepo fallback must use execFileSync to avoid cmd.exe PATH failures on Windows",
-    );
-  });
-
-  test("nativeCommit fallback does not use raw execSync", () => {
-    const body = extractFunctionBody(src, "nativeCommit");
-    assert.equal(
-      hasRawExecSync(body),
-      false,
-      "nativeCommit fallback must use execFileSync to avoid cmd.exe PATH failures on Windows",
-    );
-  });
-
-  test("nativeResetHard fallback does not use raw execSync", () => {
-    const body = extractFunctionBody(src, "nativeResetHard");
-    assert.equal(
-      hasRawExecSync(body),
-      false,
-      "nativeResetHard fallback must use execFileSync to avoid cmd.exe PATH failures on Windows",
-    );
-  });
-});
+// Note: prior static-analysis tests that scanned native-git-bridge.ts for
+// the raw shell-spawn pattern were removed under #4827 — the integration
+// tests below already exercise the fallback path end-to-end with the native
+// module disabled (GSD_ENABLE_NATIVE_GSD_GIT unset). Any cmd.exe PATH
+// regression on Windows surfaces through a real fallback failure, not a
+// grep miss in source text.
 
 // ─── Integration tests ────────────────────────────────────────────────────
 // Verify correct runtime behaviour through the fallback path (native module

package/src/resources/extensions/gsd/tests/notification-widget.test.ts

@@ -16,9 +16,12 @@ test("buildNotificationWidgetLines shows unread count with shortcut pair", () =>
     appendNotification("Need attention", "warning");
 
     const lines = buildNotificationWidgetLines();
-    assert.equal(lines.length, 1);
-    assert.match(lines[0]!, /🔔\s+1 unread/);
-    assert.match(lines[0]!, /\(.+\/.+\)/);
+    // Widget must render at least one line; may add secondary lines later
+    // (e.g., "View with /gsd notif") without breaking this assertion.
+    assert.ok(lines.length >= 1, `expected at least 1 widget line, got ${lines.length}`);
+    const combined = lines.join("\n");
+    assert.match(combined, /🔔\s+1 unread/);
+    assert.match(combined, /\(.+\/.+\)/);
   } finally {
     _resetNotificationStore();
     rmSync(tmp, { recursive: true, force: true });

package/src/resources/extensions/gsd/tests/orphaned-worktree-audit.test.ts

@@ -107,7 +107,8 @@ describe("auditOrphanedMilestoneBranches", () => {
     assert.ok(branches.includes("milestone/M001"), "unmerged branch must be preserved");
   });
 
-  test("skips active (non-complete) milestone branches", () => {
+  test("skips active milestone branch with no commits ahead of main (nothing to recover)", () => {
+    // Branch created from main with zero divergence — no live work, nothing to warn about.
     run("git branch milestone/M001", dir);
     insertMilestone({ id: "M001", title: "Test", status: "active" });
 
@@ -116,11 +117,67 @@ describe("auditOrphanedMilestoneBranches", () => {
     assert.deepStrictEqual(result.recovered, []);
     assert.deepStrictEqual(result.warnings, []);
 
-    // Branch should still exist
+    // Branch should still exist (data safety — user may intend to use it)
     const branches = run("git branch --list milestone/M001", dir);
     assert.ok(branches.includes("milestone/M001"), "active milestone branch should be preserved");
   });
 
+  test("#4762 — warns about in-progress milestone with unmerged commits ahead of main", () => {
+    // Simulates the primary #4761 scenario: auto-mode was interrupted mid-milestone.
+    // DB status = active/in_progress, branch has real work, main is behind.
+    run("git checkout -b milestone/M001", dir);
+    writeFileSync(join(dir, "feature.txt"), "in-progress work\n");
+    run("git add feature.txt", dir);
+    run("git commit -m \"in-progress work on M001\"", dir);
+    run("git checkout main", dir);
+
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+
+    // Must NOT recover/delete (data safety — work is live)
+    assert.deepStrictEqual(result.recovered, [], "must not delete a branch with live in-progress work");
+
+    // Must surface a warning so the user knows the worktree holds uncollapsed work
+    assert.ok(result.warnings.length > 0, "should warn about in-progress orphan");
+    assert.ok(
+      result.warnings.some(w => w.includes("milestone/M001") && w.includes("in-progress")),
+      `warning should mention milestone/M001 and in-progress state; got: ${JSON.stringify(result.warnings)}`,
+    );
+
+    // Branch must still exist
+    const branches = run("git branch --list milestone/M001", dir);
+    assert.ok(branches.includes("milestone/M001"), "in-progress branch must be preserved");
+  });
+
+  test("#4762 — also surfaces worktree directory for in-progress orphan when present", () => {
+    // In-progress + unmerged + physical worktree directory — the full primary scenario.
+    run("git checkout -b milestone/M001", dir);
+    writeFileSync(join(dir, "feature.txt"), "in-progress work\n");
+    run("git add feature.txt", dir);
+    run("git commit -m \"in-progress work on M001\"", dir);
+    run("git checkout main", dir);
+
+    // Simulate a leftover worktree directory
+    const wtDir = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(wtDir, { recursive: true });
+    writeFileSync(join(wtDir, ".git"), `gitdir: ${join(dir, ".git", "worktrees", "M001")}\n`);
+
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+
+    // Must preserve everything for data safety
+    assert.deepStrictEqual(result.recovered, [], "must not touch worktree or branch with live work");
+    assert.ok(existsSync(wtDir), "worktree directory must be preserved");
+
+    // Warning should mention the worktree path so the user can find the work
+    assert.ok(
+      result.warnings.some(w => w.includes(".gsd/worktrees/M001") || w.includes("worktree")),
+      `warning should reference the worktree location; got: ${JSON.stringify(result.warnings)}`,
+    );
+  });
+
   test("cleans up orphaned worktree directory for merged milestone", () => {
     // Create milestone branch (merged — same as main)
     run("git branch milestone/M001", dir);