gsd-pi 2.49.0 → 2.50.0-dev.d210a87

package/dist/resources/extensions/gsd/skill-discovery.js

@@ -9,8 +9,9 @@
  */
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { getAgentDir } from "@gsd/pi-coding-agent";
-const SKILLS_DIR = join(getAgentDir(), "skills");
+import { homedir } from "node:os";
+/** Industry-standard skills.sh global skills directory */
+const SKILLS_DIR = join(homedir(), ".agents", "skills");
 /** Snapshot of skill names at auto-mode start */
 let baselineSkills = null;
 /**

package/dist/resources/extensions/gsd/skill-health.js

@@ -14,7 +14,7 @@
  */
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { getAgentDir } from "@gsd/pi-coding-agent";
+import { homedir } from "node:os";
 import { formatCost, formatTokenCount, loadLedgerFromDisk } from "./metrics.js";
 import { detectStaleSkills } from "./skill-telemetry.js";
 // ─── Constants ────────────────────────────────────────────────────────────────
@@ -141,7 +141,7 @@ export function formatSkillDetail(basePath, skillName) {
         lines.push(`  ${date}  ${u.id.padEnd(20)}  ${formatTokenCount(u.tokens.total).padStart(8)} tokens  ${formatCost(u.cost)}`);
     }
     // 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/dist/resources/extensions/gsd/skill-telemetry.js

@@ -12,7 +12,7 @@
  */
 import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
-import { getAgentDir } from "@gsd/pi-coding-agent";
+import { homedir } from "node:os";
 // ─── In-memory state ──────────────────────────────────────────────────────────
 /** Skills available in the system prompt for the current unit */
 let availableSkills = [];
@@ -24,8 +24,14 @@ const activelyLoadedSkills = new Set();
  * Called before each unit starts.
  */
 export function captureAvailableSkills() {
-    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();
 }
 /**
@@ -85,8 +91,12 @@ export function detectStaleSkills(units, thresholdDays) {
     const cutoff = Date.now() - (thresholdDays * 24 * 60 * 60 * 1000);
     const stale = [];
     // 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);
         if (lastTs === undefined || lastTs < cutoff) {

package/dist/resources/extensions/gsd/state.js

@@ -4,12 +4,14 @@
 import { parseRoadmap, parsePlan, } from './parsers-legacy.js';
 import { parseSummary, loadFile, parseRequirementCounts, parseContextDependsOn, } from './files.js';
 import { resolveMilestoneFile, resolveSlicePath, resolveSliceFile, resolveTaskFile, resolveTasksDir, resolveGsdRootFile, 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 } from './native-parser-bridge.js';
 import { join, resolve } from 'path';
 import { existsSync, readdirSync } from 'node:fs';
 import { debugCount, debugTime } from './debug-logger.js';
-import { isDbAvailable, getAllMilestones, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, updateTaskStatus, } from './gsd-db.js';
+import { extractVerdict } from './verdict-parser.js';
+import { isDbAvailable, getAllMilestones, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, updateTaskStatus, getPendingSliceGateCount, } from './gsd-db.js';
 /**
  * A "ghost" milestone directory contains only META.json (and no substantive
  * files like CONTEXT, CONTEXT-DRAFT, ROADMAP, or SUMMARY).  These appear when
@@ -42,13 +44,9 @@ export function isMilestoneComplete(roadmap) {
  * after remediation slices are executed.
  */
 export function isValidationTerminal(validationContent) {
-    const match = validationContent.match(/^---\n([\s\S]*?)\n---/);
-    if (!match)
+    const v = extractVerdict(validationContent);
+    if (!v)
         return false;
-    const verdict = match[1].match(/verdict:\s*(\S+)/);
-    if (!verdict)
-        return false;
-    const v = verdict[1] === 'passed' ? 'pass' : verdict[1];
     // 'pass' and 'needs-attention' are always terminal.
     // 'needs-remediation' is treated as terminal to prevent infinite loops
     // when no remediation slices exist in the roadmap (#832). The validation
@@ -87,8 +85,14 @@ export async function getActiveMilestoneId(basePath) {
     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;
@@ -236,8 +240,13 @@ export async function deriveStateFromDb(basePath) {
             });
         }
     }
