gsd-pi 2.50.0-dev.9476db8 → 2.50.0-dev.d210a87

package/src/resources/extensions/gsd/skill-discovery.ts

@@ -10,9 +10,10 @@
 
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { getAgentDir } from "@gsd/pi-coding-agent";
+import { homedir } from "node:os";
 
-const SKILLS_DIR = join(getAgentDir(), "skills");
+/** Industry-standard skills.sh global skills directory */
+const SKILLS_DIR = join(homedir(), ".agents", "skills");
 
 export interface DiscoveredSkill {
   name: string;

package/src/resources/extensions/gsd/skill-health.ts

@@ -15,7 +15,7 @@
 
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
-import { getAgentDir } from "@gsd/pi-coding-agent";
+import { homedir } from "node:os";
 import type { UnitMetrics, MetricsLedger } from "./metrics.js";
 import { formatCost, formatTokenCount, loadLedgerFromDisk } from "./metrics.js";
 import { getSkillLastUsed, detectStaleSkills } from "./skill-telemetry.js";
@@ -208,7 +208,7 @@ export function formatSkillDetail(basePath: string, skillName: string): string {
   }
 
   // Check for SKILL.md existence
-  const skillPath = join(getAgentDir(), "skills", skillName, "SKILL.md");
+  const skillPath = join(homedir(), ".agents", "skills", skillName, "SKILL.md");
   if (existsSync(skillPath)) {
     const stat = require("node:fs").statSync(skillPath);
     lines.push("");

package/src/resources/extensions/gsd/skill-telemetry.ts

@@ -13,7 +13,7 @@
 
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
-import { getAgentDir } from "@gsd/pi-coding-agent";
+import { homedir } from "node:os";
 
 // ─── In-memory state ──────────────────────────────────────────────────────────
 
@@ -30,8 +30,14 @@ const activelyLoadedSkills = new Set<string>();
  * Called before each unit starts.
  */
 export function captureAvailableSkills(): void {
-  const skillsDir = join(getAgentDir(), "skills");
-  availableSkills = listSkillNames(skillsDir);
+  const skillsDir = join(homedir(), ".agents", "skills");
+  const legacyDir = join(homedir(), ".gsd", "agent", "skills");
+  const names = listSkillNames(skillsDir);
+  // Include skills still in the legacy directory only if migration hasn't completed
+  const legacyMigrated = existsSync(join(legacyDir, ".migrated-to-agents"));
+  const legacyNames = legacyMigrated ? [] : listSkillNames(legacyDir);
+  const all = new Set([...names, ...legacyNames]);
+  availableSkills = [...all];
   activelyLoadedSkills.clear();
 }
 
@@ -99,8 +105,12 @@ export function detectStaleSkills(
   const stale: string[] = [];
 
   // Check all installed skills, not just those with usage data
-  const skillsDir = join(getAgentDir(), "skills");
-  const installed = listSkillNames(skillsDir);
+  const skillsDir = join(homedir(), ".agents", "skills");
+  const legacyDir = join(homedir(), ".gsd", "agent", "skills");
+  const legacyMigrated = existsSync(join(legacyDir, ".migrated-to-agents"));
+  const legacyNames = legacyMigrated ? [] : listSkillNames(legacyDir);
+  const installedSet = new Set([...listSkillNames(skillsDir), ...legacyNames]);
+  const installed = [...installedSet];
 
   for (const skill of installed) {
     const lastTs = lastUsed.get(skill);

package/src/resources/extensions/gsd/state.ts

@@ -34,7 +34,8 @@ import {
   gsdRoot,
 } from './paths.js';
 
-import { milestoneIdSort, findMilestoneIds } from './milestone-ids.js';
+import { findMilestoneIds } from './milestone-ids.js';
+import { loadQueueOrder, sortByQueueOrder } from './queue-order.js';
 import { nativeBatchParseGsdFiles, type BatchParsedFile } from './native-parser-bridge.js';
 
 import { join, resolve } from 'path';
@@ -149,8 +150,14 @@ export async function getActiveMilestoneId(basePath: string): Promise<string | n
   if (isDbAvailable()) {
     const allMilestones = getAllMilestones();
     if (allMilestones.length > 0) {
-      const sorted = [...allMilestones].sort((a, b) => a.id.localeCompare(b.id));
-      for (const m of sorted) {
+      // Respect queue-order.json so /gsd queue reordering is honored (#2556).
+      // Without this, the DB path uses lexicographic sort while the dispatch
+      // guard uses queue order — causing a deadlock.
+      const customOrder = loadQueueOrder(basePath);
+      const sortedIds = sortByQueueOrder(allMilestones.map(m => m.id), customOrder);
+      const byId = new Map(allMilestones.map(m => [m.id, m]));
+      for (const id of sortedIds) {
+        const m = byId.get(id)!;
         if (m.status === "complete" || m.status === "done" || m.status === "parked") continue;
         return m.id;
       }
@@ -304,8 +311,12 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
       } as MilestoneRow);
     }
   }
-  // Re-sort so milestones are in canonical order after injection
-  allMilestones.sort((a, b) => milestoneIdSort(a.id, b.id));
+  // Re-sort so milestones follow queue order (same as dispatch guard) (#2556)
+  const customOrder = loadQueueOrder(basePath);
+  const sortedIds = sortByQueueOrder(allMilestones.map(m => m.id), customOrder);
+  const byId = new Map(allMilestones.map(m => [m.id, m]));
+  allMilestones.length = 0;
+  for (const id of sortedIds) allMilestones.push(byId.get(id)!);
 
   // Parallel worker isolation: when locked, filter to just the locked milestone
   const milestoneLock = process.env.GSD_MILESTONE_LOCK;

package/src/resources/extensions/gsd/templates/milestone-validation.md

@@ -35,6 +35,18 @@ validated_at: {{date}}
 
 - **{{requirementId}}**: {{status}} — {{disposition: covered by remediation slice / acceptable gap / needs attention}}
 
+## Verification Class Compliance
+
+<!-- If verification classes were defined during planning, document whether each
+     was addressed. Use N/A for classes that were empty or "none" in planning. -->
+
+| Class | Planned | Evidence | Status |
+|-------|---------|----------|--------|
+| Contract | {{planned_or_none}} | {{evidence_or_none}} | {{MET / NOT MET / N/A}} |
+| Integration | {{planned_or_none}} | {{evidence_or_none}} | {{MET / NOT MET / N/A}} |
+| Operational | {{planned_or_none}} | {{evidence_or_none}} | {{MET / NOT MET / N/A}} |
+| UAT | {{planned_or_none}} | {{evidence_or_none}} | {{MET / NOT MET / N/A}} |
+
 ## Remediation Slices
 
 <!-- New slices appended to the roadmap to address auto-remediable gaps.

package/src/resources/extensions/gsd/templates/preferences.md

@@ -71,6 +71,8 @@ remote_questions:
 uat_dispatch:
 post_unit_hooks: []
 pre_dispatch_hooks: []
+# experimental:
+#   rtk: false
 ---
 
 # GSD Skill Preferences

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

@@ -1,5 +1,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 
 import {
   unitVerb,
@@ -11,6 +13,9 @@ import {
   extractUatSliceId,
 } from "../auto-dashboard.ts";
 
+const autoSource = readFileSync(join(process.cwd(), "src", "resources", "extensions", "gsd", "auto.ts"), "utf-8");
+const dashboardSource = readFileSync(join(process.cwd(), "src", "resources", "extensions", "gsd", "auto-dashboard.ts"), "utf-8");
+
 // ─── unitVerb ─────────────────────────────────────────────────────────────
 
 test("unitVerb maps known unit types to verbs", () => {
@@ -180,6 +185,17 @@ test("formatAutoElapsed returns empty string for negative autoStartTime", () =>
   assert.equal(formatAutoElapsed(NaN), "");
 });
 
+test("getAutoDashboardData returns RTK savings in the dashboard payload", () => {
+  assert.match(autoSource, /const rtkSavings = sessionId && s\.basePath/);
+  assert.match(autoSource, /rtkSavings,/);
+});
+
+test("auto progress widget renders RTK savings under the footer stats line", () => {
+  assert.match(dashboardSource, /formatRtkSavingsLabel/);
+  assert.match(dashboardSource, /getRtkSessionSavings\(accessors\.getBasePath\(\), sessionId\)/);
+  assert.match(dashboardSource, /lines\.push\(rightAlign\("", theme\.fg\("dim", cachedRtkLabel\), width\)\);/);
+});
+
 // ─── extractUatSliceId ───────────────────────────────────────────────────
 
 test("extractUatSliceId extracts slice ID from M001/S01 format", () => {

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

@@ -140,7 +140,7 @@ test("isLockProcessAlive returns false for dead PID", () => {
   assert.equal(isLockProcessAlive(lock), false, "dead PID should return false");
 });
 
-test("isLockProcessAlive returns false for own PID (recycled)", () => {
+test("#2470: isLockProcessAlive returns true for own PID (we hold the lock)", () => {
   const lock = {
     pid: process.pid,
     startedAt: new Date().toISOString(),
@@ -148,7 +148,7 @@ test("isLockProcessAlive returns false for own PID (recycled)", () => {
     unitId: "M001/S01/T01",
     unitStartedAt: new Date().toISOString(),
   };
-  assert.equal(isLockProcessAlive(lock), false, "own PID should return false (recycled)");
+  assert.equal(isLockProcessAlive(lock), true, "own PID means we are alive — not stale (#2470)");
 });
 
 test("isLockProcessAlive returns false for invalid PID", () => {

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

@@ -882,6 +882,74 @@ test("autoLoop handles dispatch stop action", async (t) => {
   );
 });
 
+// #2474: warning-level dispatch stop should pause (resumable), not hard-stop
+test("autoLoop pauses instead of stopping for warning-level dispatch stop", async (t) => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  const pi = makeMockPi();
+  const s = makeLoopSession();
+
+  const deps = makeMockDeps({
+    resolveDispatch: async () => {
+      deps.callLog.push("resolveDispatch");
+      return {
+        action: "stop" as const,
+        reason: 'UAT verdict for S01 is "partial" — blocking progression.',
+        level: "warning" as const,
+      };
+    },
+  });
+
+  await autoLoop(ctx, pi, s, deps);
+
+  assert.ok(
+    deps.callLog.includes("resolveDispatch"),
+    "should have called resolveDispatch",
+  );
+  assert.ok(
+    deps.callLog.includes("pauseAuto"),
+    "warning-level stop should call pauseAuto (resumable)",
+  );
+  assert.ok(
+    !deps.callLog.includes("stopAuto"),
+    "warning-level stop should NOT call stopAuto (hard stop)",
+  );
+});
+
+// #2474: error-level dispatch stop should still hard-stop
+test("autoLoop hard-stops for error-level dispatch stop", async (t) => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  const pi = makeMockPi();
+  const s = makeLoopSession();
+
+  const deps = makeMockDeps({
+    resolveDispatch: async () => {
+      deps.callLog.push("resolveDispatch");
+      return {
+        action: "stop" as const,
+        reason: "Cannot complete milestone: missing SUMMARY files.",
+        level: "error" as const,
+      };
+    },
+  });
+
+  await autoLoop(ctx, pi, s, deps);
+
+  assert.ok(
+    deps.callLog.includes("stopAuto"),
+    "error-level stop should call stopAuto (hard stop)",
+  );
+  assert.ok(
+    !deps.callLog.includes("pauseAuto"),
+    "error-level stop should NOT call pauseAuto",
+  );
+});
+
 test("autoLoop handles dispatch skip action by continuing", async (t) => {
   _resetPendingResolve();
 

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

@@ -5,6 +5,7 @@ import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { invalidateAllCaches } from '../cache.ts';
+import { parseUnitId } from "../unit-id.ts";
 
 // loadPrompt reads from ~/.gsd/agent/extensions/gsd/prompts/ (main checkout).
 // In a worktree the file may not exist there yet, so we resolve prompts
@@ -222,8 +223,7 @@ describe("complete-milestone", () => {
 
       const unitType = "complete-milestone";
       const unitId = "M001";
-      const parts = unitId.split("/");
-      const mid = parts[0]!;
+      const { milestone: mid } = parseUnitId(unitId);
 
       // This is the exact logic from diagnoseExpectedArtifact for "complete-milestone"
       const result = `${relMilestoneFile(base, mid, "SUMMARY")} (milestone summary)`;

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

@@ -68,8 +68,10 @@ test("clearLock is safe when no lock exists", (t) => {
 
 // ─── isLockProcessAlive ──────────────────────────────────────────────────
 
-test("isLockProcessAlive returns true for current process (different pid)", () => {
-  // Our own PID is explicitly excluded (recycled PID guard)
+test("#2470: isLockProcessAlive returns true for own PID (we hold the lock)", () => {
+  // Own PID means we ARE the lock holder — alive, not stale. (#2470)
+  // Callers that need recycled-PID detection (e.g. startAuto) already
+  // guard with `crashLock.pid !== process.pid` before calling us.
   const lock: LockData = {
     pid: process.pid,
     startedAt: new Date().toISOString(),
@@ -77,7 +79,7 @@ test("isLockProcessAlive returns true for current process (different pid)", () =
     unitId: "M001/S01/T01",
     unitStartedAt: new Date().toISOString(),
   };
-  assert.equal(isLockProcessAlive(lock), false, "own PID should return false");
+  assert.equal(isLockProcessAlive(lock), true, "own PID should return true — we are alive");
 });
 
 test("isLockProcessAlive returns false for dead PID", () => {

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

@@ -15,6 +15,7 @@ import { tmpdir } from "node:os";
 import { stringify } from "yaml";
 import { runCustomVerification } from "../custom-verification.ts";
 import type { WorkflowDefinition } from "../definition-loader.ts";
+import { createFakeRtk } from "../../../../tests/rtk-test-utils.ts";
 
 /** Create a temp run directory with the given definition and optional files. */
 function makeTempRun(
@@ -225,6 +226,38 @@ describe("shell-command policy", () => {
     const result = runCustomVerification(runDir, "step-1");
     assert.equal(result, "retry");
   });
+
+  it("rewrites shell-command verification through RTK when available", () => {
+    const fake = createFakeRtk({
+      "echo raw": "echo rewritten",
+    });
+    const previous = process.env.GSD_RTK_PATH;
+    process.env.GSD_RTK_PATH = fake.path;
+
+    try {
+      const def = makeDef([
+        {
+          id: "step-1",
+          name: "Build artifact",
+          prompt: "Build the artifact",
+          requires: [],
+          produces: ["artifact.txt"],
+          verify: {
+            policy: "shell-command",
+            command: "echo raw",
+          },
+        },
+      ]);
+
+      const runDir = makeTempRun(def);
+      const result = runCustomVerification(runDir, "step-1");
+      assert.equal(result, "continue");
+    } finally {
+      if (previous === undefined) delete process.env.GSD_RTK_PATH;
+      else process.env.GSD_RTK_PATH = previous;
+      fake.cleanup();
+    }
+  });
 });
 
 // ─── prompt-verify tests ────────────────────────────────────────────────

package/src/resources/extensions/gsd/tests/derive-state-db.test.ts

@@ -769,9 +769,10 @@ describe('derive-state-db', async () => {
       const elapsed = performance.now() - start;
 
       console.log(`  deriveStateFromDb() took ${elapsed.toFixed(3)}ms`);
-      // Use 10ms threshold — catches real regressions without flaking on
-      // CI runners under load (1ms threshold failed at 1.050ms on GitHub Actions)
-      assert.ok(elapsed < 10, `perf-db: deriveStateFromDb() <10ms (got ${elapsed.toFixed(3)}ms)`);
+      // Use 25ms threshold — catches real regressions without flaking on
+      // slower CI runners (Windows agents measured at ~12ms under load;
+      // the 10ms threshold was too tight for those environments).
+      assert.ok(elapsed < 25, `perf-db: deriveStateFromDb() <25ms (got ${elapsed.toFixed(3)}ms)`);
 
       closeDatabase();
     } finally {