@opengsd/gsd-pi 1.4.0-dev.5fc22c6f → 1.4.0-dev.c18009cd

package/dist/resources/extensions/gsd/doctor-engine-checks.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
-import { isAbsolute, join, relative } from "node:path";
-import { getAllMilestones, getMilestoneSlices, getSliceTasks, isDbAvailable, isMemoriesFtsAvailable, _getAdapter, } from "./gsd-db.js";
+import { isAbsolute, join, relative, sep } from "node:path";
+import { deleteArtifactByPath, getAllMilestones, getMilestoneSlices, getSliceTasks, isDbAvailable, isMemoriesFtsAvailable, repairTaskCompletionFromSummary, _getAdapter, } from "./gsd-db.js";
 import { MEMORIES_FTS_REBUILT_KEY } from "./db-memory-fts-schema.js";
 import { isAfter, latestExplicitReopenAt } from "./milestone-reopen-events.js";
 import { gsdProjectionRoot, gsdRoot, resolveGsdPathContract, resolveMilestoneFile, resolveSliceFile } from "./paths.js";
@@ -11,7 +11,11 @@ import { readEvents } from "./workflow-events.js";
 import { flushWorkflowProjections } from "./projection-flush.js";
 import { parseRoadmapSlices } from "./roadmap-slices.js";
 import { parsePlan } from "./parsers-legacy.js";
+import { parseSummary } from "./files.js";
 const USER_AUTHORED_ARTIFACT_TYPES = new Set(["CONTEXT", "RESEARCH"]);
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function relativeFile(basePath, filePath) {
     return relative(basePath, filePath).split("\\").join("/");
 }
@@ -28,6 +32,17 @@ function userContentMissingMessage(path, artifactType) {
     const type = normalizedArtifactType(artifactType) || "UNKNOWN";
     return `Artifact \`${path}\` is a user-authored ${type} file recorded in the database but missing from disk. Re-run \`${userContentRecoveryCommand(type)}\` in this milestone to regenerate it.`;
 }
