gsd-pi 2.79.0 → 2.80.0-dev.4ea7d80e7

package/src/resources/extensions/gsd/tests/auto-orchestrator.test.ts

@@ -0,0 +1,353 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { createAutoOrchestrator } from "../auto/orchestrator.js";
+import type { AutoOrchestratorDeps } from "../auto/contracts.js";
+
+function makeDeps(overrides: Partial<AutoOrchestratorDeps> = {}): { deps: AutoOrchestratorDeps; calls: string[] } {
+  const calls: string[] = [];
+
+  const deps: AutoOrchestratorDeps = {
+    dispatch: {
+      async decideNextUnit() {
+        calls.push("dispatch.decide");
+        return { unitType: "execute-task", unitId: "T01", reason: "ready", preconditions: [] };
+      },
+    },
+    recovery: {
+      async classifyAndRecover() {
+        calls.push("recovery.classify");
+        return { action: "stop", reason: "fatal" };
+      },
+    },
+    worktree: {
+      async prepareForUnit() { calls.push("worktree.prepare"); },
+      async syncAfterUnit() { calls.push("worktree.sync"); },
+      async cleanupOnStop() { calls.push("worktree.cleanup"); },
+    },
+    health: {
+      async preAdvanceGate() {
+        calls.push("health.pre");
+        return { allow: true };
+      },
+      async postAdvanceRecord() { calls.push("health.post"); },
+    },
+    runtime: {
+      async ensureLockOwnership() { calls.push("runtime.lock"); },
+      async journalTransition(event) { calls.push(`journal:${event.name}`); },
+    },
+    notifications: {
+      async notifyLifecycle(event) { calls.push(`notify:${event.name}`); },
+    },
+  };
+
+  return { deps: { ...deps, ...overrides }, calls };
+}
+
+test("start() advances and records active unit", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.start({ basePath: "/tmp/project", trigger: "manual" });
+
+  assert.equal(result.kind, "advanced");
+  const status = orchestrator.getStatus();
+  assert.equal(status.phase, "running");
+  assert.deepEqual(status.activeUnit, { unitType: "execute-task", unitId: "T01" });
+  assert.ok(calls.includes("journal:start"));
+  assert.ok(calls.includes("journal:advance"));
+});
+
+test("advance() returns blocked when health gate denies", async () => {
+  const { deps } = makeDeps({
+    health: {
+      async preAdvanceGate() { return { allow: false, reason: "doctor-block" }; },
+      async postAdvanceRecord() {},
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "blocked");
+  assert.equal(result.reason, "doctor-block");
+});
+
+test("advance() stops when dispatch has no next unit", async () => {
+  const { deps } = makeDeps({
+    dispatch: {
+      async decideNextUnit() { return null; },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "stopped");
+  assert.equal(orchestrator.getStatus().phase, "stopped");
+});
+
+test("advance() uses recovery on error", async () => {
+  const { deps, calls } = makeDeps({
+    runtime: {
+      async ensureLockOwnership() { throw new Error("lock lost"); },
+      async journalTransition(event) { calls.push(`journal:${event.name}`); },
+    },
+    recovery: {
+      async classifyAndRecover() { return { action: "escalate", reason: "needs manual" }; },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "error");
+  assert.equal(result.reason, "needs manual");
+  assert.equal(orchestrator.getStatus().phase, "error");
+  assert.ok(calls.includes("journal:advance-error"));
+});
+
+test("advance() is idempotent for the same active unit", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const first = await orchestrator.advance();
+  const second = await orchestrator.advance();
+
+  assert.equal(first.kind, "advanced");
+  assert.equal(second.kind, "blocked");
+  assert.equal(second.reason, "idempotent advance: unit already active");
+
+  const prepareCalls = calls.filter((c) => c === "worktree.prepare").length;
+  assert.equal(prepareCalls, 1);
+});
+
+test("resume() re-enters running flow via advance", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.resume();
+
+  assert.equal(result.kind, "advanced");
+  assert.equal(orchestrator.getStatus().phase, "running");
+});
+
+test("resume() clears idempotent lock and allows re-advance", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const first = await orchestrator.advance();
+  const blocked = await orchestrator.advance();
+  const resumed = await orchestrator.resume();
+
+  assert.equal(first.kind, "advanced");
+  assert.equal(blocked.kind, "blocked");
+  assert.equal(resumed.kind, "advanced");
+});
+
+test("transitionCount increases across lifecycle transitions", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const before = orchestrator.getStatus().transitionCount;
+  await orchestrator.start({ basePath: "/tmp/project", trigger: "manual" });
+  const afterStart = orchestrator.getStatus().transitionCount;
+  await orchestrator.stop("done");
+  const afterStop = orchestrator.getStatus().transitionCount;
+
+  assert.ok(afterStart > before);
+  assert.ok(afterStop > afterStart);
+});
+
+test("stop() clears idempotent unit lock so advance can run again", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const first = await orchestrator.advance();
+  const blocked = await orchestrator.advance();
+  const stopped = await orchestrator.stop("reset");
+  const second = await orchestrator.advance();
+
+  assert.equal(first.kind, "advanced");
+  assert.equal(blocked.kind, "blocked");
+  assert.equal(stopped.kind, "stopped");
+  assert.equal(second.kind, "advanced");
+});
+
+test("advance() stopped clears previous activeUnit", async () => {
+  let first = true;
+  const { deps } = makeDeps({
+    dispatch: {
+      async decideNextUnit() {
+        if (first) {
+          first = false;
+          return { unitType: "execute-task", unitId: "T01", reason: "ready", preconditions: [] };
+        }
+        return null;
+      },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+  const stopped = await orchestrator.advance();
+
+  assert.equal(stopped.kind, "stopped");
+  assert.equal(orchestrator.getStatus().activeUnit, undefined);
+});
+
+test("recovery stop clears activeUnit", async () => {
+  const { deps, calls } = makeDeps({
+    runtime: {
+      async ensureLockOwnership() { throw new Error("boom"); },
+      async journalTransition(event) { calls.push(`journal:${event.name}`); },
+    },
+    recovery: {
+      async classifyAndRecover() { return { action: "stop", reason: "fatal" }; },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "stopped");
+  assert.equal(orchestrator.getStatus().activeUnit, undefined);
+  assert.ok(calls.includes("journal:advance-stopped"));
+  assert.ok(calls.includes("notify:stopped"));
+  assert.ok(!calls.includes("notify:error"));
+});
+
+test("recovery retry maps to paused result", async () => {
+  const { deps, calls } = makeDeps({
+    runtime: {
+      async ensureLockOwnership() { throw new Error("boom"); },
+      async journalTransition(event) { calls.push(`journal:${event.name}`); },
+    },
+    recovery: {
+      async classifyAndRecover() { return { action: "retry", reason: "transient" }; },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "paused");
+  assert.equal(result.reason, "transient");
+  assert.equal(orchestrator.getStatus().phase, "paused");
+  assert.ok(calls.includes("journal:advance-paused"));
+  assert.ok(calls.includes("notify:pause"));
+});
+
+test("getStatus() returns defensive copy of activeUnit", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+  const snap1 = orchestrator.getStatus();
+  if (snap1.activeUnit) snap1.activeUnit.unitId = "MUTATED";
+  const snap2 = orchestrator.getStatus();
+
+  assert.equal(snap2.activeUnit?.unitId, "T01");
+});
+
+test("start() clears prior idempotent lock", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+  const blocked = await orchestrator.advance();
+  const restarted = await orchestrator.start({ basePath: "/tmp/project", trigger: "manual" });
+
+  assert.equal(blocked.kind, "blocked");
+  assert.equal(restarted.kind, "advanced");
+});
+
+test("error path emits error notification", async () => {
+  const { deps, calls } = makeDeps({
+    runtime: {
+      async ensureLockOwnership() { throw new Error("boom"); },
+      async journalTransition(event) { calls.push(`journal:${event.name}`); },
+    },
+    recovery: {
+      async classifyAndRecover() { return { action: "escalate", reason: "needs manual" }; },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+
+  assert.ok(calls.includes("notify:error"));
+});
+
+test("blocked path journals advance-blocked", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+  await orchestrator.advance();
+
+  assert.ok(calls.includes("journal:advance-blocked"));
+});
+
+test("health post hook runs on blocked result", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+  await orchestrator.advance();
+
+  assert.ok(calls.includes("health.post"));
+});
+
+test("start() emits start notification", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.start({ basePath: "/tmp/project", trigger: "manual" });
+
+  assert.ok(calls.includes("notify:start"));
+});
+
+test("resume() emits resume notification", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.resume();
+
+  assert.ok(calls.includes("notify:resume"));
+});
+
+test("stopped with no remaining units clears idempotent lock for next advance", async () => {
+  let callCount = 0;
+  const { deps } = makeDeps({
+    dispatch: {
+      async decideNextUnit() {
+        callCount += 1;
+        if (callCount === 2) return null;
+        return { unitType: "execute-task", unitId: "T01", reason: "ready", preconditions: [] };
+      },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const first = await orchestrator.advance();
+  const stopped = await orchestrator.advance();
+  const after = await orchestrator.advance();
+
+  assert.equal(first.kind, "advanced");
+  assert.equal(stopped.kind, "stopped");
+  assert.equal(after.kind, "advanced");
+});
+
+test("stop() cleans up worktree and transitions to stopped", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.stop("user-request");
+
+  assert.equal(result.kind, "stopped");
+  assert.equal(orchestrator.getStatus().phase, "stopped");
+  assert.ok(calls.includes("worktree.cleanup"));
+  assert.ok(calls.includes("journal:stop"));
+  assert.ok(calls.includes("notify:stop"));
+});

package/src/resources/extensions/gsd/tests/auto-pr-bugs.test.ts

@@ -34,6 +34,25 @@ test("#2302 bug 1: auto_pr condition should not require pushed flag", () => {
   );
 });
 
+test("auto_pr skips milestone branch push when configured remote is absent", () => {
+  const autoPrIdx = autoWorktreeSrc.indexOf("prefs.auto_pr === true");
+  assert.ok(autoPrIdx !== -1, "auto_pr block exists in auto-worktree.ts");
+
+  const autoPrBlock = autoWorktreeSrc.slice(
+    autoPrIdx,
+    autoWorktreeSrc.indexOf("// 11. Guard removed", autoPrIdx),
+  );
+  const remoteExistsIdx = autoPrBlock.indexOf("gitRemoteExists(originalBasePath_, remote)");
+  const pushIdx = autoPrBlock.indexOf('execFileSync("git", ["push", remote, milestoneBranch]');
+
+  assert.ok(remoteExistsIdx !== -1, "auto_pr must check that the configured remote exists");
+  assert.ok(pushIdx !== -1, "auto_pr still pushes the milestone branch before creating the PR");
+  assert.ok(
+    remoteExistsIdx < pushIdx,
+    "auto_pr must check remote existence before pushing the milestone branch",
+  );
+});
+
 // ─── Bug 2: phases.ts should not duplicate PR creation ──────────────────────
 
 const phasesSrcPath = join(import.meta.dirname, "..", "auto", "phases.ts");

package/src/resources/extensions/gsd/tests/auto-recovery.test.ts

@@ -7,11 +7,12 @@ import { randomUUID } from "node:crypto";
 
 import { verifyExpectedArtifact, hasImplementationArtifacts, resolveExpectedArtifactPath, diagnoseExpectedArtifact, buildLoopRemediationSteps, writeBlockerPlaceholder } from "../auto-recovery.ts";
 import { resolveMilestoneFile } from "../paths.ts";
-import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertGateRow } from "../gsd-db.ts";
+import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertGateRow, insertTask, getMilestoneCommitAttributionShas } from "../gsd-db.ts";
 import { clearParseCache } from "../files.ts";
 import { parseRoadmap } from "../parsers-legacy.ts";
 import { invalidateAllCaches } from "../cache.ts";
 import { deriveState, invalidateStateCache } from "../state.ts";
+import { writeIntegrationBranch } from "../git-service.ts";
 
 const tmpDirs: string[] = [];
 
@@ -90,6 +91,46 @@ test("resolveExpectedArtifactPath returns correct path for plan-slice", () => {
   }
 });
 
+test("plan-slice artifact resolution handles lowercase unit IDs against uppercase paths", () => {
+  const base = makeTmpBase();
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    const tasksDir = join(sliceDir, "tasks");
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "- [ ] **T01: Implement feature** `est:1h`",
+    ].join("\n"));
+    writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan");
+
+    const artifactPath = resolveExpectedArtifactPath("plan-slice", "m001/s01", base);
+    assert.ok(
+      artifactPath?.endsWith(".gsd/milestones/M001/slices/S01/S01-PLAN.md"),
+      "lowercase unit IDs should resolve to the existing uppercase artifact path",
+    );
+
+    const diagnostic = diagnoseExpectedArtifact("plan-slice", "m001/s01", base);
+    assert.ok(
+      diagnostic?.includes(".gsd/milestones/M001/slices/S01/S01-PLAN.md"),
+      "diagnostic should report the existing uppercase artifact path",
+    );
+    assert.ok(
+      diagnostic?.includes("task plans"),
+      "diagnostic should mention task plans because slice plan alone is insufficient",
+    );
+
+    assert.equal(
+      verifyExpectedArtifact("plan-slice", "m001/s01", base),
+      true,
+      "verification should pass when the uppercase slice plan and task plans exist",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("resolveExpectedArtifactPath returns null for unknown type", () => {
   const base = makeTmpBase();
   try {
@@ -695,6 +736,174 @@ test("hasImplementationArtifacts rejects milestone-scoped main history with only
   }
 });
 
+test("hasImplementationArtifacts finds integration implementation-only commits when milestone branch diff is .gsd-only", () => {
+  const base = makeGitBase();
+  try {
+    mkdirSync(join(base, "src"), { recursive: true });
+    writeFileSync(join(base, "src", "feature.ts"), "export function feature() {}\n");
+    execFileSync("git", ["add", "src/feature.ts"], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "feat: add milestone feature\n\nGSD-Task: S01/T01"], { cwd: base, stdio: "ignore" });
+
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Slice One",
+      status: "complete",
+      risk: "low",
+      depends: [],
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Task One",
+      status: "complete",
+    });
+
+    execFileSync("git", ["checkout", "-b", "milestone/M001"], { cwd: base, stdio: "ignore" });
+    writeIntegrationBranch(base, "M001", "main");
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-SUMMARY.md"), "# Milestone Summary\nDone.");
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "chore: auto-commit after complete-milestone\n\nGSD-Unit: M001"], { cwd: base, stdio: "ignore" });
+
+    const result = hasImplementationArtifacts(base, "M001");
+    assert.equal(
+      result,
+      "present",
+      ".gsd-only milestone closeout diffs should still honor implementation commits already on the integration branch",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("hasImplementationArtifacts backfills untagged main implementation commits from completed task file hints", () => {
+  const base = makeGitBase();
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Slice One",
+      status: "complete",
+      risk: "low",
+      depends: [],
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Task One",
+      status: "complete",
+      keyFiles: ["index.html", "style.css", "app.js"],
+      planning: { files: ["index.html", "style.css", "app.js"] },
+    });
+
+    writeFileSync(join(base, "index.html"), "<main></main>\n");
+    writeFileSync(join(base, "style.css"), "main { display: block; }\n");
+    writeFileSync(join(base, "app.js"), "document.body.dataset.ready = 'true';\n");
+    execFileSync("git", ["add", "index.html", "style.css", "app.js"], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "feat: add to-do app with CRUD and localStorage persistence"], { cwd: base, stdio: "ignore" });
+    const commitSha = execFileSync("git", ["rev-parse", "HEAD"], { cwd: base, encoding: "utf-8" }).trim();
+
+    const result = hasImplementationArtifacts(base, "M001");
+    assert.equal(
+      result,
+      "present",
+      "completed task file hints should repair prior untagged implementation commits on main",
+    );
+    assert.deepEqual(getMilestoneCommitAttributionShas("M001"), [commitSha]);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("hasImplementationArtifacts does not backfill untagged commits before milestone creation", () => {
+  const base = makeGitBase();
+  try {
+    writeFileSync(join(base, "app.js"), "document.body.dataset.ready = 'old';\n");
+    execFileSync("git", ["add", "app.js"], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "feat: old app work"], {
+      cwd: base,
+      stdio: "ignore",
+      env: {
+        ...process.env,
+        GIT_AUTHOR_DATE: "2020-01-01T00:00:00Z",
+        GIT_COMMITTER_DATE: "2020-01-01T00:00:00Z",
+      },
+    });
+
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Slice One",
+      status: "complete",
+      risk: "low",
+      depends: [],
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Task One",
+      status: "complete",
+      keyFiles: ["app.js"],
+      planning: { files: ["app.js"] },
+    });
+
+    const result = hasImplementationArtifacts(base, "M001");
+    assert.equal(result, "absent", "pre-milestone commits must not be attributed to the milestone");
+    assert.deepEqual(getMilestoneCommitAttributionShas("M001"), []);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("hasImplementationArtifacts does not backfill unrelated untagged implementation commits", () => {
+  const base = makeGitBase();
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Slice One",
+      status: "complete",
+      risk: "low",
+      depends: [],
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Task One",
+      status: "complete",
+      keyFiles: ["src/expected.ts"],
+      planning: { files: ["src/expected.ts"] },
+    });
+
+    mkdirSync(join(base, "src"), { recursive: true });
+    writeFileSync(join(base, "src", "unrelated.ts"), "export const unrelated = true;\n");
+    execFileSync("git", ["add", "src/unrelated.ts"], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "feat: unrelated work"], { cwd: base, stdio: "ignore" });
+
+    const result = hasImplementationArtifacts(base, "M001");
+    assert.equal(result, "absent", "backfill must require overlap with completed task file hints");
+    assert.deepEqual(getMilestoneCommitAttributionShas("M001"), []);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("hasImplementationArtifacts treats empty non-integration branch diff as absent (#4699)", () => {
   const base = makeGitBase();
   try {
@@ -764,6 +973,73 @@ test("hasImplementationArtifacts finds implementation commits when .gsd/ is giti
   }
 });
 
+test("hasImplementationArtifacts binds GSD-Task trailer to milestone via DB state when .gsd/ is gitignored", () => {
+  const base = makeGitBase();
+  try {
+    writeFileSync(join(base, ".git", "info", "exclude"), ".gsd/\n");
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Slice One",
+      status: "complete",
+      risk: "low",
+      depends: [],
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Task One",
+      status: "complete",
+    });
+
+    mkdirSync(join(base, "src"), { recursive: true });
+    writeFileSync(join(base, "src", "feature.ts"), "export function feature() {}\n");
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync(
+      "git",
+      ["commit", "-m", "feat: add feature\n\nGSD-Task: S01/T01"],
+      { cwd: base, stdio: "ignore" },
+    );
+
+    const result = hasImplementationArtifacts(base, "M001");
+    assert.equal(
+      result,
+      "present",
+      "DB task ownership should bind S01/T01 implementation commits to M001 without explicit M001 text",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("hasImplementationArtifacts does not bind GSD-Task trailer without milestone ownership evidence", () => {
+  const base = makeGitBase();
+  try {
+    writeFileSync(join(base, ".git", "info", "exclude"), ".gsd/\n");
+    mkdirSync(join(base, "src"), { recursive: true });
+    writeFileSync(join(base, "src", "feature.ts"), "export function feature() {}\n");
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync(
+      "git",
+      ["commit", "-m", "feat: add feature\n\nGSD-Task: S01/T01"],
+      { cwd: base, stdio: "ignore" },
+    );
+
+    const result = hasImplementationArtifacts(base, "M001");
+    assert.equal(
+      result,
+      "absent",
+      "S01/T01 shape alone must not bind an implementation commit to M001",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("hasImplementationArtifacts ignores malformed milestone IDs in commit-message fallback", () => {
   const base = makeGitBase();
   try {