@opengsd/gsd-pi 1.4.0 → 1.5.0-dev.4fb2d460

package/src/resources/extensions/gsd/tests/auto-loop-no-copy-artifacts.test.ts

@@ -14,7 +14,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
-import { createAutoWorktree, teardownAutoWorktree } from "../auto-worktree.ts";
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
+import { teardownAutoWorktree } from "../auto-worktree-teardown.ts";
 
 function git(args: string[], cwd: string): void {
   execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });

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

@@ -22,7 +22,7 @@ import {
   isSessionSwitchAbortGraceActive,
 } from "../auto/resolve.js";
 import { runUnit, shouldDeferUnitFailsafeTimeout } from "../auto/run-unit.js";
-import { scheduleAutoWakeup, _resetAutoWakeupsForTest } from "../auto/schedule-wakeup.js";
+import { consumeAutoWakeup, scheduleAutoWakeup, _resetAutoWakeupsForTest } from "../auto/schedule-wakeup.js";
 import { writeUnitRuntimeRecord, readUnitRuntimeRecord } from "../unit-runtime.js";
 import { autoLoop as rawAutoLoop } from "../auto/loop.js";
 import { runPreDispatch } from "../auto/pre-dispatch.js";
@@ -67,6 +67,76 @@ async function drainMicrotasks(turns = 20): Promise<void> {
   }
 }
 
+function guardedExitMilestoneForTest(
+  merge: (milestoneId: string, opts: { merge: boolean }) => {
+    ok: boolean;
+    merged?: boolean;
+    codeFilesChanged?: boolean;
+    reason?: string;
+    cause?: unknown;
+  },
+) {
+  return (
+    milestoneId: string,
+    opts: {
+      merge: boolean;
+      guardedMerge?: {
+        projectRoot: string;
+        preflightCleanRoot: (
+          basePath: string,
+          milestoneId: string,
+          notify: (message: string, level: "info" | "warning" | "error") => void,
+        ) => { blocked?: boolean; blockedReason?: string; stashPushed: boolean; stashMarker?: string };
+        postflightPopStash: (
+          basePath: string,
+          milestoneId: string,
+          stashMarker: string | undefined,
+          notify: (message: string, level: "info" | "warning" | "error") => void,
+        ) => { needsManualRecovery?: boolean };
+      };
+    },
+    ctx?: { notify: (message: string, level: "info" | "warning" | "error") => void },
+  ) => {
+    const notify = ctx?.notify ?? (() => {});
+    const guard = opts.guardedMerge;
+    if (opts.merge && guard) {
+      const preflight = guard.preflightCleanRoot(guard.projectRoot, milestoneId, notify);
+      if (preflight.blocked) {
+        return {
+          ok: false,
+          reason: preflight.blockedReason?.startsWith("unmerged-conflicts")
+            ? "preflight-unmerged-conflicts"
+            : "preflight-dirty-overlap",
+        };
+      }
+
+      const mergeResult = merge(milestoneId, { merge: true });
+      const postflight = preflight.stashPushed
+        ? guard.postflightPopStash(
+            guard.projectRoot,
+            milestoneId,
+            preflight.stashMarker,
+            notify,
+          )
+        : undefined;
+
+      if (!mergeResult.ok) {
+        return {
+          ok: false,
+          reason: mergeResult.reason === "merge-conflict" ? "merge-conflict" : "merge-failed",
+          cause: mergeResult.cause,
+          postflight,
+        };
+      }
+      if (postflight?.needsManualRecovery) {
+        return { ok: false, reason: "postflight-stash-restore-failed", postflight };
+      }
+      return mergeResult;
+    }
+    return merge(milestoneId, opts);
+  };
+}
+
 async function waitForMicrotasks(
   condition: () => boolean,
   label: string,
@@ -482,6 +552,62 @@ test("runUnit honors ScheduleWakeup by continuing the same unit session", async
   assert.equal(pi.calls.length, 2);
 });
 