+function artifactPathRelativeToGsd(artifactPath) {
+    const parts = artifactPath.split(/[\\/]+/);
+    const gsdIndex = parts.lastIndexOf(".gsd");
+    if (gsdIndex < 0 || gsdIndex === parts.length - 1)
+        return artifactPath;
+    return parts.slice(gsdIndex + 1).join("/");
+}
+function isPathInside(basePath, candidatePath) {
+    const rel = relative(basePath, candidatePath);
+    return rel === "" || (rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
+}
 function reportCheckboxDbStatusDivergence(issues, basePath, filePath, scope, unitId, status, checkboxDone) {
     const dbDone = isClosedStatus(status);
     if (checkboxDone === dbDone)
@@ -99,12 +114,97 @@ function isClearedByMilestoneShellProjectionFlush(basePath, issue, reRenderedMil
     return issue.file === relativeFile(basePath, roadmapPath);
 }
 function artifactExistsOnDisk(basePath, artifactPath) {
-    if (isAbsolute(artifactPath))
-        return existsSync(artifactPath);
-    return [
-        join(gsdProjectionRoot(basePath), artifactPath),
-        join(gsdRoot(basePath), artifactPath),
-    ].some((candidate) => existsSync(candidate));
+    return resolveArtifactDiskPath(basePath, artifactPath) !== null;
+}
+function resolveArtifactDiskPath(basePath, artifactPath) {
+    const relativeArtifactPath = artifactPathRelativeToGsd(artifactPath);
+    if (isAbsolute(relativeArtifactPath)) {
+        return existsSync(relativeArtifactPath) ? relativeArtifactPath : null;
+    }
+    for (const root of [gsdProjectionRoot(basePath), gsdRoot(basePath)]) {
+        const candidate = join(root, relativeArtifactPath);
+        if (isPathInside(root, candidate) && existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+function taskExistsInPlan(basePath, milestoneId, sliceId, taskId) {
+    const planPath = resolveSliceFile(basePath, milestoneId, sliceId, "PLAN");
+    if (!planPath || !existsSync(planPath))
+        return false;
+    try {
+        return parsePlan(readFileSync(planPath, "utf-8")).tasks.some((task) => task.id === taskId);
+    }
+    catch {
+        return false;
+    }
+}
+function isPassingVerificationResult(value) {
+    const normalized = value.trim().toLowerCase();
+    if (!normalized)
+        return false;
+    if (/\b(fail(?:ed|ing)?|error|blocked|mixed|untested)\b/.test(normalized))
+        return false;
+    if (/\b(?:not|never|no|didn't|did\s+not|cannot|can't|won't|couldn't)\s+(?:\w+\s+){0,3}?(?:pass(?:ed|ing)?|success(?:ful)?|succeeded)\b/.test(normalized)) {
+        return false;
+    }
+    return /\b(pass(?:ed|ing)?|success(?:ful)?|succeeded)\b/.test(normalized) || normalized === "all-pass";
+}
+function readTaskCompletionEvidenceFromSummary(basePath, row) {
+    if (!row.slice_id || !row.task_id)
+        return null;
+    if (!row.task_status && Number(row.task_count) > 0 && !taskExistsInPlan(basePath, row.milestone_id, row.slice_id, row.task_id)) {
+        return null;
+    }
+    const diskPath = resolveArtifactDiskPath(basePath, row.path);
+    if (!diskPath)
+        return null;
+    try {
+        const fullSummaryMd = readFileSync(diskPath, "utf-8");
+        const summary = parseSummary(fullSummaryMd);
+        const fm = summary.frontmatter;
+        if (fm.id !== row.task_id || fm.parent !== row.slice_id || fm.milestone !== row.milestone_id)
+            return null;
+        if (fm.blocker_discovered)
+            return null;
+        if (!isPassingVerificationResult(fm.verification_result))
+            return null;
+        const completedAt = fm.completed_at.trim();
+        if (!completedAt || !Number.isFinite(Date.parse(completedAt)))
+            return null;
+        return {
+            completedAt,
+            verificationResult: fm.verification_result.trim(),
+            title: summary.title.replace(new RegExp(`^${escapeRegExp(row.task_id)}:\\s*`), "").trim(),
+            oneLiner: summary.oneLiner,
+            narrative: summary.whatHappened,
+            duration: fm.duration,
+            blockerDiscovered: fm.blocker_discovered,
+            deviations: summary.deviations,
+            knownIssues: summary.knownLimitations,
+            keyFiles: fm.key_files.filter((file) => file !== "(none)"),
+            keyDecisions: fm.key_decisions.filter((decision) => decision !== "(none)"),
+            fullSummaryMd,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function repairTaskArtifactDbStatusDivergence(basePath, row) {
+    const evidence = readTaskCompletionEvidenceFromSummary(basePath, row);
+    if (!evidence || !row.slice_id || !row.task_id)
+        return false;
+    repairTaskCompletionFromSummary({
+        milestoneId: row.milestone_id,
+        sliceId: row.slice_id,
+        taskId: row.task_id,
+        ...evidence,
+    });
+    return true;
+}
+function artifactDbStatusDivergenceFixable(basePath, row) {
+    return readTaskCompletionEvidenceFromSummary(basePath, row) !== null;
 }
 function artifactUnitId(row) {
     if (!row.milestone_id)
@@ -124,6 +224,38 @@ function artifactScope(row) {
         return "milestone";
     return "project";
 }
+function sameArtifactIdentity(left, right) {
+    return left.artifact_type === right.artifact_type &&
+        left.milestone_id === right.milestone_id &&
+        left.slice_id === right.slice_id &&
+        left.task_id === right.task_id;
+}
+function isMilestonesArtifactPath(artifactPath) {
+    return artifactPathRelativeToGsd(artifactPath).startsWith("milestones/");
+}
+function expectedMilestonesArtifactPath(row) {
+    if (!row.milestone_id)
+        return null;
+    const artifactType = normalizedArtifactType(row.artifact_type);
+    if (!artifactType)
+        return null;
+    if (row.slice_id && row.task_id) {
+        return `milestones/${row.milestone_id}/slices/${row.slice_id}/tasks/${row.task_id}-${artifactType}.md`;
+    }
+    if (row.slice_id) {
+        return `milestones/${row.milestone_id}/slices/${row.slice_id}/${row.slice_id}-${artifactType}.md`;
+    }
+    return `milestones/${row.milestone_id}/${row.milestone_id}-${artifactType}.md`;
+}
+function hasPresentMilestonesReplacement(basePath, row, artifactRows) {
+    const expectedPath = expectedMilestonesArtifactPath(row);
+    if (expectedPath && artifactExistsOnDisk(basePath, expectedPath))
+        return true;
+    return artifactRows.some((other) => other.path !== row.path &&
+        isMilestonesArtifactPath(other.path) &&
+        sameArtifactIdentity(row, other) &&
+        artifactExistsOnDisk(basePath, other.path));
+}
 export async function checkEngineHealth(basePath, issues, fixesApplied, options) {
     const dbPath = resolveGsdPathContract(basePath).projectDb;
     if (!isDbAvailable() && existsSync(dbPath)) {
@@ -327,16 +459,25 @@ export async function checkEngineHealth(basePath, issues, fixesApplied, options)
                     if (artifactExistsOnDisk(basePath, row.path))
                         continue;
                     const unitId = artifactUnitId(row);
+                    const issuePath = artifactPathRelativeToGsd(row.path);
+                    if (options?.repair && issuePath.startsWith("phases/") && hasPresentMilestonesReplacement(basePath, row, artifactRows)) {
+                        // Route the write through the Single Writer owner (gsd-db.ts) instead
+                        // of issuing raw DELETE SQL here — doctor is a read-only consumer and
+                        // the single-writer invariant forbids write SQL outside the allowlist.
+                        deleteArtifactByPath(row.path);
+                        fixesApplied.push(`pruned stale flat-phase artifact row ${row.path}`);
+                        continue;
+                    }
                     if (isUserAuthoredArtifactType(row.artifact_type)) {
                         const artifactType = normalizedArtifactType(row.artifact_type);
-                        missingUserContentArtifacts.push({ path: row.path, artifactType });
+                        missingUserContentArtifacts.push({ path: issuePath, artifactType });
                         issues.push({
                             severity: "warning",
                             code: "artifact_user_content_missing",
                             scope: artifactScope(row),
                             unitId,
-                            message: userContentMissingMessage(row.path, artifactType),
-                            file: row.path,
+                            message: userContentMissingMessage(issuePath, artifactType),
+                            file: issuePath,
                             fixable: false,
                         });
                         continue;
@@ -346,9 +487,9 @@ export async function checkEngineHealth(basePath, issues, fixesApplied, options)
                         code: "artifact_file_missing",
                         scope: artifactScope(row),
                         unitId,
-                        message: `Artifact ${row.path} is recorded in the database as ${row.artifact_type || "UNKNOWN"} but no matching file exists on disk`,
-                        file: row.path,
-                        fixable: false,
+                        message: `Artifact ${issuePath} is recorded in the database as ${row.artifact_type || "UNKNOWN"} but no matching file exists on disk`,
+                        file: issuePath,
+                        fixable: issuePath.startsWith("phases/") && hasPresentMilestonesReplacement(basePath, row, artifactRows),
                     });
                 }
             }
@@ -395,13 +536,30 @@ export async function checkEngineHealth(basePath, issues, fixesApplied, options)
                     if (seen.has(unitId))
                         continue;
                     seen.add(unitId);
+                    const fixable = artifactDbStatusDivergenceFixable(basePath, row);
+                    let repairFailed = false;
+                    if (options?.repair && fixable) {
+                        try {
+                            if (repairTaskArtifactDbStatusDivergence(basePath, row)) {
+                                fixesApplied.push(`repaired task completion from SUMMARY artifact for ${unitId}`);
+                                continue;
+                            }
+                        }
+                        catch {
+                            repairFailed = true;
+                        }
+                    }
                     issues.push({
                         severity: "error",
                         code: "artifact_db_status_divergence",
                         scope: row.task_id ? "task" : row.slice_id ? "slice" : "milestone",
                         unitId,
-                        message: `Completion artifact ${row.path} exists while DB state for ${unitId} is still open or missing. Runtime will not import it silently; run explicit recovery/repair after review.`,
-                        fixable: false,
+                        message: repairFailed
+                            ? `Completion artifact ${row.path} exists while DB state for ${unitId} is still open or missing. Doctor found valid SUMMARY completion evidence but could not repair the database state.`
+                            : fixable
+                                ? `Completion artifact ${row.path} exists while DB state for ${unitId} is still open or missing. Doctor can repair this from the SUMMARY completion evidence.`
+                                : `Completion artifact ${row.path} exists while DB state for ${unitId} is still open or missing. Runtime will not import it silently; run explicit recovery/repair after review.`,
+                        fixable,
                     });
                 }
             }

package/dist/resources/extensions/gsd/gsd-db.js

@@ -410,6 +410,58 @@ export function insertTask(t) {
 export function updateTaskStatus(milestoneId, sliceId, taskId, status, completedAt) {
     applyStatusTransition({ entity: "task", milestoneId, sliceId, taskId, status, completedAt });
 }
+export function repairTaskCompletionFromSummary(t) {
+    const db = getDbOrNull();
+    if (!db)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    transaction(() => {
+        const seq = db.prepare(`SELECT COALESCE(MAX(sequence), 0) + 1 AS next_sequence
+       FROM tasks
+       WHERE milestone_id = :mid AND slice_id = :sid`).get({ ":mid": t.milestoneId, ":sid": t.sliceId });
+        db.prepare(`INSERT INTO tasks (
+        milestone_id, slice_id, id, title, status, one_liner, narrative,
+        verification_result, duration, completed_at, blocker_discovered,
+        deviations, known_issues, key_files, key_decisions, full_summary_md,
+        sequence
+      ) VALUES (
+        :milestone_id, :slice_id, :id, :title, 'complete', :one_liner, :narrative,
+        :verification_result, :duration, :completed_at, :blocker_discovered,
+        :deviations, :known_issues, :key_files, :key_decisions, :full_summary_md,
+        :sequence
+      )
+      ON CONFLICT(milestone_id, slice_id, id) DO UPDATE SET
+        title = CASE WHEN NULLIF(:title, '') IS NOT NULL THEN :title ELSE tasks.title END,
+        status = 'complete',
+        one_liner = CASE WHEN NULLIF(:one_liner, '') IS NOT NULL THEN :one_liner ELSE tasks.one_liner END,
+        narrative = CASE WHEN NULLIF(:narrative, '') IS NOT NULL THEN :narrative ELSE tasks.narrative END,
+        verification_result = :verification_result,
+        duration = CASE WHEN NULLIF(:duration, '') IS NOT NULL THEN :duration ELSE tasks.duration END,
+        completed_at = :completed_at,
+        blocker_discovered = :blocker_discovered,
+        deviations = CASE WHEN NULLIF(:deviations, '') IS NOT NULL THEN :deviations ELSE tasks.deviations END,
+        known_issues = CASE WHEN NULLIF(:known_issues, '') IS NOT NULL THEN :known_issues ELSE tasks.known_issues END,
+        key_files = :key_files,
+        key_decisions = :key_decisions,
+        full_summary_md = :full_summary_md`).run({
+            ":milestone_id": t.milestoneId,
+            ":slice_id": t.sliceId,
+            ":id": t.taskId,
+            ":title": t.title ?? "",
+            ":one_liner": t.oneLiner ?? "",
+            ":narrative": t.narrative ?? "",
+            ":verification_result": t.verificationResult,
+            ":duration": t.duration ?? "",
+            ":completed_at": t.completedAt,
+            ":blocker_discovered": t.blockerDiscovered ? 1 : 0,
+            ":deviations": t.deviations ?? "",
+            ":known_issues": t.knownIssues ?? "",
+            ":key_files": JSON.stringify(t.keyFiles ?? []),
+            ":key_decisions": JSON.stringify(t.keyDecisions ?? []),
+            ":full_summary_md": t.fullSummaryMd,
+            ":sequence": seq?.next_sequence ?? 1,
+        });
+    });
+}
 export function setTaskBlockerDiscovered(milestoneId, sliceId, taskId, discovered) {
     if (!getDbOrNull())
         return;

package/dist/resources/extensions/gsd/migrate-external.js

@@ -8,7 +8,7 @@
 import { execFileSync } from "node:child_process";
 import { existsSync, lstatSync, mkdirSync, readdirSync, realpathSync, renameSync, cpSync, rmSync, statSync, symlinkSync } from "node:fs";
 import { join } from "node:path";
-import { externalGsdRoot, isInsideWorktree } from "./repo-identity.js";
+import { externalGsdRoot, externalStateAlreadyExistsForProject, isInsideWorktree } from "./repo-identity.js";
 import { getErrorMessage } from "./error-utils.js";
 import { hasGitTrackedGsdFiles } from "./gitignore.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
@@ -74,6 +74,15 @@ export function migrateToExternalState(basePath) {
             return { migrated: false };
         }
     }
+    // If external state already contains project data, this is not a legacy
+    // migration source. It is likely an already-migrated project whose symlink
+    // was replaced by a real directory, so copying would risk data loss.
+    if (externalStateAlreadyExistsForProject(basePath)) {
+        return {
+            migrated: false,
+            error: "External state already exists for this project; leaving local .gsd directory untouched to avoid overwriting authoritative state",
+        };
+    }
     const externalPath = externalGsdRoot(basePath);
     const migratingPath = join(basePath, ".gsd.migrating");
     try {
@@ -81,13 +90,13 @@ export function migrateToExternalState(basePath) {
         mkdirSync(externalPath, { recursive: true });
         // Rename .gsd -> .gsd.migrating (atomic lock).
         // On Windows, NTFS may reject rename with EPERM if file descriptors are
-        // open (VS Code watchers, antivirus on-access scan). Fall back to
-        // copy+delete (#1292).
+        // open (VS Code watchers, antivirus on-access scan). WSL/DrvFs can report
+        // the same transient lock as EACCES. Fall back to copy+delete (#1292).
         try {
             renameSync(localGsd, migratingPath);
         }
         catch (renameErr) {
-            if (renameErr?.code === "EPERM" || renameErr?.code === "EBUSY") {
+            if (renameErr?.code === "EPERM" || renameErr?.code === "EBUSY" || renameErr?.code === "EACCES") {
                 try {
                     cpSync(localGsd, migratingPath, { recursive: true, force: true });
                     rmSync(localGsd, { recursive: true, force: true });

package/dist/resources/extensions/gsd/milestone-merge-transaction.js

@@ -1,10 +1,10 @@
 // Project/App: gsd-pi
 // File Purpose: Process-level transaction wrapper for milestone merge closeout.
 export function runMilestoneMergeTransaction(deps, input) {
-    return deps.mergeMilestoneToMain(input.basePath, input.milestoneId, input.roadmapContent);
+    return deps.mergeMilestone(input.basePath, input.milestoneId, input.roadmapContent);
 }
-export function createMilestoneMergeTransaction(mergeMilestoneToMain) {
+export function createMilestoneMergeTransaction(mergeMilestone) {
     return function mergeMilestoneTransaction(basePath, milestoneId, roadmapContent) {
-        return runMilestoneMergeTransaction({ mergeMilestoneToMain }, { basePath, milestoneId, roadmapContent });
+        return runMilestoneMergeTransaction({ mergeMilestone }, { basePath, milestoneId, roadmapContent });
     };
 }

package/dist/resources/extensions/gsd/repo-identity.js

@@ -328,6 +328,22 @@ export function externalProjectsRoot() {
     const base = process.env.GSD_STATE_DIR || gsdHome();
     return join(base, "projects");
 }
+/**
+ * Check whether this project already has authoritative external state.
+ *
+ * Used by legacy `.gsd/` migration to avoid re-copying a re-materialized local
+ * directory over newer state when an already-migrated symlink was replaced.
+ */
+export function externalStateAlreadyExistsForProject(basePath) {
+    const base = process.env.GSD_STATE_DIR || gsdHome();
+    const computedPath = join(base, "projects", repoIdentity(basePath));
+    if (hasProjectState(computedPath))
+        return true;
+    const markerId = readGsdIdMarker(resolveGitRoot(basePath));
+    if (!markerId)
+        return false;
+    return hasProjectState(join(base, "projects", markerId));
+}
 // ─── Numbered Variant Cleanup ────────────────────────────────────────────────
 /**
  * macOS collision pattern: `.gsd 2`, `.gsd 3`, `.gsd 4`, etc.

package/dist/resources/extensions/gsd/root-write-leak-guard.js

@@ -42,12 +42,14 @@ export function captureRootDirtySnapshot(rootPath) {
         if (!line.trim())
             continue;
         const code = line.slice(0, 2);
+        if (code !== "??")
+            continue;
         const path = line.slice(3).replace(/^"|"$/g, "");
         if (!path || isRootRuntimePath(path))
             continue;
         snapshot.set(path, {
             path,
-            status: code.trim() || code,
+            status: code,
             fingerprint: fileFingerprint(rootPath, path),
         });
     }
@@ -58,7 +60,7 @@ export function detectRootWriteLeak(input) {
     const leaked = [];
     for (const entry of after.values()) {
         const prior = input.before?.get(entry.path);
-        if (!prior || prior.status !== entry.status || prior.fingerprint !== entry.fingerprint) {
+        if (!prior || prior.fingerprint !== entry.fingerprint) {
             leaked.push(entry);
         }
     }

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

@@ -20,8 +20,9 @@
 //
 // Not yet declared here (remaining ADR-033 steps): the manifest data
 // (`UNIT_MANIFESTS` stays in unit-context-manifest.ts, already type-enforced
-// against the registry's `UnitType`) and prompt-template association (still
-// implicit in auto-prompts.ts builders).
+// against the registry's `UnitType`). Prompt-template association is declared
+// for direct one-template units; conditional/composite prompt selection stays
+// with the prompt builders until it has a richer registry shape.
 import { BROWSER_CONTRACT_TOOL_NAMES } from "../shared/browser-contract.js";
 // ─── Shared tool-name constants (used by registry rows) ──────────────────
 export const RUN_UAT_WORKFLOW_TOOL_NAMES = [
@@ -50,6 +51,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["research"],
+        promptTemplate: "research-milestone",
         toolContract: {
             allowedGsdTools: [
                 "gsd_summary_save",
@@ -65,6 +67,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["planning"],
+        promptTemplate: "plan-milestone",
         toolContract: {
             allowedGsdTools: [
                 "gsd_milestone_status",
@@ -113,6 +116,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "section-close",
         phaseChain: ["validation", "planning"],
+        promptTemplate: "validate-milestone",
         toolContract: {
             allowedGsdTools: [
                 "gsd_milestone_status",
@@ -130,6 +134,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["completion"],
+        promptTemplate: "complete-milestone",
         toolContract: {
             allowedGsdTools: [
                 "gsd_milestone_status",
@@ -153,6 +158,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["research"],
+        promptTemplate: "research-slice",
         toolContract: {
             allowedGsdTools: [
                 "gsd_milestone_status",
@@ -169,6 +175,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["planning"],
+        promptTemplate: "plan-slice",
         toolContract: {
             allowedGsdTools: [
                 "gsd_milestone_status",
@@ -187,6 +194,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["planning"],
+        promptTemplate: "refine-slice",
         toolContract: {
             allowedGsdTools: [
                 "gsd_milestone_status",
@@ -203,6 +211,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["planning"],
+        promptTemplate: "replan-slice",
         toolContract: {
             allowedGsdTools: ["gsd_replan_slice", "gsd_decision_save"],
             requiredWorkflowTools: ["gsd_replan_slice"],
@@ -212,6 +221,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "section-close",
         phaseChain: ["completion"],
+        promptTemplate: "complete-slice",
         toolContract: {
             allowedGsdTools: [
                 "gsd_milestone_status",
@@ -246,6 +256,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["validation", "planning"],
+        promptTemplate: "reassess-roadmap",
         toolContract: {
             allowedGsdTools: ["gsd_milestone_status", "gsd_reassess_roadmap"],
             requiredWorkflowTools: ["gsd_milestone_status", "gsd_reassess_roadmap"],
@@ -255,6 +266,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "execute-task",
         phaseChain: ["execution"],
+        promptTemplate: "execute-task",
         toolContract: {
             allowedGsdTools: [
                 "gsd_task_complete",
@@ -299,6 +311,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "execute-task",
         phaseChain: ["execution"],
+        promptTemplate: "reactive-execute",
         toolContract: {
             allowedGsdTools: [
                 "gsd_milestone_status",
@@ -314,6 +327,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["uat", "completion"],
+        promptTemplate: "run-uat",
         toolContract: {
             allowedGsdTools: [...RUN_UAT_WORKFLOW_TOOL_NAMES, "subagent"],
             requiredWorkflowTools: [...RUN_UAT_WORKFLOW_TOOL_NAMES],
@@ -328,6 +342,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["validation", "planning"],
+        promptTemplate: "gate-evaluate",
         toolContract: {
             allowedGsdTools: ["gsd_save_gate_result"],
             requiredWorkflowTools: ["gsd_save_gate_result"],
@@ -337,6 +352,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["validation", "planning"],
+        promptTemplate: "rewrite-docs",
         toolContract: {
             allowedGsdTools: ["gsd_summary_save", "gsd_decision_save"],
             requiredWorkflowTools: [],
@@ -361,6 +377,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["discuss", "planning"],
+        promptTemplate: "guided-workflow-preferences",
         toolContract: {
             allowedGsdTools: ["gsd_summary_save"],
             requiredWorkflowTools: [],
@@ -370,6 +387,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["discuss", "planning"],
+        promptTemplate: "guided-discuss-project",
         toolContract: {
             allowedGsdTools: ["gsd_summary_save", "gsd_decision_save", "gsd_requirement_save"],
             requiredWorkflowTools: ["ask_user_questions", "gsd_summary_save"],
@@ -379,6 +397,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["discuss", "planning"],
+        promptTemplate: "guided-discuss-requirements",
         toolContract: {
             allowedGsdTools: ["gsd_requirement_save", "gsd_summary_save"],
             requiredWorkflowTools: ["ask_user_questions", "gsd_requirement_save", "gsd_summary_save"],
@@ -388,6 +407,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["discuss", "planning"],
+        promptTemplate: "guided-research-decision",
         toolContract: {
             allowedGsdTools: ["gsd_summary_save"],
             requiredWorkflowTools: ["ask_user_questions"],
@@ -400,6 +420,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["research"],
+        promptTemplate: "guided-research-project",
         toolContract: {
             allowedGsdTools: [],
             requiredWorkflowTools: [],
@@ -419,3 +440,7 @@ export function getUnitDescriptor(unitType) {
 export function getUnitPhaseChain(unitType) {
     return getUnitDescriptor(unitType)?.phaseChain ?? null;
 }
+/** Prompt template id for units with a direct one-template builder. */
+export function getUnitPromptTemplate(unitType) {
+    return getUnitDescriptor(unitType)?.promptTemplate;
+}