-    // 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;
     const milestones = milestoneLock
@@ -595,6 +604,21 @@ export async function deriveStateFromDb(basePath) {
             };
         }
     }
+    // ── Quality gate evaluation check ──────────────────────────────────
+    // If slice-scoped gates (Q3/Q4) are still pending, pause before execution
+    // so the gate-evaluate dispatch rule can run parallel sub-agents.
+    // Slices with zero gate rows (pre-feature or simple) skip straight through.
+    const pendingGateCount = getPendingSliceGateCount(activeMilestone.id, activeSlice.id);
+    if (pendingGateCount > 0) {
+        return {
+            activeMilestone, activeSlice, activeTask: null,
+            phase: 'evaluating-gates',
+            recentDecisions: [], blockers: [],
+            nextAction: `Evaluate ${pendingGateCount} quality gate(s) for ${activeSlice.id} before execution.`,
+            registry, requirements,
+            progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
+        };
+    }
     // ── Blocker detection: check completed tasks for blocker_discovered ──
     const completedTasks = tasks.filter(t => isStatusDone(t.status));
     let blockerTaskId = null;
@@ -1143,6 +1167,21 @@ export async function _deriveStateImpl(basePath) {
         };
     }
     const slicePlan = parsePlan(slicePlanContent);
+    // ── Reconcile stale task status for filesystem-based projects (#2514) ──
+    // Heading-style tasks (### T01:) are always parsed as done=false by
+    // parsePlan because the heading syntax has no checkbox. When the agent
+    // writes a SUMMARY file but the plan's heading isn't converted to a
+    // checkbox, the task appears incomplete forever — causing infinite
+    // re-dispatch. Reconcile by checking SUMMARY files on disk.
+    for (const t of slicePlan.tasks) {
+        if (t.done)
+            continue;
+        const summaryPath = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, t.id, "SUMMARY");
+        if (summaryPath && existsSync(summaryPath)) {
+            t.done = true;
+            process.stderr.write(`gsd-reconcile: task ${activeMilestone.id}/${activeSlice.id}/${t.id} has SUMMARY on disk but plan shows incomplete — marking done (#2514)\n`);
+        }
+    }
     const taskProgress = {
         done: slicePlan.tasks.filter(t => t.done).length,
         total: slicePlan.tasks.length,

package/dist/resources/extensions/gsd/templates/milestone-summary.md

@@ -49,6 +49,14 @@ completed_at: {{date}}
 
 - {{requirementId}}: {{fromStatus}} → {{toStatus}} — {{evidence}}
 
+## Decision Re-evaluation
+
+<!-- Review decisions from this milestone. OMIT if no decisions need re-evaluation. -->
+
+| Decision | Original Rationale | Still Valid? | Action |
+|----------|-------------------|-------------|--------|
+| {{decisionId}} | {{originalRationale}} | {{yes/no/partially}} | {{keep/revise/supersede}} |
+
 ## Forward Intelligence
 
 <!-- Write what you wish you'd known at the start of this milestone.

package/dist/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/dist/resources/extensions/gsd/templates/plan.md

@@ -8,6 +8,22 @@
 - {{mustHave}}
 - {{mustHave}}
 
+## Threat Surface
+
+<!-- Q3: How can this be exploited? OMIT ENTIRELY for simple slices with no auth, user input, or data exposure. -->
+
+- **Abuse**: {{abuseScenarios — parameter tampering, replay, privilege escalation, or N/A}}
+- **Data exposure**: {{sensitiveDataAccessible — PII, tokens, secrets, or none}}
+- **Input trust**: {{untrustedInput — user input reaching DB/API/filesystem, or none}}
+
+## Requirement Impact
+
+<!-- Q4: What existing promises does this break? OMIT ENTIRELY if no existing requirements are affected. -->
+
+- **Requirements touched**: {{requirementIds — e.g. R001, R003, or none}}
+- **Re-verify**: {{whatMustBeRetested — e.g. login flow, API contract, or N/A}}
+- **Decisions revisited**: {{decisionIds — e.g. D002, or none}}
+
 ## Proof Level
 
 <!-- Omit this section entirely for simple slices where the answer is trivially obvious. -->

package/dist/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/dist/resources/extensions/gsd/templates/roadmap.md

@@ -92,6 +92,19 @@ This milestone is complete only when all are true:
   - Each "After this" line must be truthful about proof level: if only fixtures or tests prove it, say so; do not imply the user can already perform the live end-to-end behavior unless that has actually been exercised
 -->
 
+## Horizontal Checklist
+
+<!-- Cross-cutting concerns across all slices. Check each that was considered.
+     OMIT ENTIRELY for trivial milestones. -->
+
+- [ ] Every active R### re-read against new code — still fully satisfied?
+- [ ] Every D### from prior milestones re-evaluated — still valid at new scope?
+- [ ] Graceful shutdown / cleanup on termination verified
+- [ ] Revenue / billing path impact assessed (or N/A)
+- [ ] Auth boundary documented — what's protected vs public
+- [ ] Shared resource budget confirmed — connection pools, caches, rate limits hold under peak
+- [ ] Reconnection / retry strategy verified for every external dependency
+
 ## Boundary Map
 
 <!-- Be specific. Name concrete outputs: API endpoints, event payloads, shared types/interfaces,

package/dist/resources/extensions/gsd/templates/slice-summary.md

@@ -57,6 +57,15 @@ completed_at: {{date}}
 
 - {{requirementIdOr_none}} — {{what changed}}
 
+## Operational Readiness
+
+<!-- Q8: How will ops know it's healthy/broken? OMIT ENTIRELY for simple slices with no runtime concerns. -->
+
+- **Health signal**: {{howToConfirmHealthy — health endpoint, heartbeat log, metric, or N/A}}
+- **Failure signal**: {{howToDetectBroken — error rate spike, alert, log pattern, or N/A}}
+- **Recovery**: {{selfRecoverOrRestart — auto-reconnect, circuit breaker, manual restart, or N/A}}
+- **Monitoring gaps**: {{silentFailureModes — background jobs, cache eviction, memory pressure, or none}}
+
 ## Deviations
 
 <!-- Deviations are unplanned changes to the written plan, not ordinary debugging inside the plan's intended scope. -->

package/dist/resources/extensions/gsd/templates/task-plan.md

@@ -17,6 +17,30 @@ skills_used:
 
 {{description}}
 
+## Failure Modes
+
+<!-- Q5: What breaks when dependencies fail? OMIT ENTIRELY for tasks with no external dependencies. -->
+
+| Dependency | On error | On timeout | On malformed response |
+|------------|----------|-----------|----------------------|
+| {{dependency}} | {{errorStrategy}} | {{timeoutStrategy}} | {{malformedStrategy}} |
+
+## Load Profile
+
+<!-- Q6: What breaks at 10x load? OMIT ENTIRELY for tasks with no shared resources or scaling concerns. -->
+
+- **Shared resources**: {{sharedResources — DB connections, caches, rate limiters, or none}}
+- **Per-operation cost**: {{perOpCost — N API calls, M DB queries, K bytes, or trivial}}
+- **10x breakpoint**: {{whatBreaksFirst — pool exhaustion, rate limit, memory, or N/A}}
+
+## Negative Tests
+
+<!-- Q7: What negative tests prove robustness? OMIT ENTIRELY for trivial tasks. -->
+
+- **Malformed inputs**: {{malformedInputTests — empty string, null, oversized, wrong type}}
+- **Error paths**: {{errorPathTests — network timeout, auth failure, 5xx, invalid JSON}}
+- **Boundary conditions**: {{boundaryTests — empty list, max length, zero, off-by-one}}
+
 ## Steps
 
 1. {{step}}

package/dist/resources/extensions/gsd/tests/dist-redirect.mjs

@@ -7,17 +7,28 @@ const require = createRequire(import.meta.url);
 const ROOT = new URL("../../../../../", import.meta.url);
 
 export function resolve(specifier, context, nextResolve) {
-  // 1. Direct redirects to dist/ for specific packages
+  // 1. Redirect all workspace package bare imports to source.
+  //    CI portability runs don't build any packages/ dist artifacts, so every
+  //    @gsd/* specifier (including transitive ones pulled in by pi-coding-agent
+  //    source itself) must resolve to the TypeScript source entrypoint.
   if (specifier === "../../packages/pi-coding-agent/src/index.js") {
-    specifier = new URL("packages/pi-coding-agent/dist/index.js", ROOT).href;
+    specifier = new URL("packages/pi-coding-agent/src/index.ts", ROOT).href;
+  } else if (specifier === "@gsd/pi-coding-agent") {
+    specifier = new URL("packages/pi-coding-agent/src/index.ts", ROOT).href;
   } else if (specifier === "@gsd/pi-ai/oauth") {
-    specifier = new URL("packages/pi-ai/dist/utils/oauth/index.js", ROOT).href;
+    specifier = new URL("packages/pi-ai/src/utils/oauth/index.ts", ROOT).href;
   } else if (specifier === "@gsd/pi-ai") {
-    specifier = new URL("packages/pi-ai/dist/index.js", ROOT).href;
+    specifier = new URL("packages/pi-ai/src/index.ts", ROOT).href;
   } else if (specifier === "@gsd/pi-agent-core") {
-    specifier = new URL("packages/pi-agent-core/dist/index.js", ROOT).href;
+    specifier = new URL("packages/pi-agent-core/src/index.ts", ROOT).href;
   } else if (specifier === "@gsd/pi-tui") {
-    specifier = new URL("packages/pi-tui/dist/index.js", ROOT).href;
+    specifier = new URL("packages/pi-tui/src/index.ts", ROOT).href;
+  } else if (specifier === "@gsd/native") {
+    specifier = new URL("packages/native/src/index.ts", ROOT).href;
+  } else if (specifier.startsWith("@gsd/native/")) {
+    // Sub-path imports like @gsd/native/fd, @gsd/native/text, etc.
+    const subpath = specifier.slice("@gsd/native/".length);
+    specifier = new URL(`packages/native/src/${subpath}/index.ts`, ROOT).href;
   }
   // 2. Redirect packages/*/dist/ → packages/*/src/ with .js→.ts for strip-types
   //    Also handles local imports — skip rewrite for dist/ paths that are real compiled artifacts.
@@ -54,9 +65,15 @@ export function resolve(specifier, context, nextResolve) {
 }
 
 export function load(url, context, nextLoad) {
-  // Node's --experimental-strip-types handles .ts but not .tsx (which may contain JSX).
-  // Use TypeScript to transpile .tsx → JS with react-jsx transform, then serve as module.
-  if (url.endsWith('.tsx')) {
+  // Node's --experimental-strip-types handles plain .ts but not .tsx and not
+  // all TypeScript syntax used by workspace packages (parameter properties,
+  // decorators, etc.). Transpile all workspace package source files and .tsx
+  // files through TypeScript's transpileModule to avoid those crashes.
+  const shouldTranspileWithTypeScript =
+    url.endsWith('.tsx') ||
+    (url.endsWith('.ts') && url.includes('/packages/') && url.includes('/src/'));
+
+  if (shouldTranspileWithTypeScript) {
     const ts = require('typescript');
     const source = readFileSync(fileURLToPath(url), 'utf-8');
     const { outputText } = ts.transpileModule(source, {
@@ -66,6 +83,8 @@ export function load(url, context, nextLoad) {
         module: ts.ModuleKind.ESNext,
         target: ts.ScriptTarget.ESNext,
         esModuleInterop: true,
+        experimentalDecorators: true,
+        emitDecoratorMetadata: true,
       },
     });
     return { format: 'module', source: outputText, shortCircuit: true };

package/dist/resources/extensions/gsd/tools/plan-slice.js

@@ -1,5 +1,5 @@
 import { clearParseCache } from "../files.js";
-import { transaction, getMilestone, getSlice, insertTask, upsertSlicePlanning, upsertTaskPlanning, } from "../gsd-db.js";
+import { transaction, getMilestone, getSlice, insertTask, upsertSlicePlanning, upsertTaskPlanning, insertGateRow, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderPlanFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
@@ -145,6 +145,19 @@ export async function handlePlanSlice(rawParams, basePath) {
                     fullPlanMd: task.fullPlanMd,
                 });
             }
+            // Seed quality gate rows inside the transaction — all-or-nothing with
+            // the plan data so a crash can't leave orphaned gates without tasks.
+            const sliceGates = ["Q3", "Q4"];
+            for (const gid of sliceGates) {
+                insertGateRow({ milestoneId: params.milestoneId, sliceId: params.sliceId, gateId: gid, scope: "slice" });
+            }
+            const taskGates = ["Q5", "Q6", "Q7"];
+            for (const task of params.tasks) {
+                for (const gid of taskGates) {
+                    insertGateRow({ milestoneId: params.milestoneId, sliceId: params.sliceId, gateId: gid, scope: "task", taskId: task.taskId });
+                }
+            }
+            insertGateRow({ milestoneId: params.milestoneId, sliceId: params.sliceId, gateId: "Q8", scope: "slice" });
         });
     }
     catch (err) {

package/dist/resources/extensions/gsd/tools/validate-milestone.js

@@ -9,6 +9,7 @@ import { transaction, _getAdapter, } from "../gsd-db.js";
 import { resolveMilestonePath, clearPathCache } from "../paths.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
+import { VALIDATION_VERDICTS, isValidMilestoneVerdict } from "../verdict-parser.js";
 function renderValidationMarkdown(params) {
     let md = `---
 verdict: ${params.verdict}
@@ -41,9 +42,8 @@ export async function handleValidateMilestone(params, basePath) {
     if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
         return { error: "milestoneId is required and must be a non-empty string" };
     }
-    const validVerdicts = ["pass", "needs-attention", "needs-remediation"];
-    if (!validVerdicts.includes(params.verdict)) {
-        return { error: `verdict must be one of: ${validVerdicts.join(", ")}` };
+    if (!isValidMilestoneVerdict(params.verdict)) {
+        return { error: `verdict must be one of: ${VALIDATION_VERDICTS.join(", ")}` };
     }
     // ── Filesystem render ──────────────────────────────────────────────────
     const validationMd = renderValidationMarkdown(params);

package/dist/resources/extensions/gsd/undo.js

@@ -5,6 +5,7 @@
 import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { nativeRevertCommit, nativeRevertAbort } from "./native-git-bridge.js";
+import { parseUnitId } from "./unit-id.js";
 import { deriveState } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
 import { gsdRoot, resolveTasksDir, resolveSlicePath, resolveTaskFile, buildTaskFileName, buildSliceFileName } from "./paths.js";
@@ -52,11 +53,11 @@ export async function handleUndo(args, ctx, _pi, basePath) {
         return;
     }
     // 1. Delete summary artifact
-    const parts = unitId.split("/");
+    const { milestone, slice, task } = parseUnitId(unitId);
     let summaryRemoved = false;
-    if (parts.length === 3) {
+    if (task !== undefined && slice !== undefined) {
         // Task-level: M001/S01/T01
-        const [mid, sid, tid] = parts;
+        const [mid, sid, tid] = [milestone, slice, task];
         const tasksDir = resolveTasksDir(basePath, mid, sid);
         if (tasksDir) {
             const summaryFile = join(tasksDir, buildTaskFileName(tid, "SUMMARY"));
@@ -66,9 +67,9 @@ export async function handleUndo(args, ctx, _pi, basePath) {
             }
         }
     }
-    else if (parts.length === 2) {
+    else if (slice !== undefined) {
         // Slice-level: M001/S01
-        const [mid, sid] = parts;
+        const [mid, sid] = [milestone, slice];
         const slicePath = resolveSlicePath(basePath, mid, sid);
         if (slicePath) {
             for (const suffix of ["SUMMARY", "COMPLETE"]) {
@@ -82,8 +83,8 @@ export async function handleUndo(args, ctx, _pi, basePath) {
     }
     // 2. Uncheck task in PLAN if execute-task
     let planUpdated = false;
-    if (unitType === "execute-task" && parts.length === 3) {
-        const [mid, sid, tid] = parts;
+    if (unitType === "execute-task" && task !== undefined && slice !== undefined) {
+        const [mid, sid, tid] = [milestone, slice, task];
         planUpdated = uncheckTaskInPlan(basePath, mid, sid, tid);
     }
     // 3. Try to revert git commits from activity log

package/dist/resources/extensions/gsd/unit-runtime.js

@@ -2,6 +2,7 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, unlink
 import { join } from "node:path";
 import { gsdRoot, relSliceFile, relTaskFile, resolveSliceFile, resolveTaskFile, } from "./paths.js";
 import { loadFile, parseTaskPlanMustHaves, countMustHavesMentionedInSummary } from "./files.js";
+import { parseUnitId } from "./unit-id.js";
 function runtimeDir(basePath) {
     return join(gsdRoot(basePath), "runtime", "units");
 }
@@ -75,7 +76,7 @@ export function listUnitRuntimeRecords(basePath) {
     return results;
 }
 export async function inspectExecuteTaskDurability(basePath, unitId) {
-    const [mid, sid, tid] = unitId.split("/");
+    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
     if (!mid || !sid || !tid)
         return null;
     const planAbs = resolveSliceFile(basePath, mid, sid, "PLAN");

package/dist/resources/extensions/gsd/verdict-parser.js

@@ -0,0 +1,84 @@
+/**
+ * Centralized verdict extraction, normalization, and schema validation.
+ *
+ * All verdict-related logic lives here so that normalization rules
+ * (e.g. `passed` → `pass`) are applied consistently across the codebase.
+ */
+import { extractUatType } from "./files.js";
+// ── Verdict extraction ──────────────────────────────────────────────────
+/**
+ * Extract and normalize the `verdict` value from YAML frontmatter.
+ *
+ * Normalization:
+ * - lowercased
+ * - `passed` → `pass`
+ *
+ * Returns `undefined` when frontmatter is absent or has no `verdict` field.
+ */
+export function extractVerdict(content) {
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch)
+        return undefined;
+    const verdictMatch = fmMatch[1].match(/verdict:\s*([\w-]+)/i);
+    if (!verdictMatch)
+        return undefined;
+    let v = verdictMatch[1].toLowerCase();
+    if (v === "passed")
+        v = "pass";
+    return v;
+}
+/**
+ * Returns `true` when the content's frontmatter contains a `verdict` field.
+ */
+export function hasVerdict(content) {
+    return /verdict:\s*[\w-]+/i.test(content);
+}
+// ── UAT verdict schema ──────────────────────────────────────────────────
+/**
+ * Base verdicts that are always acceptable for UAT results.
+ */
+export const UAT_ACCEPTABLE_VERDICTS = ["pass", "passed"];
+/**
+ * UAT types whose results may legitimately produce a `partial` verdict
+ * when all automatable checks pass but human-only checks remain.
+ */
+const PARTIAL_ELIGIBLE_UAT_TYPES = [
+    "mixed",
+    "human-experience",
+    "live-runtime",
+];
+/**
+ * Check whether a verdict is acceptable for a given UAT type.
+ *
+ * `pass` / `passed` are always acceptable. `partial` is acceptable only for
+ * UAT types that include non-automatable human checks.
+ */
+export function isAcceptableUatVerdict(verdict, uatType) {
+    if (UAT_ACCEPTABLE_VERDICTS.includes(verdict))
+        return true;
+    if (verdict === "partial" && uatType && PARTIAL_ELIGIBLE_UAT_TYPES.includes(uatType)) {
+        return true;
+    }
+    return false;
+}
+// ── Milestone validation verdict schema ─────────────────────────────────
+/**
+ * Valid verdicts for the `validate-milestone` tool.
+ */
+export const VALIDATION_VERDICTS = ["pass", "needs-attention", "needs-remediation"];
+/**
+ * Check whether a string is a valid milestone validation verdict.
+ */
+export function isValidMilestoneVerdict(verdict) {
+    return VALIDATION_VERDICTS.includes(verdict);
+}
+// ── UAT type helper ─────────────────────────────────────────────────────
+/**
+ * Extract the UAT type from content, defaulting to `"artifact-driven"`.
+ *
+ * The `"artifact-driven"` fallback is the original default used throughout
+ * the codebase when a UAT file lacks an explicit `## UAT Type` section.
+ */
+export function getUatType(content) {
+    return extractUatType(content) ?? "artifact-driven";
+}

package/dist/resources/extensions/gsd/verification-gate.js

@@ -6,6 +6,7 @@ import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { join, basename } from "node:path";
 import { DEFAULT_COMMAND_TIMEOUT_MS } from "./constants.js";
+import { rewriteCommandWithRtk } from "../shared/rtk.js";
 /** Maximum bytes of stdout/stderr to retain per command (10 KB). */
 const MAX_OUTPUT_BYTES = 10 * 1024;
 /** Truncate a string to maxBytes, appending a marker if truncated. */
@@ -210,10 +211,11 @@ export function runVerificationGate(options) {
     const checks = [];
     for (const command of commands) {
         const start = Date.now();
+        const rewrittenCommand = rewriteCommandWithRtk(command);
         // Pass the command string as an argument to the shell explicitly
         // to avoid Node.js DEP0190 (spawnSync with shell: true and no args).
         const shellBin = process.platform === "win32" ? "cmd" : "sh";
-        const shellArgs = process.platform === "win32" ? ["/c", command] : ["-c", command];
+        const shellArgs = process.platform === "win32" ? ["/c", rewrittenCommand] : ["-c", rewrittenCommand];
         const result = spawnSync(shellBin, shellArgs, {
             cwd: options.cwd,
             stdio: "pipe",

package/dist/resources/extensions/gsd/worktree-resolver.js

@@ -72,6 +72,16 @@ export class WorktreeResolver {
      */
     enterMilestone(milestoneId, ctx) {
         this.validateMilestoneId(milestoneId);
+        // If worktree creation failed earlier this session, skip all future attempts
+        if (this.s.isolationDegraded) {
+            debugLog("WorktreeResolver", {
+                action: "enterMilestone",
+                milestoneId,
+                skipped: true,
+                reason: "isolation-degraded",
+            });
+            return;
+        }
         if (!this.deps.shouldUseWorktreeIsolation()) {
             debugLog("WorktreeResolver", {
                 action: "enterMilestone",
@@ -136,6 +146,9 @@ export class WorktreeResolver {
                 data: { milestoneId, error: msg, fallback: "project-root" },
             });
             ctx.notify(`Auto-worktree creation for ${milestoneId} failed: ${msg}. Continuing in project root.`, "warning");
+            // Degrade isolation for the rest of this session so mergeAndExit
+            // doesn't try to merge a nonexistent worktree branch (#2483)
+            this.s.isolationDegraded = true;
             // Do NOT update s.basePath — stay in project root
         }
     }
@@ -210,6 +223,17 @@ export class WorktreeResolver {
      */
     mergeAndExit(milestoneId, ctx) {
         this.validateMilestoneId(milestoneId);
+        // If worktree creation failed earlier, skip merge — work is on current branch (#2483)
+        if (this.s.isolationDegraded) {
+            debugLog("WorktreeResolver", {
+                action: "mergeAndExit",
+                milestoneId,
+                skipped: true,
+                reason: "isolation-degraded",
+            });
+            ctx.notify(`Skipping worktree merge for ${milestoneId} — isolation was degraded (worktree creation failed earlier). Work is on the current branch.`, "info");
+            return;
+        }
         const mode = this.deps.getIsolationMode();
         debugLog("WorktreeResolver", {
             action: "mergeAndExit",