+test("runUnit clears scheduled wakeups when the unit is cancelled", async () => {
+  _resetPendingResolve();
+  _resetAutoWakeupsForTest();
+
+  const ctx = {
+    ...makeMockCtx(),
+    ui: {
+      notify: () => {},
+      setStatus: () => {},
+      setWorkingMessage: () => {},
+    },
+    sessionManager: {
+      getEntries: () => [],
+    },
+    modelRegistry: {
+      getProviderAuthMode: () => undefined,
+      isProviderRequestReady: () => true,
+    },
+  } as any;
+  const pi = makeMockPi();
+  const s = makeMockSession();
+
+  const resultPromise = runUnit(
+    ctx,
+    pi,
+    s,
+    "execute-task",
+    "M001/S01/T02",
+    "submit external job",
+  );
+
+  await waitForMicrotasks(() => pi.calls.length === 1, "initial unit dispatch");
+  scheduleAutoWakeup({
+    basePath: s.basePath,
+    unitType: "execute-task",
+    unitId: "M001/S01/T02",
+    delayMs: 0,
+    prompt: "stale prompt from cancelled unit",
+    reason: "poll external job",
+    createdAt: Date.now(),
+  });
+  resolveAgentEndCancelled({
+    message: "Auto-mode paused",
+    category: "aborted",
+    isTransient: true,
+  });
+
+  const result = await resultPromise;
+  assert.equal(result.status, "cancelled");
+  assert.equal(
+    consumeAutoWakeup(s.basePath, "execute-task", "M001/S01/T02"),
+    null,
+    "cancelled units must not leave stale ScheduleWakeup prompts for later retries",
+  );
+});
+
 test("runUnit suppresses the global working-message loader for auto dashboard runs", async () => {
   _resetPendingResolve();
   const workingMessages: unknown[] = [];
@@ -1335,11 +1461,11 @@ function makeMockDeps(
     GitServiceImpl: class {} as any,
     lifecycle: {
       enterMilestone: () => ({ ok: true, mode: "worktree", path: "/tmp/project" }),
-      exitMilestone: (_mid: string, opts: { merge: boolean }) => ({
+      exitMilestone: guardedExitMilestoneForTest((_mid, opts) => ({
         ok: true,
         merged: opts.merge,
         codeFilesChanged: false,
-      }),
+      })),
     } as any,
     worktreeProjection: new WorktreeStateProjection(),
     postUnitPreVerification: async () => {
@@ -1762,10 +1888,10 @@ test("autoLoop marks transition merge complete before postflight recovery stop",
       enterMilestone: () => {
         assert.fail("must not enter the next milestone after postflight recovery fails");
       },
-      exitMilestone: (_mid: string, opts: { merge: boolean }) => {
+      exitMilestone: guardedExitMilestoneForTest((_mid, opts) => {
         if (opts.merge) mergeCalls += 1;
         return { ok: true, merged: opts.merge, codeFilesChanged: false };
-      },
+      }),
     } as any,
     stopAuto: async (_ctx, _pi, reason) => {
       deps.callLog.push("stopAuto");

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

@@ -49,6 +49,24 @@ test("recoverFailedMigration returns false when both .gsd and .gsd.migrating exi
   assert.ok(existsSync(join(base, ".gsd.migrating")), ".gsd.migrating must still exist");
 });
 
+test("recoverFailedMigration removes orphan when .gsd is a real intact directory", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-migrating-real-orphan-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const localGsd = join(base, ".gsd");
+  mkdirSync(join(localGsd, "phases"), { recursive: true });
+  mkdirSync(join(localGsd, "activity"), { recursive: true });
+  writeFileSync(join(localGsd, "STATE.md"), "# State\n", "utf-8");
+  writeFileSync(join(localGsd, "gsd.db"), "not empty\n", "utf-8");
+  mkdirSync(join(base, ".gsd.migrating"), { recursive: true });
+
+  const recovered = recoverFailedMigration(base);
+
+  assert.equal(recovered, true, "expected orphan cleanup to succeed");
+  assert.ok(existsSync(localGsd), ".gsd real directory must remain");
+  assert.ok(!existsSync(join(base, ".gsd.migrating")), ".gsd.migrating orphan must be removed");
+});
+
 test("recoverFailedMigration removes orphan when .gsd is an intact external-state junction", (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-migrating-orphan-"));
   const stateDir = mkdtempSync(join(tmpdir(), "gsd-migrating-state-"));

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

@@ -63,6 +63,62 @@ test("resolvePreferredModelConfig synthesizes heavy routing ceiling when models
   }
 });
 
+test("resolvePreferredModelConfig treats token-profile model defaults as synthesized routing", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = makeTempDir("gsd-routing-profile-project-");
+  const tempGsdHome = makeTempDir("gsd-routing-profile-home-");
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "token_profile: quality",
+        "dynamic_routing:",
+        "  enabled: true",
+        "  tier_models:",
+        "    light: claude-haiku-4-5",
+        "    standard: claude-sonnet-4-6",
+        "    heavy: claude-opus-4-6",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const config = resolvePreferredModelConfig(
+      "plan-slice",
+      {
+        provider: "anthropic",
+        id: "claude-sonnet-4-6",
+      },
+      true,
+      tempProject,
+      [
+        "anthropic/claude-haiku-4-5",
+        "anthropic/claude-sonnet-4-6",
+        "anthropic/claude-opus-4-6",
+      ],
+      "anthropic/claude-sonnet-4-6",
+    );
+
+    assert.deepEqual(config, {
+      primary: "claude-opus-4-6",
+      fallbacks: [],
+      source: "synthesized",
+    });
+  } finally {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  }
+});
+
 test("resolvePreferredModelConfig falls back to auto start model when heavy tier is absent", () => {
   const originalCwd = process.cwd();
   const originalGsdHome = process.env.GSD_HOME;
@@ -152,6 +208,128 @@ test("resolvePreferredModelConfig keeps explicit phase models as the ceiling", (
   }
 });
 
+// #1115 regression: a token_profile with dynamic_routing enabled but NO
+// tier_models pins must still resolve the profile's per-phase model as a
+// synthesized routing ceiling. Before the fix, resolvePreferredModelConfig
+// bailed to undefined here (explicit detection skips profile defaults, and the
+// synthesis path required tier_models), so auto dispatch fell back to the
+// start model for every unit and silently discarded the profile.
+test("resolvePreferredModelConfig resolves profile per-phase models as synthesized when tier_models are absent", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = makeTempDir("gsd-routing-profile-notier-");
+  const tempGsdHome = makeTempDir("gsd-routing-profile-notier-home-");
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "token_profile: budget",
+        "dynamic_routing:",
+        "  enabled: true",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const availableModelIds = [
+      "anthropic/claude-haiku-4-5",
+      "anthropic/claude-sonnet-4-6",
+      "anthropic/claude-opus-4-6",
+    ];
+    const start = { provider: "anthropic", id: "claude-sonnet-4-6" };
+    // preferredModelId is intentionally left undefined so profile tier
+    // resolution is exercised rather than pinning every tier to the session
+    // model (a heavy session model can satisfy every tier).
+    const resolve = (unitType: string) =>
+      resolvePreferredModelConfig(unitType, start, true, tempProject, availableModelIds);
+
+    // budget profile: research=light, planning=standard, execution=standard,
+    // execution_simple=light, completion=light (PROFILE_TIER_MAP).
+    assert.deepEqual(resolve("research-milestone"), {
+      primary: "claude-haiku-4-5",
+      fallbacks: [],
+      source: "synthesized",
+    });
+    assert.deepEqual(resolve("plan-milestone"), {
+      primary: "claude-sonnet-4-6",
+      fallbacks: [],
+      source: "synthesized",
+    });
+    assert.deepEqual(resolve("execute-task"), {
+      primary: "claude-sonnet-4-6",
+      fallbacks: [],
+      source: "synthesized",
+    });
+    assert.deepEqual(resolve("execute-task-simple"), {
+      primary: "claude-haiku-4-5",
+      fallbacks: [],
+      source: "synthesized",
+    });
+    assert.deepEqual(resolve("complete-slice"), {
+      primary: "claude-haiku-4-5",
+      fallbacks: [],
+      source: "synthesized",
+    });
+  } finally {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  }
+});
+
+// #1115 guard: the explicit flat-rate opt-out must suppress synthesized routing
+// even on the profile-derived (no tier_models) path — the opt-out moved ahead
+// of both synthesis branches, so a flat-rate start model with
+// allow_flat_rate_providers:false yields no config (start model is used as-is).
+test("resolvePreferredModelConfig honors flat-rate opt-out on the profile path (no tier_models)", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = makeTempDir("gsd-routing-flatrate-notier-");
+  const tempGsdHome = makeTempDir("gsd-routing-flatrate-notier-home-");
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "token_profile: budget",
+        "dynamic_routing:",
+        "  enabled: true",
+        "  allow_flat_rate_providers: false",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const config = resolvePreferredModelConfig(
+      "execute-task",
+      // claude-code is a built-in flat-rate provider.
+      { provider: "claude-code", id: "claude-opus-4-6" },
+      true,
+      tempProject,
+      ["anthropic/claude-haiku-4-5", "anthropic/claude-sonnet-4-6", "anthropic/claude-opus-4-6"],
+    );
+
+    assert.equal(config, undefined);
+  } finally {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  }
+});
+
 test("selectAndApplyModel honors explicit phase models without downgrading (#3617)", async () => {
   const originalCwd = process.cwd();
   const originalGsdHome = process.env.GSD_HOME;

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

@@ -61,6 +61,7 @@ async function runSuccessfulFinalize(s: AutoSession) {
     },
     stopAuto: async () => {},
     pauseAuto: async () => {},
+    checkpointWorkflowDatabase() {},
     updateProgressWidget() {},
     postUnitPreVerification: async () => "continue",
     runPostUnitVerification: async () => "continue",
@@ -410,9 +411,13 @@ test("runFinalize stops before merge when an isolated unit leaks app files into
   const notifications: Array<{ message: string; level?: string }> = [];
   const stopCalls: Array<{ reason?: string; preserve?: boolean }> = [];
   const mergeCalls: string[] = [];
+  const checkpointCalls: string[] = [];
   const result = await runFinalizeWithDeps(
     s,
     {
+      checkpointWorkflowDatabase() {
+        checkpointCalls.push("checkpoint");
+      },
       stopAuto: async (_ctx: unknown, _pi: unknown, reason?: string, options?: { preserveCompletedMilestoneBranch?: boolean }) => {
         stopCalls.push({ reason, preserve: options?.preserveCompletedMilestoneBranch });
       },
@@ -438,16 +443,53 @@ test("runFinalize stops before merge when an isolated unit leaks app files into
 
   assert.equal(result.action, "break");
   assert.equal(result.reason, "root-write-leak");
+  assert.deepEqual(checkpointCalls, ["checkpoint"], "root-write leak should flush DB before stopAuto");
   assert.deepEqual(stopCalls, [{ reason: "Root-write leak during isolated auto-mode", preserve: true }]);
   assert.deepEqual(mergeCalls, [], "root-write leak must stop before merge preflight");
   const message = notifications.find((n) => n.level === "error")?.message ?? "";
   assert.match(message, /execute-task M001\/S01\/T01/);
   assert.match(message, /Project root:/);
   assert.match(message, /Expected worktree:/);
-  assert.match(message, /index\.html/);
+  assert.doesNotMatch(message, /index\.html/);
   assert.match(message, /tests\/verify-s09\.sh/);
 });
 
+test("runFinalize ignores tracked root artifact changes during isolated units", async (t) => {
+  const root = mkdtempSync(join(tmpdir(), "gsd-root-leak-tracked-"));
+  const worktree = join(root, ".gsd", "worktrees", "M001");
+  t.after(() => {
+    rmSync(root, { recursive: true, force: true });
+  });
+  initRepo(root);
+  writeFileSync(join(root, "openapi.json"), "{}\n");
+  runGit(root, ["add", "openapi.json"]);
+  runGit(root, ["commit", "-m", "chore: add generated spec"]);
+  mkdirSync(worktree, { recursive: true });
+
+  const s = new AutoSession();
+  s.basePath = worktree;
+  s.originalBasePath = root;
+  s.currentMilestoneId = "M001";
+  s.rootWriteBaseline = captureRootDirtySnapshot(root);
+  s.currentUnit = {
+    type: "execute-task",
+    id: "M001/S01/T01",
+    startedAt: Date.now(),
+  };
+
+  writeFileSync(join(root, "openapi.json"), "{\"generated\":true}\n");
+
+  const stopCalls: string[] = [];
+  const result = await runFinalizeWithDeps(s, {
+    stopAuto: async (_ctx: unknown, _pi: unknown, reason?: string) => {
+      stopCalls.push(reason ?? "");
+    },
+  });
+
+  assert.equal(result.action, "next");
+  assert.deepEqual(stopCalls, []);
+});
+
 test("runFinalize allows root .gsd-only changes during isolated units", async (t) => {
   const root = mkdtempSync(join(tmpdir(), "gsd-root-leak-gsd-"));
   const worktree = join(root, ".gsd", "worktrees", "M001");

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

@@ -299,6 +299,63 @@ test("refreshRecoveryDbForArtifact treats missing execute-task DB rows as fatal
   });
 });
 
+test("refreshRecoveryDbForArtifact promotes an open execute-task DB row when artifacts are verified on disk (#1204)", () => {
+  const dir = makeTmpProject();
+  insertTask({
+    milestoneId: "M001",
+    sliceId: "S01",
+    id: "T01",
+    title: "Stuck Task",
+    status: "pending",
+  });
+  const sliceDir = join(dir, ".gsd", "milestones", "M001", "slices", "S01");
+  mkdirSync(sliceDir, { recursive: true });
+  writeFileSync(join(sliceDir, "S01-PLAN.md"), [
+    "# S01 Plan",
+    "",
+    "- [ ] **T01: Implement feature** `est:1h`",
+    "",
+  ].join("\n"));
+
+  const result = refreshRecoveryDbForArtifact("execute-task", "M001/S01/T01", dir);
+
+  assert.deepEqual(result, { ok: true });
+  assert.equal(getTask("M001", "S01", "T01")?.status, "complete");
+  const planContent = readFileSync(join(sliceDir, "S01-PLAN.md"), "utf-8");
+  assert.ok(planContent.includes("[x] **T01:"), "plan checkbox should be re-rendered to [x]");
+  const events = readEvents(join(dir, ".gsd", "event-log.jsonl"));
+  assert.ok(
+    events.some((e) => e.cmd === "complete-task" && e.trigger_reason === "stuck-artifact-recovery"),
+    "a complete-task recovery event should be appended",
+  );
+});
+
+test("refreshRecoveryDbForArtifact still appends the recovery event when the plan checkbox sync throws after DB promotion (#1221)", () => {
+  const dir = makeTmpProject();
+  insertTask({
+    milestoneId: "M001",
+    sliceId: "S01",
+    id: "T01",
+    title: "Stuck Task",
+    status: "pending",
+  });
+  const sliceDir = join(dir, ".gsd", "milestones", "M001", "slices", "S01");
+  mkdirSync(sliceDir, { recursive: true });
+  // Make the expected plan path a directory so the best-effort checkbox
+  // rewrite (readFileSync) throws EISDIR after the DB row is already promoted.
+  mkdirSync(join(sliceDir, "S01-PLAN.md"), { recursive: true });
+
+  const result = refreshRecoveryDbForArtifact("execute-task", "M001/S01/T01", dir);
+
+  assert.deepEqual(result, { ok: true });
+  assert.equal(getTask("M001", "S01", "T01")?.status, "complete");
+  const events = readEvents(join(dir, ".gsd", "event-log.jsonl"));
+  assert.ok(
+    events.some((e) => e.cmd === "complete-task" && e.trigger_reason === "stuck-artifact-recovery"),
+    "recovery event must still be appended even when the plan checkbox sync fails",
+  );
+});
+
 test("refreshRecoveryDbForArtifact closes complete-milestone DB row when artifacts exist but DB is stale (#5568)", async () => {
   const base = mkdtempSync(join(tmpdir(), "auto-recovery-complete-ms-"));
   mkdirSync(join(base, ".gsd"), { recursive: true });
@@ -838,6 +895,60 @@ test("verifyExpectedArtifact plan-slice fails when a task plan file is missing (
   }
 });
 
+test("verifyExpectedArtifact accepts flat-phase plan-slice with embedded tasks and no task plan files", () => {
+  const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
+  try {
+    const phaseDir = join(base, ".gsd", "phases", "01-test");
+    mkdirSync(join(phaseDir, "tasks"), { recursive: true });
+    writeFileSync(join(phaseDir, "01-01-PLAN.md"), [
+      "# S01: Test Slice",
+      "",
+      "<tasks>",
+      "- [ ] **T01**: Implement feature _(1h)_",
+      "  - Files: `src/index.ts`",
+      "  - Verify: pnpm test",
+      "- [ ] **T02**: Write tests _(1h)_",
+      "</tasks>",
+    ].join("\n"));
+
+    const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
+    assert.equal(result, true, "flat-phase embedded tasks should not require tasks/T##-PLAN.md files");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact plan-slice still verifies per-task files for legacy ## Tasks plan with a stray empty <tasks> block", () => {
+  const base = makeTmpBase();
+  try {
+    const tasksDir = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks");
+    const planPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
+    // Legacy layout: real tasks live in a "## Tasks" section with separate
+    // per-task PLAN files, but the plan also carries an empty <tasks></tasks>
+    // block. The empty block must NOT flip the plan into flat-phase mode and
+    // skip the per-task artifact checks.
+    const planContent = [
+      "# S01: Test Slice",
+      "",
+      "<tasks>",
+      "</tasks>",
+      "",
+      "## Tasks",
+      "",
+      "- [ ] **T01: First task** `est:1h`",
+      "- [ ] **T02: Second task** `est:2h`",
+    ].join("\n");
+    writeFileSync(planPath, planContent);
+    // Only T01-PLAN.md exists; T02's artifact is missing.
+    writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n\nDo the thing.");
+
+    const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
+    assert.equal(result, false, "a stray <tasks> block must not skip per-task file verification for a legacy ## Tasks plan");
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("verifyExpectedArtifact plan-slice fails for plan with no tasks (#699)", () => {
   const base = makeTmpBase();
   try {

package/src/resources/extensions/gsd/tests/auto-remote-session-lock-cleanup.test.ts

@@ -124,3 +124,44 @@ test("forceStopAutoRemote escalates a live remote PID and releases worker state"
   );
   assert.equal(readCrashLock(base), null, "force stop should remove the visible remote lock");
 });
+
+test("forceStopAutoRemote does not SIGKILL a PID that exits during the grace window", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const workerId = registerAutoWorker({ projectRootRealpath: normalizeRealPath(base) });
+  const pid = 525_252;
+  setWorkerPid(workerId, pid);
+  writeLegacyLock(base, pid);
+
+  // The process is alive until it receives SIGTERM, then exits cooperatively
+  // (liveness probe throws ESRCH) — so the grace loop should break before SIGKILL.
+  const signals: Array<NodeJS.Signals | 0> = [];
+  let alive = true;
+  const originalKill = process.kill;
+  process.kill = ((target: number, signal?: NodeJS.Signals | number) => {
+    assert.equal(target, pid);
+    if (signal === 0) {
+      if (!alive) {
+        const err = new Error("no such process") as NodeJS.ErrnoException;
+        err.code = "ESRCH";
+        throw err;
+      }
+      return true;
+    }
+    signals.push((signal ?? 0) as NodeJS.Signals | 0);
+    if (signal === "SIGTERM") alive = false; // cooperative exit on SIGTERM
+    return true;
+  }) as typeof process.kill;
+  t.after(() => {
+    process.kill = originalKill;
+  });
+
+  const result = forceStopAutoRemote(base);
+
+  assert.deepEqual(result, { found: true, pid });
+  assert.ok(signals.includes("SIGTERM"), "force stop should request graceful termination first");
+  assert.ok(!signals.includes("SIGKILL"), "force stop must not escalate when the PID exits during the grace window");
+  assert.equal(readCrashLock(base), null, "force stop should remove the visible remote lock");
+});