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

package/dist/resources/extensions/gsd/key-manager.js

@@ -19,6 +19,7 @@ export const PROVIDER_REGISTRY = [
     // must be in the canonical registry so all consumers see the same catalog.
     // See: https://github.com/open-gsd/gsd-pi/issues/4541
     { id: "claude-code", label: "Claude Code CLI", category: "llm", authMode: "externalCli" },
+    { id: "cursor-agent", label: "Cursor Agent", category: "llm", envVar: "CURSOR_API_KEY", authMode: "externalCli" },
     { id: "openai", label: "OpenAI", category: "llm", envVar: "OPENAI_API_KEY", prefixes: ["sk-"], dashboardUrl: "platform.openai.com/api-keys" },
     { id: "github-copilot", label: "GitHub Copilot", category: "llm", envVar: "GITHUB_TOKEN", authMode: "browserOAuth" },
     { id: "openai-codex", label: "ChatGPT Plus/Pro (Codex)", category: "llm", authMode: "browserOAuth" },

package/dist/resources/extensions/gsd/markdown-renderer.js

@@ -12,7 +12,7 @@ import { readFileSync, existsSync, mkdirSync, statSync, unlinkSync } from "node:
 import { logWarning } from "./workflow-logger.js";
 import { isClosedStatus } from "./status-guards.js";
 import { dirname, join, relative } from "node:path";
-import { getAllMilestones, getMilestone, getMilestoneScopedArtifacts, getSliceScopedArtifacts, getMilestoneSlices, getSliceTasks, getTask, getSlice, insertArtifact, deleteArtifactByPath, getGateResults, isDbAvailable, } from "./gsd-db.js";
+import { getAllMilestones, getMilestone, getMilestoneScopedArtifacts, getSliceScopedArtifacts, getMilestoneSlices, getSliceTasks, getTasksBySliceIds, getTask, getSlice, insertArtifact, deleteArtifactByPath, getGateResults, isDbAvailable, } from "./gsd-db.js";
 import { resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTasksDir, gsdProjectionRoot, gsdRoot, buildMilestoneFileName, buildTaskFileName, } from "./paths.js";
 import { saveFile, clearParseCache, registerCacheClearCallback } from "./files.js";
 import { parseRoadmap, parsePlan } from "./parsers-legacy.js";
@@ -99,6 +99,12 @@ function meaningfulSection(value) {
         return "";
     return trimmed;
 }
+function renderGateFindings(gate) {
+    const findings = gate.findings.trim() || `- **Verdict:** ${gate.verdict}\n- **Rationale:** ${gate.rationale}`;
+    if (gate.verdict !== "flag")
+        return findings;
+    return `> **Warning:** Verdict: flag - concerns recorded below\n\n${findings}`;
+}
 function pushIndented(lines, value, indent = "  ") {
     for (const line of value.split("\n")) {
         lines.push(`${indent}${line}`);
@@ -289,7 +295,7 @@ function renderTaskPlanMarkdown(task, taskGates = []) {
         if (gate && gate.verdict !== "omitted") {
             lines.push(`## ${label}`);
             lines.push("");
-            lines.push(gate.findings.trim() || `- **Verdict:** ${gate.verdict}\n- **Rationale:** ${gate.rationale}`);
+            lines.push(renderGateFindings(gate));
             lines.push("");
         }
     }
@@ -319,14 +325,14 @@ function renderSlicePlanMarkdown(slice, tasks, gates = []) {
     if (q3 && q3.verdict !== "omitted") {
         lines.push("## Threat Surface");
         lines.push("");
-        lines.push(q3.findings.trim() || `- **Verdict:** ${q3.verdict}\n- **Rationale:** ${q3.rationale}`);
+        lines.push(renderGateFindings(q3));
         lines.push("");
     }
     const q4 = gates.find(g => g.gate_id === "Q4" && g.status === "complete");
     if (q4 && q4.verdict !== "omitted") {
         lines.push("## Requirement Impact");
         lines.push("");
-        lines.push(q4.findings.trim() || `- **Verdict:** ${q4.verdict}\n- **Rationale:** ${q4.rationale}`);
+        lines.push(renderGateFindings(q4));
         lines.push("");
     }
     const proofLevel = meaningfulSection(slice.proof_level);
@@ -701,6 +707,17 @@ export async function renderSliceSummary(basePath, milestoneId, sliceId) {
 export async function renderAllFromDb(basePath) {
     const result = { rendered: 0, skipped: 0, errors: [] };
     const milestones = getAllMilestones();
+    // Pre-fetch slices once per milestone and batch-load all tasks in one query
+    // family, avoiding an N+1 (previously one task query per slice).
+    const slicesByMilestone = new Map();
+    const slicePairs = [];
+    for (const milestone of milestones) {
+        const slices = getMilestoneSlices(milestone.id);
+        slicesByMilestone.set(milestone.id, slices);
+        for (const slice of slices)
+            slicePairs.push({ milestoneId: milestone.id, sliceId: slice.id });
+    }
+    const tasksBySlice = getTasksBySliceIds(slicePairs);
     for (const milestone of milestones) {
         // Render roadmap checkboxes
         try {
@@ -723,8 +740,8 @@ export async function renderAllFromDb(basePath) {
         catch (err) {
             result.errors.push(`milestone artifacts ${milestone.id}: ${err.message}`);
         }
-        // Iterate slices
-        const slices = getMilestoneSlices(milestone.id);
+        // Iterate slices (pre-fetched above)
+        const slices = slicesByMilestone.get(milestone.id) ?? [];
         for (const slice of slices) {
             // Preserve slice-scoped artifacts imported from disk, including real PLAN
             // fallback content when task rows cannot regenerate it.
@@ -760,8 +777,8 @@ export async function renderAllFromDb(basePath) {
             catch (err) {
                 result.errors.push(`slice summary ${milestone.id}/${slice.id}: ${err.message}`);
             }
-            // Iterate tasks
-            const tasks = getSliceTasks(milestone.id, slice.id);
+            // Iterate tasks (batched above)
+            const tasks = tasksBySlice.get(`${milestone.id}\0${slice.id}`) ?? [];
             for (const task of tasks) {
                 try {
                     const ok = await renderTaskSummary(basePath, milestone.id, slice.id, task.id);
@@ -1028,9 +1045,21 @@ export async function renderReplanFromDb(basePath, milestoneId, sliceId, replanD
     return { replanPath: absPath, content };
 }
 export async function renderAssessmentFromDb(basePath, milestoneId, sliceId, assessmentData) {
-    // Flat-phase: assessment file lives in the phase dir
-    const slicePath = resolveSlicePath(basePath, milestoneId, sliceId)
-        ?? join(milestonesDir(basePath), canonicalPhaseDirName(milestoneId, getMilestone(milestoneId)?.title));
+    // Flat-phase: the assessment file lives in the phase dir, NOT in a slices/SID/
+    // subdir. resolveSlicePath() detects a slices/SID/ dir unconditionally, so a
+    // stray slices/SID/ created by an earlier planning step would send this write
+    // to a hybrid path (wrong dir, flat filename) that verification cannot find.
+    // Guard with the same legacy-base check relSlicePath() uses so flat-phase
+    // milestones always target the phase dir.
+    const mDir = resolveMilestonePath(basePath, milestoneId);
+    const legacyBase = legacyMilestonesDir(basePath);
+    const isLegacyLayout = mDir
+        ? mDir.startsWith(legacyBase + "/") || mDir.startsWith(legacyBase + "\\")
+        : false;
+    const fallbackDir = join(milestonesDir(basePath), canonicalPhaseDirName(milestoneId, getMilestone(milestoneId)?.title));
+    const slicePath = isLegacyLayout
+        ? (resolveSlicePath(basePath, milestoneId, sliceId) ?? fallbackDir)
+        : (mDir ?? fallbackDir);
     const phaseNum = milestoneIdToPhaseNum(milestoneId);
     const planNum = sliceIdToPlanNum(sliceId);
     const absPath = join(slicePath, planFileName(phaseNum, planNum, "ASSESSMENT"));

package/dist/resources/extensions/gsd/md-importer.js

@@ -4,14 +4,14 @@
 //
 // Exports: parseDecisionsTable, parseRequirementsSections, migrateFromMarkdown
 import { readFileSync, readdirSync, existsSync, statSync } from 'node:fs';
-import { join, basename } from 'node:path';
+import { join, basename, dirname } from 'node:path';
 import { upsertDecision, upsertRequirement, insertArtifact, insertMilestone, insertSlice, insertTask, transaction, updateMilestoneStatus, updateSliceStatus, _getAdapter, } from './gsd-db.js';
 import { openWorkflowDatabasePath } from './db-workspace.js';
-import { resolveGsdRootFile, resolveMilestoneFile, resolveSliceFile, resolveTasksDir, legacyMilestonesDir, gsdRoot, resolveTaskFiles, resolveMilestonePath, } from './paths.js';
+import { resolveGsdRootFile, resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, legacyMilestonesDir, gsdRoot, resolveTaskFiles, resolveMilestonePath, } from './paths.js';
 import { findMilestoneIds } from './guided-flow.js';
 import { milestoneIdToPhaseNum } from './layout-policy.js';
 import { parseRoadmap, parsePlan } from './parsers-legacy.js';
-import { parseContextDependsOn } from './files.js';
+import { parseContextDependsOn, parseSummary } from './files.js';
 import { logWarning } from './workflow-logger.js';
 // ─── DECISIONS.md Parser ───────────────────────────────────────────────────
 const VALID_MADE_BY = new Set(['human', 'agent', 'collaborative']);
@@ -662,21 +662,63 @@ export function migrateHierarchyToDb(basePath) {
             for (const taskEntry of plan.tasks) {
                 // Per K002: use 'complete' not 'done'
                 let taskStatus = taskEntry.done ? 'complete' : 'pending';
-                // Pre-migration consistency (legacy layout only): if a task is marked
-                // done but has no per-task SUMMARY.md, import it as pending so it gets
-                // re-executed rather than silently entering the DB as complete.
-                // Flat-phase has no per-task summary files by design — the checkbox
-                // state is the authoritative completion signal and is imported as-is.
-                if (taskStatus === 'complete') {
-                    const tDir = resolveTasksDir(basePath, milestoneId, sliceEntry.id);
-                    if (tDir) {
-                        const summaryFile = join(tDir, `${taskEntry.id}-SUMMARY.md`);
-                        if (!existsSync(summaryFile)) {
-                            taskStatus = 'pending';
-                            process.stderr.write(`gsd-migrate: ${milestoneId}/${sliceEntry.id}/${taskEntry.id} marked done but missing summary — importing as pending\n`);
-                        }
+                // Resolve the per-task SUMMARY.md. Legacy layout keeps summaries under
+                // a tasks/ subdir; flat-phase writes TID-SUMMARY.md directly in the
+                // phase dir (execute-task's gsd_task_complete writes it there). A tasks/
+                // subdir may still exist in flat-phase for auxiliary artifacts — its
+                // mere existence must NOT redirect summary resolution into tasks/ (#1208).
+                const slicePath = resolveSlicePath(basePath, milestoneId, sliceEntry.id);
+                let taskSummaryFile = null;
+                let isLegacySlice = false;
+                // Legacy layout keeps per-task summaries under a tasks/ subdir. Its
+                // presence — not merely "is this a legacy slice" — is what makes a
+                // missing summary a downgrade signal. resolveTasksDir returns null when
+                // no such dir exists, so a legacy slice whose checkbox is the only
+                // completion signal (no tasks/ dir at all) is left complete on import.
+                let legacyTasksDir = null;
+                if (slicePath) {
+                    isLegacySlice = basename(dirname(slicePath)) === 'slices';
+                    legacyTasksDir = isLegacySlice
+                        ? resolveTasksDir(basePath, milestoneId, sliceEntry.id)
+                        : null;
+                    const summaryDir = legacyTasksDir ?? slicePath;
+                    taskSummaryFile = join(summaryDir, `${taskEntry.id}-SUMMARY.md`);
+                }
+                const hasTaskSummary = taskSummaryFile !== null && existsSync(taskSummaryFile);
+                // Pre-migration consistency (legacy tasks/ layout only): if a task is
+                // marked done but its tasks/ dir has no per-task SUMMARY.md, import it
+                // as pending so it gets re-executed rather than silently entering the DB
+                // as complete. A legacy slice with no tasks/ dir (checkbox-only
+                // completion) and flat-phase layout are both left as-is here.
+                if (taskStatus === 'complete' && legacyTasksDir !== null && !hasTaskSummary) {
+                    taskStatus = 'pending';
+                    process.stderr.write(`gsd-migrate: ${milestoneId}/${sliceEntry.id}/${taskEntry.id} marked done but missing summary — importing as pending\n`);
+                }
+                // Lost-update guard (#1222): a per-task SUMMARY.md is the durable
+                // completion attestation written by gsd_task_complete. When the plan
+                // checkbox is stale-unchecked but the SUMMARY exists on disk, a
+                // re-import must NOT downgrade the completed task back to pending — that
+                // silent revert is the lost-update that hard-stopped auto-mode after the
+                // first execute-task. The surviving SUMMARY wins over a stale checkbox.
+                // reopen-task removes the SUMMARY, so this never re-completes an
+                // intentionally reopened task.
+                // Flat-phase summaries are phase-scoped (T01-SUMMARY.md); when a milestone
+                // has multiple slices, require the summary parent frontmatter to match so
+                // one slice's completion does not attest a sibling's same-named task.
+                let summaryAttestsCompletion = hasTaskSummary;
+                if (summaryAttestsCompletion && !isLegacySlice && roadmap.slices.length > 1 && taskSummaryFile) {
+                    try {
+                        const summaryContent = readFileSync(taskSummaryFile, 'utf-8');
+                        summaryAttestsCompletion = parseSummary(summaryContent).frontmatter.parent === sliceEntry.id;
+                    }
+                    catch {
+                        summaryAttestsCompletion = false;
                     }
                 }
+                if (taskStatus === 'pending' && summaryAttestsCompletion) {
+                    taskStatus = 'complete';
+                    process.stderr.write(`gsd-migrate: ${milestoneId}/${sliceEntry.id}/${taskEntry.id} unchecked in plan but SUMMARY.md present — importing as complete (#1222)\n`);
+                }
                 insertTask({
                     id: taskEntry.id,
                     sliceId: sliceEntry.id,
@@ -687,6 +729,12 @@ export function migrateHierarchyToDb(basePath) {
                         files: taskEntry.files ?? [],
                         verify: taskEntry.verify ?? '',
                     },
+                    // #1222 (metadata half): re-import derives status from the plan/summary
+                    // but has none of the execution prose gsd_task_complete wrote to the DB.
+                    // Preserve the existing row's execution columns and completed_at so a
+                    // re-import cannot blank a completed task's summary metadata or refresh
+                    // its completion timestamp — the DB row is strictly richer than the plan.
+                    preserveCompletionMetadata: true,
                 });
                 counts.tasks++;
             }
@@ -699,14 +747,32 @@ export function migrateHierarchyToDb(basePath) {
             if (!sliceEntry.done) {
                 const sliceSummaryPath = resolveSliceFile(basePath, milestoneId, sliceEntry.id, 'SUMMARY');
                 const hasSliceSummary = sliceSummaryPath !== null && existsSync(sliceSummaryPath);
+                const slicePathForTasks = resolveSlicePath(basePath, milestoneId, sliceEntry.id);
+                const isLegacySliceLayout = slicePathForTasks !== null
+                    && basename(dirname(slicePathForTasks)) === 'slices';
+                const taskSummaryDir = slicePathForTasks
+                    ? (isLegacySliceLayout
+                        ? (resolveTasksDir(basePath, milestoneId, sliceEntry.id) ?? slicePathForTasks)
+                        : slicePathForTasks)
+                    : null;
                 const allTasksDone = plan.tasks.length > 0 && plan.tasks.every(t => {
-                    if (!t.done)
-                        return false;
-                    const tDir = resolveTasksDir(basePath, milestoneId, sliceEntry.id);
-                    // Flat-phase has no per-task summary files — checkbox state is authoritative.
-                    if (!tDir)
-                        return true;
-                    return existsSync(join(tDir, `${t.id}-SUMMARY.md`));
+                    const taskSummaryFile = taskSummaryDir !== null
+                        ? join(taskSummaryDir, `${t.id}-SUMMARY.md`)
+                        : null;
+                    const hasTaskSummary = taskSummaryFile !== null && existsSync(taskSummaryFile);
+                    let summaryAttestsCompletion = hasTaskSummary;
+                    if (summaryAttestsCompletion && !isLegacySliceLayout && roadmap.slices.length > 1 && taskSummaryFile) {
+                        try {
+                            const summaryContent = readFileSync(taskSummaryFile, 'utf-8');
+                            summaryAttestsCompletion = parseSummary(summaryContent).frontmatter.parent === sliceEntry.id;
+                        }
+                        catch {
+                            summaryAttestsCompletion = false;
+                        }
+                    }
+                    // Match per-task import rules above: SUMMARY attestation wins over a stale
+                    // checkbox (#1222); flat-phase checkboxes are authoritative without summary.
+                    return summaryAttestsCompletion || (t.done && !isLegacySliceLayout);
                 });
                 if (allTasksDone && hasSliceSummary) {
                     if (_getAdapter()) {

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 });
@@ -239,7 +248,7 @@ function isLocalGsdExternalStateJunction(basePath, localGsd) {
  * Recover from a failed migration (`.gsd.migrating` exists).
  * Moves `.gsd.migrating` back to `.gsd` if `.gsd` doesn't exist, or removes an
  * orphaned staging directory when `.gsd` is already a verified external state
- * junction with intact current state.
+ * junction, or an intact real directory, with intact current state.
  */
 export function recoverFailedMigration(basePath) {
     const localGsd = join(basePath, ".gsd");
@@ -247,10 +256,18 @@ export function recoverFailedMigration(basePath) {
     if (!existsSync(migratingPath))
         return false;
     if (existsSync(localGsd)) {
-        if (!isLocalGsdExternalStateJunction(basePath, localGsd))
-            return false;
         if (!isCurrentGsdStateIntactForMigratingCleanup(basePath))
             return false;
+        if (!isLocalGsdExternalStateJunction(basePath, localGsd)) {
+            try {
+                const stat = lstatSync(localGsd);
+                if (!stat.isDirectory())
+                    return false;
+            }
+            catch {
+                return false;
+            }
+        }
         try {
             rmSync(migratingPath, { recursive: true, force: true });
             return true;

package/dist/resources/extensions/gsd/migration-auto-check.js

@@ -56,14 +56,40 @@ function replaceSetPrefix(values, from, to) {
         values.add(`${to}${value.slice(from.length)}`);
     }
 }
+/**
+ * Rewrite one milestone identity across EVERY markdown identity set. The
+ * roadmapless subset is a view of `milestones`, so it must speak the same
+ * aligned vocabulary; otherwise the discussion-phase exclusion below keys off
+ * the stale bare id, fails its `dbScan.milestones.has(...)` membership check,
+ * and decrements the milestone count even though the aligned identity remains
+ * in the set, reporting false drift for a milestone that is actually in sync.
+ * Centralising the set list here keeps every alignment path from silently
+ * missing a set (the defect that regressed the suffixed roadmapless case).
+ */
+function realignMilestonePrefix(markdownScan, from, to) {
+    replaceSetPrefix(markdownScan.milestones, from, to);
+    replaceSetPrefix(markdownScan.slices, from, to);
+    replaceSetPrefix(markdownScan.tasks, from, to);
+    replaceSetPrefix(markdownScan.milestonesWithoutRoadmap, from, to);
+}
 function alignNumericMarkdownIdsWithDb(markdownScan, dbScan) {
     for (const dbId of dbScan.milestones) {
         const paddedId = paddedMilestoneId(dbId);
         if (!paddedId || dbScan.milestones.has(paddedId) || !markdownScan.milestones.has(paddedId))
             continue;
-        replaceSetPrefix(markdownScan.milestones, paddedId, dbId);
-        replaceSetPrefix(markdownScan.slices, paddedId, dbId);
-        replaceSetPrefix(markdownScan.tasks, paddedId, dbId);
+        realignMilestonePrefix(markdownScan, paddedId, dbId);
+    }
+}
+function bareMilestoneId(id) {
+    const match = id.match(/^(M\d{3})-[a-z0-9]{6}$/);
+    return match?.[1] ?? null;
+}
+function alignBareMarkdownIdsWithSuffixedDb(markdownScan, dbScan) {
+    for (const dbId of dbScan.milestones) {
+        const bareId = bareMilestoneId(dbId);
+        if (!bareId || dbScan.milestones.has(bareId) || !markdownScan.milestones.has(bareId))
+            continue;
+        realignMilestonePrefix(markdownScan, bareId, dbId);
     }
 }
 /**
@@ -148,6 +174,7 @@ export async function checkMarkdownHierarchyAgainstDb(basePath) {
     const dbScan = scanDbHierarchy();
     const beforeDb = dbScan.counts;
     alignNumericMarkdownIdsWithDb(markdownScan, dbScan);
+    alignBareMarkdownIdsWithSuffixedDb(markdownScan, dbScan);
     // Discussion-phase scratch: a milestone dir with no ROADMAP and no DB row is
     // a pre-registration discussion artifact (CONTEXT/CONTEXT-DRAFT only — the
     // queued DB row is inserted only at discussion handoff). Treating it as

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

@@ -1,10 +1,21 @@
 // Project/App: gsd-pi
 // File Purpose: Process-level transaction wrapper for milestone merge closeout.
+import { mergeMilestoneToMain } from "./auto-worktree-merge.js";
 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 });
     };
 }
+/**
+ * Production merge transaction adapter.
+ *
+ * This is the only production construction point that knows the legacy
+ * `auto-worktree.ts` merge primitive. Lifecycle callers depend on the
+ * transaction runner interface, not the legacy implementation module.
+ */
+export function createDefaultMilestoneMergeTransaction(mergeMilestone = mergeMilestoneToMain) {
+    return createMilestoneMergeTransaction(mergeMilestone);
+}

package/dist/resources/extensions/gsd/milestone-settlement.js

@@ -1,6 +1,6 @@
 // Project/App: gsd-pi
 // File Purpose: Milestone closeout settlement state across DB proof, artifacts, merge, and cleanup.
-import { isInAutoWorktree } from "./auto-worktree.js";
+import { isInAutoWorktree } from "./auto-worktree-entry.js";
 import { formatCloseoutProofBlock, proveMilestoneCloseout, } from "./milestone-closeout-proof.js";
 import { resolveCloseoutArtifactProjection } from "./artifact-projection.js";
 function isActiveUnmergedWorktree(input) {

package/dist/resources/extensions/gsd/parallel-merge.js

@@ -8,7 +8,7 @@ import { existsSync, readdirSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { resolveGsdPathContract } from "./paths.js";
 import { worktreePathFor, worktreesDirs } from "./worktree-placement.js";
-import { getAutoWorktreePath } from "./auto-worktree.js";
+import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
 import { buildWorktreeLifecycleDeps } from "./auto.js";
 import { mergeMilestoneStandalone, } from "./worktree-lifecycle.js";
 import { MergeConflictError } from "./git-service.js";

package/dist/resources/extensions/gsd/parallel-orchestrator.js

@@ -12,7 +12,9 @@ import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { gsdRoot } from "./paths.js";
 import { createWorktree, worktreePath } from "./worktree-manager.js";
-import { autoWorktreeBranch, fastForwardReusedMilestoneBranchIfSafe, runWorktreePostCreateHook, syncGsdStateToWorktreeByScope } from "./auto-worktree.js";
+import { autoWorktreeBranch, fastForwardReusedMilestoneBranchIfSafe } from "./auto-worktree-branch-lifecycle.js";
+import { syncGsdStateToWorktreeByScope } from "./auto-worktree-sync.js";
+import { runWorktreePostCreateHook } from "./worktree-post-create-hook.js";
 import { nativeBranchExists } from "./native-git-bridge.js";
 import { readIntegrationBranch } from "./git-service.js";
 import { createWorkspace, scopeMilestone } from "./workspace.js";

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

@@ -669,7 +669,10 @@ function pickPreferredPhaseDir(phasesDir, matches) {
     }
     return best;
 }
-function phaseDirMatchesMilestoneId(dirName, milestoneId, phaseNum) {
+function slugLooksLikeTeamSuffixProjection(slugPart) {
+    return /^[a-z0-9]{6}(-|$)/.test(slugPart);
+}
+function phaseDirMatchesMilestoneId(dirName, milestoneId, phaseNum, allowTeamSuffixSlugs = false) {
     const numMatch = dirName.match(/^(\d+)-(.*)$/);
     if (!numMatch || parseInt(numMatch[1], 10) !== phaseNum)
         return false;
@@ -678,8 +681,9 @@ function phaseDirMatchesMilestoneId(dirName, milestoneId, phaseNum) {
     if (suffix) {
         return slugPart === suffix || slugPart.startsWith(`${suffix}-`);
     }
-    // Plain sequential IDs must not resolve to unique-suffix phase dirs.
-    return !/^[a-z0-9]{6}(-|$)/.test(slugPart);
+    if (slugLooksLikeTeamSuffixProjection(slugPart) && !allowTeamSuffixSlugs)
+        return false;
+    return true;
 }
 function resolvePhaseDir(basePath, milestoneId) {
     // Try flat-phase layout first: phases/NN-slug/ (always scan phases/, even when
@@ -700,6 +704,16 @@ function resolvePhaseDir(basePath, milestoneId) {
                     matches.push(entry.name);
                 }
             }
+            // Bare milestone ids may only have a suffixed team-mode projection on disk.
+            if (matches.length === 0 && !milestoneIdUniqueSuffix(milestoneId)) {
+                for (const entry of readdirSync(phasesDir, { withFileTypes: true })) {
+                    if (!entry.isDirectory())
+                        continue;
+                    if (phaseDirMatchesMilestoneId(entry.name, milestoneId, phaseNum, true)) {
+                        matches.push(entry.name);
+                    }
+                }
+            }
         }
         catch {
             // unreadable — fall through

package/dist/resources/extensions/gsd/preferences-diagnostics.js

@@ -1,4 +1,5 @@
-import { loadGlobalGSDPreferences, loadProjectGSDPreferences, } from "./preferences.js";
+import { loadEffectiveGSDPreferences, loadGlobalGSDPreferences, loadProjectGSDPreferences, } from "./preferences.js";
+import { crossAxisPreferenceWarnings } from "./preferences-validation.js";
 const notifiedPreferenceDiagnostics = new Set();
 export function collectPreferenceDiagnostics(basePath) {
     const diagnostics = [
@@ -14,6 +15,28 @@ export function collectPreferenceDiagnostics(basePath) {
         seen.add(signature);
         unique.push(diagnostic);
     }
+    const effective = loadEffectiveGSDPreferences(basePath);
+    if (effective) {
+        const existingMessages = new Set(unique.map((diagnostic) => diagnostic.message));
+        for (const message of crossAxisPreferenceWarnings(effective.preferences)) {
+            if (existingMessages.has(message))
+                continue;
+            const diagnostic = {
+                path: effective.path,
+                scope: effective.scope,
+                severity: "warning",
+                kind: "validation",
+                message,
+                sanitized: true,
+            };
+            const signature = preferenceDiagnosticSignature(diagnostic);
+            if (seen.has(signature))
+                continue;
+            seen.add(signature);
+            existingMessages.add(message);
+            unique.push(diagnostic);
+        }
+    }
     return unique;
 }
 export function formatPreferenceDiagnostic(diagnostic) {

package/dist/resources/extensions/gsd/preferences-models.js

@@ -74,10 +74,12 @@ function resolveWinningPhase(models, chain) {
  * - Legacy: `planning: claude-opus-4-6`
  * - Extended: `planning: { model: claude-opus-4-6, fallbacks: [glm-5, minimax-m2.5] }`
  */
-export function resolveModelWithFallbacksForUnit(unitType, basePath, availableModelIds, preferredModelId) {
-    const loadOpts = availableModelIds !== undefined || preferredModelId !== undefined
-        ? { availableModelIds, preferredModelId }
-        : undefined;
+export function resolveModelWithFallbacksForUnit(unitType, basePath, availableModelIds, preferredModelId, skipProfileDefaults = false) {
+    const loadOpts = {
+        ...(availableModelIds !== undefined ? { availableModelIds } : {}),
+        ...(preferredModelId !== undefined ? { preferredModelId } : {}),
+        ...(skipProfileDefaults ? { skipProfileDefaults: true } : {}),
+    };
     const prefs = loadEffectiveGSDPreferences(basePath, loadOpts);
     const chain = phaseChainForUnit(unitType);
     if (!chain)

package/dist/resources/extensions/gsd/preferences-skills.js

@@ -4,35 +4,29 @@
  * Contains all logic for resolving skill references from preferences
  * to absolute filesystem paths, plus skill discovery and staleness config.
  */
-import { existsSync, readdirSync } from "node:fs";
+import { existsSync, readdirSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { isAbsolute, join } from "node:path";
+import { getSkillDirectories } from "@gsd/pi-coding-agent";
 import { gsdHome } from "./gsd-home.js";
-import { statSync } from "node:fs";
 import { validatePreferences } from "./preferences-validation.js";
 /**
  * Known skill directories for **preference reference resolution** (bare skill names).
  *
- * Search order (first match wins):
- * 1. ~/.gsd/agent/skills/ (GSD bundled)
- * 2. ~/.agents/skills/ (ecosystem global)
- * 3. .agents/skills/ (project ecosystem)
- * 4. ~/.claude/skills/ and .claude/skills/ (Claude Code compatibility)
+ * Sourced from the shared taxonomy (`@gsd/pi-coding-agent` `getSkillDirectories`)
+ * so preference resolution, mid-session discovery, and the PackageManager
+ * catalog all agree on which directories exist. The `method` is derived from
+ * each entry's scope.
  *
  * Note: the ResourceLoader catalog uses PackageManager precedence instead —
  * project `.gsd/skills` and `.agents/skills` can override bundled GSD skills
  * on name collision. See docs/dev/what-is-pi/09-the-customization-stack.md.
  */
 export function getSkillSearchDirs(cwd) {
-    const dirs = [
-        { dir: join(gsdHome(), "agent", "skills"), method: "user-skill" },
-        { dir: join(homedir(), ".agents", "skills"), method: "user-skill" },
-        { dir: join(cwd, ".agents", "skills"), method: "project-skill" },
-        // Claude Code official skill directories
-        { dir: join(homedir(), ".claude", "skills"), method: "user-skill" },
-        { dir: join(cwd, ".claude", "skills"), method: "project-skill" },
-    ];
-    return dirs;
+    return getSkillDirectories({ cwd, gsdHome: gsdHome() }).map((entry) => ({
+        dir: entry.path,
+        method: entry.scope === "project" ? "project-skill" : "user-skill",
+    }));
 }
 /**
  * Resolve a single skill reference to an absolute path.

package/dist/resources/extensions/gsd/preferences-types.js

@@ -86,6 +86,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "min_request_interval_ms",
     "stale_commit_threshold_minutes",
     "context_management",
+    "tool_call_loop_guard",
     "experimental",
     "codebase",
     "slice_parallel",