gsd-pi 2.80.0-dev.2be7caf18 → 2.80.0-dev.42bd34838

package/src/resources/extensions/gsd/tests/unit-dispatches.test.ts

@@ -21,6 +21,7 @@ import {
   markFailed,
   markStuck,
   markCanceled,
+  markLatestActiveForWorkerCanceled,
   getRecentForUnit,
   getLatestForUnit,
 } from "../db/unit-dispatches.ts";
@@ -196,6 +197,35 @@ test("markStuck and markCanceled set their respective statuses", (t) => {
   assert.equal(getLatestForUnit("M001/S01/T01")!.status, "canceled");
 });
 
+test("markLatestActiveForWorkerCanceled cancels only the latest active dispatch for a worker", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  const { workerId, leaseToken } = setup(base);
+
+  const first = recordDispatchClaim({
+    traceId: "tc-1", workerId, milestoneLeaseToken: leaseToken,
+    milestoneId: "M001", unitType: "plan-slice", unitId: "M001/S01",
+  });
+  assert.equal(first.ok, true);
+  if (!first.ok) return;
+  markCompleted(first.dispatchId);
+
+  const second = recordDispatchClaim({
+    traceId: "tc-2", workerId, milestoneLeaseToken: leaseToken,
+    milestoneId: "M001", unitType: "run-task", unitId: "M001/S01/T01",
+  });
+  assert.equal(second.ok, true);
+  if (!second.ok) return;
+  markRunning(second.dispatchId);
+
+  assert.equal(markLatestActiveForWorkerCanceled(workerId, "signal-exit"), true);
+  assert.equal(getLatestForUnit("M001/S01")!.status, "completed");
+  const latest = getLatestForUnit("M001/S01/T01")!;
+  assert.equal(latest.status, "canceled");
+  assert.equal(latest.exit_reason, "signal-exit");
+  assert.equal(markLatestActiveForWorkerCanceled(workerId, "signal-exit"), false);
+});
+
 test("terminal transitions do not overwrite an already terminal dispatch", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));

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

@@ -9,6 +9,7 @@ import {
   readUnitRuntimeRecord,
   writeUnitRuntimeRecord,
 } from "../unit-runtime.ts";
+import { closeDatabase, insertMilestone, insertSlice, insertTask, openDatabase } from "../gsd-db.ts";
 import { clearPathCache } from '../paths.ts';
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
@@ -72,6 +73,35 @@ console.log("\n=== runtime record cleanup ===");
   assert.deepStrictEqual(loaded, null, "record removed");
 }
 
+console.log("\n=== execute-task durability trusts closed DB task status ===");
+{
+  const dbBase = mkdtempSync(join(tmpdir(), "gsd-unit-runtime-db-test-"));
+  mkdirSync(join(dbBase, ".gsd", "milestones", "M300", "slices", "S01", "tasks"), { recursive: true });
+  try {
+    openDatabase(join(dbBase, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M300", title: "DB Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M300", title: "DB Slice", status: "in_progress" });
+    insertTask({ id: "T01", milestoneId: "M300", sliceId: "S01", title: "DB Task", status: "complete" });
+    writeFileSync(
+      join(dbBase, ".gsd", "milestones", "M300", "slices", "S01", "S01-PLAN.md"),
+      "# S01\n\n## Tasks\n\n- [ ] **T01: DB Task** `est:10m`\n",
+      "utf-8",
+    );
+    writeFileSync(join(dbBase, ".gsd", "STATE.md"), "## Next Action\nExecute T01 for S01: DB task\n", "utf-8");
+
+    const status = await inspectExecuteTaskDurability(dbBase, "M300/S01/T01");
+    assert.ok(status !== null, "db-complete: status exists");
+    assert.equal(status!.dbComplete, true, "db-complete: closed DB status is captured");
+    assert.equal(status!.summaryExists, false, "db-complete: summary can still be missing");
+    assert.equal(status!.taskChecked, false, "db-complete: checkbox can still be unchecked");
+    assert.equal(status!.nextActionAdvanced, false, "db-complete: next action can still point at task");
+    assert.equal(formatExecuteTaskRecoveryStatus(status!), "DB task status is closed");
+  } finally {
+    closeDatabase();
+    rmSync(dbBase, { recursive: true, force: true });
+  }
+}
+
 console.log("\n=== hook unit type sanitization (slash in unitType) ===");
 {
   // Hook units have unitType like "hook/code-review" with a slash

package/src/resources/extensions/gsd/tests/workflow-tool-executors.test.ts

@@ -165,6 +165,9 @@ test("executeMilestoneStatus returns milestone metadata and slice counts", async
     assert.equal(parsed.sliceCount, 1);
     assert.equal(parsed.slices[0].id, "S01");
     assert.equal(parsed.slices[0].taskCounts.pending, 1);
+    assert.equal(result.details.status, "active");
+    assert.equal(result.details.title, "Milestone One");
+    assert.deepEqual(result.details.slices, parsed.slices);
   } finally {
     closeDatabase();
     cleanup(base);

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: WorktreeResolver unit and regression tests.
 import test from "node:test";
 import assert from "node:assert/strict";
 import { mkdtempSync, rmSync, mkdirSync, realpathSync } from "node:fs";
@@ -9,6 +11,17 @@ import {
   type NotifyCtx,
 } from "../worktree-resolver.js";
 import { AutoSession } from "../auto/session.js";
+import {
+  closeDatabase,
+  insertMilestone,
+  openDatabase,
+} from "../gsd-db.js";
+import { registerAutoWorker } from "../db/auto-workers.js";
+import {
+  claimMilestoneLease,
+  getMilestoneLease,
+  releaseMilestoneLease,
+} from "../db/milestone-leases.js";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -19,11 +32,12 @@ interface CallLog {
 }
 
 function makeSession(
-  overrides?: Partial<{ basePath: string; originalBasePath: string }>,
+  overrides?: Partial<AutoSession>,
 ): AutoSession {
   const s = new AutoSession();
   s.basePath = overrides?.basePath ?? "/project";
   s.originalBasePath = overrides?.originalBasePath ?? "/project";
+  Object.assign(s, overrides);
   return s;
 }
 
@@ -182,6 +196,17 @@ function findCalls(calls: CallLog[], fn: string): CallLog[] {
   return calls.filter((c) => c.fn === fn);
 }
 
+function makeDbBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-worktree-resolver-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanupDbBase(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
 // ─── Getter Tests ────────────────────────────────────────────────────────────
 
 test("workPath returns s.basePath", () => {
@@ -371,6 +396,43 @@ test("enterMilestone does not create double-nested worktree when originalBasePat
   );
 });
 
+test("enterMilestone reacquires a released same-milestone lease before worktree entry", (t) => {
+  const base = makeDbBase();
+  t.after(() => cleanupDbBase(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test milestone", status: "active" });
+
+  const workerId = registerAutoWorker({ projectRootRealpath: base });
+  const originalClaim = claimMilestoneLease(workerId, "M001");
+  assert.equal(originalClaim.ok, true);
+  if (!originalClaim.ok) throw new Error("expected test lease claim");
+  assert.equal(releaseMilestoneLease(workerId, "M001", originalClaim.token), true);
+
+  const s = makeSession({
+    basePath: base,
+    originalBasePath: base,
+    workerId,
+    currentMilestoneId: "M001",
+    milestoneLeaseToken: originalClaim.token,
+  });
+  const deps = makeDeps({
+    createAutoWorktree: (basePath: string, milestoneId: string) => join(basePath, ".gsd", "worktrees", milestoneId),
+  });
+  const ctx = makeNotifyCtx();
+  const resolver = new WorktreeResolver(s, deps);
+
+  resolver.enterMilestone("M001", ctx);
+
+  const row = getMilestoneLease("M001");
+  assert.ok(row);
+  assert.equal(row.worker_id, workerId);
+  assert.equal(row.status, "held");
+  assert.equal(row.fencing_token, originalClaim.token + 1);
+  assert.equal(s.milestoneLeaseToken, originalClaim.token + 1);
+  assert.equal(s.basePath, join(base, ".gsd", "worktrees", "M001"));
+  assert.equal(ctx.messages.some((m) => m.level === "error"), false);
+});
+
 // ─── enterMilestone Tests (branch mode) ──────────────────────────────────────
 
 test("enterMilestone in branch mode calls enterBranchModeForMilestone and rebuilds GitService", () => {

package/src/resources/extensions/gsd/tools/memory-tools.ts

@@ -308,6 +308,7 @@ function includeSupersededMemories(rankedActive: Memory[]): Memory[] {
         scope: (row["scope"] as string) ?? "project",
         tags,
         structured_fields: structuredFields,
+        last_hit_at: (row["last_hit_at"] as string | null) ?? null,
       };
     });
   } catch {

package/src/resources/extensions/gsd/tools/workflow-tool-executors.ts

@@ -813,7 +813,7 @@ export async function executeMilestoneStatus(
 
       return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-        details: { operation: "milestone_status", milestoneId: milestone.id, sliceCount: slices.length },
+        details: { operation: "milestone_status", ...result },
       };
     });
   } catch (err) {

package/src/resources/extensions/gsd/unit-runtime.ts

@@ -10,6 +10,8 @@ import {
 } from "./paths.js";
 import { loadFile, parseTaskPlanMustHaves, countMustHavesMentionedInSummary } from "./files.js";
 import { parseUnitId } from "./unit-id.js";
+import { getTask, isDbAvailable, refreshOpenDatabaseFromDisk } from "./gsd-db.js";
+import { isClosedStatus } from "./status-guards.js";
 
 // Per-record advisory lock — prevents read-modify-write races between
 // concurrent writers updating disjoint fields of the same runtime record.
@@ -92,6 +94,7 @@ export interface ExecuteTaskRecoveryStatus {
   summaryExists: boolean;
   taskChecked: boolean;
   nextActionAdvanced: boolean;
+  dbComplete: boolean;
   mustHaveCount: number;
   mustHavesMentionedInSummary: number;
 }
@@ -213,6 +216,12 @@ export async function inspectExecuteTaskDurability(
   const escapedTid = tid.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const taskChecked = !!planContent && new RegExp(`^- \\[[xX]\\] \\*\\*${escapedTid}:`, "m").test(planContent);
   const nextActionAdvanced = !new RegExp(`Execute ${tid}\\b`).test(stateContent);
+  let dbComplete = false;
+  if (isDbAvailable()) {
+    refreshOpenDatabaseFromDisk();
+    const task = getTask(mid, sid, tid);
+    dbComplete = !!task && isClosedStatus(task.status);
+  }
 
   // Must-have coverage: load task plan and count mentions in summary
   let mustHaveCount = 0;
@@ -239,12 +248,14 @@ export async function inspectExecuteTaskDurability(
     summaryExists,
     taskChecked,
     nextActionAdvanced,
+    dbComplete,
     mustHaveCount,
     mustHavesMentionedInSummary,
   };
 }
 
 export function formatExecuteTaskRecoveryStatus(status: ExecuteTaskRecoveryStatus): string {
+  if (status.dbComplete) return "DB task status is closed";
   const missing = [] as string[];
   if (!status.summaryExists) missing.push(`summary missing (${status.summaryPath})`);
   if (!status.taskChecked) missing.push(`task checkbox unchecked in ${status.planPath}`);

package/src/resources/extensions/gsd/worktree-resolver.ts

@@ -25,7 +25,7 @@ import { emitWorktreeCreated, emitWorktreeMerged } from "./worktree-telemetry.js
 import { getCollapseCadence, getMilestoneResquash, resquashMilestoneOnMain } from "./slice-cadence.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { resolveWorktreeProjectRoot, normalizeWorktreePathForCompare } from "./worktree-root.js";
-import { claimMilestoneLease, releaseMilestoneLease } from "./db/milestone-leases.js";
+import { claimMilestoneLease, refreshMilestoneLease, releaseMilestoneLease } from "./db/milestone-leases.js";
 
 // ─── Path Comparison Helper ────────────────────────────────────────────────
 /**
@@ -207,23 +207,44 @@ export class WorktreeResolver {
     // milestone (re-entry within the same session).
     if (this.s.workerId) {
       if (this.s.currentMilestoneId === milestoneId && this.s.milestoneLeaseToken !== null) {
-        // Already held — no-op, the heartbeat in loop.ts refreshes TTL.
-      } else {
-        // If we held a different milestone, release it first so other
-        // workers don't have to wait for TTL.
-        if (this.s.currentMilestoneId && this.s.currentMilestoneId !== milestoneId && this.s.milestoneLeaseToken !== null) {
-          try {
-            releaseMilestoneLease(this.s.workerId, this.s.currentMilestoneId, this.s.milestoneLeaseToken);
-          } catch (err) {
-            debugLog("WorktreeResolver", {
-              action: "enterMilestone",
-              milestoneId,
-              releasePriorLeaseError: err instanceof Error ? err.message : String(err),
-            });
-          }
+        const refreshed = refreshMilestoneLease(
+          this.s.workerId,
+          milestoneId,
+          this.s.milestoneLeaseToken,
+        );
+        if (refreshed) {
+          debugLog("WorktreeResolver", {
+            action: "enterMilestone",
+            milestoneId,
+            leaseRefreshed: true,
+            fencingToken: this.s.milestoneLeaseToken,
+          });
+        } else {
+          debugLog("WorktreeResolver", {
+            action: "enterMilestone",
+            milestoneId,
+            staleLeaseToken: this.s.milestoneLeaseToken,
+          });
           this.s.milestoneLeaseToken = null;
         }
+      }
+
+      // If we held a different milestone, release it first so other
+      // workers don't have to wait for TTL.
+      if (this.s.currentMilestoneId && this.s.currentMilestoneId !== milestoneId && this.s.milestoneLeaseToken !== null) {
+        try {
+          releaseMilestoneLease(this.s.workerId, this.s.currentMilestoneId, this.s.milestoneLeaseToken);
+        } catch (err) {
+          debugLog("WorktreeResolver", {
+            action: "enterMilestone",
+            milestoneId,
+            releasePriorLeaseError: err instanceof Error ? err.message : String(err),
+          });
+        }
+        this.s.milestoneLeaseToken = null;
+      }
 
+      if (this.s.milestoneLeaseToken === null) {
         try {
           const claim = claimMilestoneLease(this.s.workerId, milestoneId);
           if (claim.ok) {