@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.c18009cd

package/dist/resources/extensions/gsd/commands-handlers.js

@@ -158,6 +158,65 @@ export function parseDoctorArgs(args) {
 export function isDoctorHealActionable(issue) {
     return issue.fixable && issue.severity !== "info";
 }
+/**
+ * Compat-health line for `/gsd doctor`. Reports the gsd-core compat marker's
+ * presence and the count of projection files whose on-disk sha has drifted
+ * from the recorded baseline. Returns "" if the marker module is unavailable
+ * (defensive — doctor must never fail because of compat reporting).
+ *
+ * Exported for unit testing.
+ */
+export async function formatCompatHealthLine(basePath) {
+    try {
+        const { readCompatMarker, computeProjectionSha } = await import("./compat/compat-marker.js");
+        const marker = readCompatMarker(basePath);
+        const countDrifted = (entries, root) => {
+            let drifted = 0;
+            for (const [rel, entry] of Object.entries(entries)) {
+                const abs = join(basePath, root, rel);
+                if (!existsSync(abs))
+                    continue;
+                if (computeProjectionSha(readFileSync(abs, "utf-8")) !== entry.sha)
+                    drifted++;
+            }
+            return drifted;
+        };
+        const lines = [];
+        const gsdEntryCount = Object.keys(marker.projections).length;
+        const planningActive = marker.planning?.active ?? false;
+        const planningEntryCount = planningActive
+            ? Object.keys(marker.planning.projections).length +
+                Object.keys(marker.planning.passthrough).length
+            : 0;
+        if (gsdEntryCount === 0 && !planningActive) {
+            return "  Compat health:      no baseline (run /gsd sync to establish)";
+        }
+        if (gsdEntryCount === 0) {
+            lines.push("  Compat health (.gsd):    no baseline (run /gsd sync to establish)");
+        }
+        else {
+            const gsdDrifted = countDrifted(marker.projections, ".gsd");
+            lines.push(`  Compat health (.gsd):    ${gsdDrifted === 0 ? "OK" : `${gsdDrifted} file(s) drifted — run /gsd sync`}`);
+        }
+        if (planningActive) {
+            if (planningEntryCount === 0) {
+                lines.push("  Compat health (.planning): no baseline (run /gsd sync to establish)");
+            }
+            else {
+                const planningDrifted = countDrifted(marker.planning.projections, ".planning") +
+                    countDrifted(marker.planning.passthrough, ".planning");
+                lines.push(`  Compat health (.planning): ${planningDrifted === 0 ? "OK" : `${planningDrifted} file(s) drifted — run /gsd sync`}`);
+            }
+        }
+        else {
+            lines.push(`  Compat health (.planning): not active`);
+        }
+        return lines.join("\n");
+    }
+    catch {
+        return "";
+    }
+}
 export async function handleDoctor(args, ctx, pi) {
     const { jsonMode, dryRun, fixFlag, includeBuild, includeTests, mode, requestedScope } = parseDoctorArgs(args);
     const scope = await selectDoctorScope(projectRoot(), requestedScope);
@@ -181,7 +240,12 @@ export async function handleDoctor(args, ctx, pi) {
         maxIssues: mode === "audit" ? 50 : 12,
         title: mode === "audit" ? "GSD doctor audit." : mode === "heal" ? "GSD doctor heal prep." : undefined,
     });
-    ctx.ui.notify(reportText, report.ok ? "info" : "warning");
+    // Compat health: marker presence + drift vs current projections. Appended to
+    // the formatted report so it surfaces in every doctor run without touching
+    // the doctor report internals.
+    const compatLine = await formatCompatHealthLine(projectRoot());
+    const fullReport = compatLine ? `${reportText}\n${compatLine}` : reportText;
+    ctx.ui.notify(fullReport, report.ok ? "info" : "warning");
     if (mode === "heal") {
         const unresolved = filterDoctorIssues(report.issues, {
             scope: effectiveScope,
@@ -362,6 +426,8 @@ export async function handleKnowledge(args, ctx) {
     }
     const type = typeArg;
     const basePath = currentDirectoryRoot();
+    const { ensureDbOpen } = await import("./bootstrap/dynamic-tools.js");
+    await ensureDbOpen(basePath);
     const state = await deriveState(basePath);
     const scope = state.activeMilestone?.id
         ? `${state.activeMilestone.id}${state.activeSlice ? `/${state.activeSlice.id}` : ""}`

package/dist/resources/extensions/gsd/commands-maintenance.js

@@ -699,11 +699,88 @@ export async function rebuildMarkdownProjectionsFromDb(basePath) {
         quarantinedPaths: quarantined,
     };
 }
+/**
+ * `/gsd sync` — pull in external (gsd-core) markdown edits and re-project.
+ *
+ * Non-destructive cousin of `/gsd recover`: does NOT clear the DB. Runs the
+ * ADR-017 reconcile pipeline (which picks up the external-markdown-edit handler
+ * automatically), then re-projects via renderAllFromDb, then refreshes the
+ * compat marker. Use this when switching from gsd-core mid-session.
+ *
+ * Accepts `--dry-run` to report what would change without writing.
+ */
+export async function handleSync(ctx, basePath, args = "") {
+    const { isDbAvailable } = await import("./gsd-db.js");
+    const { reconcileBeforeDispatch } = await import("./state-reconciliation/index.js");
+    const { renderAllFromDb } = await import("./markdown-renderer.js");
+    const { writeCompatMarker, readCompatMarker } = await import("./compat/compat-marker.js");
+    const dryRun = args.trim() === "--dry-run";
+    if (!isDbAvailable()) {
+        ctx.ui.notify("gsd sync: No database open. Run a GSD command first to initialize the DB.", "error");
+        return;
+    }
+    const lines = ["gsd sync: reconciling .gsd/ for cross-tool edits…"];
+    try {
+        const result = await reconcileBeforeDispatch(basePath, { dryRun });
+        const repairedExternal = result.repaired.filter((r) => r.kind === "external-markdown-edit");
+        lines.push(`  External .gsd/ edits ${dryRun ? "to import" : "imported"}: ${repairedExternal.length}`);
+        for (const r of repairedExternal) {
+            const e = r;
+            lines.push(`    • ${e.projectionPath}`);
+        }
+        const repairedPlanningExternal = result.repaired.filter((r) => r.kind === "external-planning-edit");
+        if (repairedPlanningExternal.length > 0) {
+            lines.push(`  External .planning/ edits ${dryRun ? "to import" : "imported"}: ${repairedPlanningExternal.length}`);
+            for (const r of repairedPlanningExternal) {
+                const e = r;
+                const tag = e.passthrough ? " (passthrough)" : "";
+                lines.push(`    • ${e.projectionPath}${tag}`);
+            }
+        }
+        if (result.blockers.length > 0) {
+            lines.push("", "  ⚠ Blockers:");
+            for (const b of result.blockers)
+                lines.push(`    • ${b}`);
+        }
+        if (dryRun) {
+            lines.push("", "  (dry-run: no repairs, projection, or marker writes performed)");
+            ctx.ui.notify(lines.join("\n"), "info");
+            return;
+        }
+        const renderResult = await renderAllFromDb(basePath);
+        if (renderResult.errors.length > 0) {
+            lines.push("", "  ⚠ Projection errors:");
+            for (const e of renderResult.errors)
+                lines.push(`    • ${e}`);
+        }
+        // Refresh the marker to reflect the freshly re-projected state. The
+        // planning hook inside renderAllFromDb already recorded per-file SHAs
+        // into marker.planning.projections; we read back the fully-populated
+        // marker here so the timestamp is the last thing written.
+        const marker = readCompatMarker(basePath);
+        marker.lastWriter = "gsd-pi";
+        marker.lastProjectedAt = new Date().toISOString();
+        writeCompatMarker(basePath, marker);
+        const planningShaCnt = Object.keys(marker.planning?.projections ?? {}).length;
+        const planningNote = planningShaCnt > 0
+            ? ` + ${planningShaCnt} .planning/ SHA${planningShaCnt !== 1 ? "s" : ""}`
+            : "";
+        const state = await deriveState(basePath);
+        lines.push("", `  Phase:  ${state.phase}`, `  Marker: .gsd/.compat.json refreshed${planningNote}`);
+        if (state.activeMilestone) {
+            lines.push(`  Active: ${state.activeMilestone.id}: ${state.activeMilestone.title}`);
+        }
+        ctx.ui.notify(lines.join("\n"), "info");
+    }
+    catch (err) {
+        ctx.ui.notify(`gsd sync failed: ${err.message}`, "error");
+    }
+}
 /**
  * `gsd rebuild markdown` — Re-render markdown projections from the authoritative DB.
  *
- * This is the DB-first realignment command. It does not import markdown into
- * the DB. Completion SUMMARY files that contradict open DB rows are preserved
+ * This is the DB-first realignment command. It does not import markdown into the
+ * DB. Completion SUMMARY files that contradict open DB rows are preserved
  * under `.gsd/quarantine/projections/` before DB projections are rendered.
  */
 export async function handleRebuild(ctx, basePath, args = "") {

package/dist/resources/extensions/gsd/commands-prefs-wizard.js

@@ -8,7 +8,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { getGlobalGSDPreferencesPath, getLegacyGlobalGSDPreferencesPath, getProjectGSDPreferencesPath, loadGlobalGSDPreferences, loadProjectGSDPreferences, loadEffectiveGSDPreferences, normalizePreferencesShape, resolveAllSkillReferences, } from "./preferences.js";
+import { getGlobalGSDPreferencesPath, getLegacyGlobalGSDPreferencesPath, getProjectGSDPreferencesPath, loadGlobalGSDPreferences, loadProjectGSDPreferences, loadEffectiveGSDPreferences, normalizePreferencesShape, resolveAllSkillReferences, clearGSDPreferencesCache, } from "./preferences.js";
 import { loadFile, saveFile, splitFrontmatter, parseFrontmatterMap } from "./files.js";
 import { runClaudeImportFlow } from "./claude-import.js";
 import { clearSessionModelOverride } from "./session-model-override.js";
@@ -246,6 +246,7 @@ export async function handleImportClaude(ctx, scope) {
                 body = preserved;
         }
         await saveFile(path, `---\n${frontmatter}---${body}`);
+        clearGSDPreferencesCache();
     };
     await runClaudeImportFlow(ctx, scope, readPrefs, writePrefs);
 }
@@ -265,6 +266,7 @@ export async function handlePrefsMode(ctx, scope) {
     }
     const content = `---\n${frontmatter}---${body}`;
     await saveFile(path, content);
+    clearGSDPreferencesCache();
     await ctx.waitForIdle();
     await ctx.reload();
     ctx.ui.notify(`Saved ${scope} preferences to ${path}`, "info");
@@ -531,6 +533,19 @@ export function buildCategorySummaries(prefs) {
         if (parts.length > 0)
             integrationsSummary = parts.join(", ");
     }
+    // Workspace (parent-workspace multi-repo)
+    const workspace = prefs.workspace;
+    const workspaceRepos = workspace?.repositories;
+    let workspaceSummary = "(single-repo)";
+    {
+        const parts = [];
+        if (workspace?.mode)
+            parts.push(`mode: ${workspace.mode}`);
+        if (workspaceRepos && Object.keys(workspaceRepos).length > 0)
+            parts.push(`${Object.keys(workspaceRepos).length} repo(s)`);
+        if (parts.length > 0)
+            workspaceSummary = parts.join(", ");
+    }
     return {
         mode: modeSummary,
         models: modelsSummary,
@@ -548,6 +563,7 @@ export function buildCategorySummaries(prefs) {
         hooks: hooksSummary,
         uok: uokSummary,
         integrations: integrationsSummary,
+        workspace: workspaceSummary,
     };
 }
 // ─── Category configuration functions ────────────────────────────────────────
@@ -714,7 +730,10 @@ async function configureDynamicRouting(ctx, prefs) {
     const hooks = await promptBoolean(ctx, "Route hook sessions dynamically", dr.hooks, true);
     if (hooks !== undefined)
         dr.hooks = hooks;
-    const flatRate = await promptBoolean(ctx, "Allow dynamic routing for flat-rate providers", dr.allow_flat_rate_providers, false);
+    // Opt-out flag (#1115): routing is allowed for flat-rate providers by
+    // default; only an explicit `false` suppresses it. The default hint reflects
+    // that allow-by-default behavior.
+    const flatRate = await promptBoolean(ctx, "Allow dynamic routing for flat-rate providers", dr.allow_flat_rate_providers, true);
     if (flatRate !== undefined)
         dr.allow_flat_rate_providers = flatRate;
     // tier_models.light / standard / heavy — optional model IDs
@@ -890,6 +909,135 @@ async function configureSkills(ctx, prefs) {
     const staleness = await promptInteger(ctx, "Skill staleness days (0 to disable)", prefs.skill_staleness_days, "60");
     applyNumber(prefs, "skill_staleness_days", staleness);
 }
+async function configureWorkspace(ctx, prefs) {
+    let workspace = (prefs.workspace ?? {});
+    // Mode
+    const mode = await promptEnum(ctx, "Workspace mode", workspace.mode, ["project", "parent"]);
+    if (mode !== undefined)
+        workspace = { ...workspace, mode: mode };
+    if (workspace.mode !== "parent") {
+        // Single-repo mode: drop any declared repositories and persist.
+        if (workspace.repositories && Object.keys(workspace.repositories).length > 0) {
+            const clear = await promptBoolean(ctx, "Clear declared repositories (switch to single-repo)?", false, false);
+            if (clear)
+                workspace = { mode: workspace.mode };
+        }
+        persistWorkspace(prefs, workspace);
+        return;
+    }
+    // Parent mode — edit child repositories via a sub-menu.
+    let repositories = { ...(workspace.repositories ?? {}) };
+    while (true) {
+        const ids = Object.keys(repositories).sort();
+        const summary = ids.length === 0 ? "(no repositories — parent mode requires at least one)" : `${ids.length} repo(s)`;
+        const listLabels = ids.map((id) => {
+            const r = repositories[id];
+            const roleStr = r.role ? ` — ${r.role}` : "";
+            const policyStr = r.commit_policy === "skip" ? " [skip]" : "";
+            return `${id} (${r.path})${roleStr}${policyStr}`;
+        });
+        const choice = await ctx.ui.select(`Declared repositories — ${summary}`, [...listLabels, "Add repository", "Done"]);
+        const pick = typeof choice === "string" ? choice : "";
+        if (!pick || pick === "Done")
+            break;
+        if (pick === "Add repository") {
+            const idInput = await ctx.ui.input("Repository id (letters, digits, . _ -; 'project' is reserved):", "");
+            const id = typeof idInput === "string" ? idInput.trim() : "";
+            if (!id || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(id)) {
+                ctx.ui.notify("Invalid repository id — must match ^[A-Za-z0-9][A-Za-z0-9._-]*$ and cannot be 'project'.", "warning");
+                continue;
+            }
+            if (id === "project" || repositories[id]) {
+                ctx.ui.notify(`Repository id "${id}" is reserved or already declared.`, "warning");
+                continue;
+            }
+            const pathInput = await ctx.ui.input("Repository path (relative to project root, e.g. frontend):", "");
+            const path = typeof pathInput === "string" ? pathInput.trim() : "";
+            if (!path) {
+                ctx.ui.notify("Repository path is required.", "warning");
+                continue;
+            }
+            const repo = { path };
+            const roleInput = await ctx.ui.input("Role/label (optional):", "");
+            if (typeof roleInput === "string" && roleInput.trim())
+                repo.role = roleInput.trim();
+            const verifyInput = await ctx.ui.input("Verification commands (comma- or newline-separated, optional):", "");
+            if (typeof verifyInput === "string" && verifyInput.trim()) {
+                const cmds = parseStringList(verifyInput);
+                if (cmds.length > 0)
+                    repo.verification = cmds;
+            }
+            const policy = await promptEnum(ctx, "Commit policy", undefined, ["auto", "skip"]);
+            if (policy === "skip")
+                repo.commit_policy = "skip";
+            repositories[id] = repo;
+        }
+        else {
+            // Edit/delete an existing repo (the first token is the id).
+            const id = pick.split(" ")[0];
+            if (!repositories[id])
+                continue;
+            const editChoice = await ctx.ui.select(`Repository ${id}`, ["Edit path", "Edit role", "Edit verification", "Edit commit policy", "Delete repository", "Cancel"]);
+            const ec = typeof editChoice === "string" ? editChoice : "";
+            if (!ec || ec === "Cancel")
+                continue;
+            if (ec === "Delete repository") {
+                delete repositories[id];
+            }
+            else if (ec === "Edit path") {
+                const v = await ctx.ui.input("Repository path:", repositories[id].path);
+                if (typeof v === "string" && v.trim())
+                    repositories[id] = { ...repositories[id], path: v.trim() };
+            }
+            else if (ec === "Edit role") {
+                const v = await ctx.ui.input("Role/label (blank to clear):", repositories[id].role ?? "");
+                if (typeof v === "string" && v.trim())
+                    repositories[id] = { ...repositories[id], role: v.trim() };
+                else if (typeof v === "string") {
+                    const { role, ...rest } = repositories[id];
+                    void role;
+                    repositories[id] = rest;
+                }
+            }
+            else if (ec === "Edit verification") {
+                const v = await ctx.ui.input("Verification commands (blank to clear):", (repositories[id].verification ?? []).join(", "));
+                if (typeof v === "string" && v.trim()) {
+                    const cmds = parseStringList(v);
+                    if (cmds.length > 0)
+                        repositories[id] = { ...repositories[id], verification: cmds };
+                }
+                else if (typeof v === "string") {
+                    const { verification, ...rest } = repositories[id];
+                    void verification;
+                    repositories[id] = rest;
+                }
+            }
+            else if (ec === "Edit commit policy") {
+                const policy = await promptEnum(ctx, "Commit policy", repositories[id].commit_policy, ["auto", "skip"]);
+                if (policy === "skip")
+                    repositories[id] = { ...repositories[id], commit_policy: "skip" };
+                else {
+                    const { commit_policy, ...rest } = repositories[id];
+                    void commit_policy;
+                    repositories[id] = rest;
+                }
+            }
+        }
+    }
+    if (Object.keys(repositories).length === 0) {
+        ctx.ui.notify("Parent mode requires at least one repository — mode not saved.", "warning");
+        return;
+    }
+    persistWorkspace(prefs, { mode: "parent", repositories });
+}
+/** Persist the workspace config onto prefs, dropping it entirely when empty. */
+function persistWorkspace(prefs, workspace) {
+    if (!workspace.mode && (!workspace.repositories || Object.keys(workspace.repositories).length === 0)) {
+        delete prefs.workspace;
+        return;
+    }
+    prefs.workspace = workspace;
+}
 async function configureSkillRules(ctx, prefs) {
     let rules = Array.isArray(prefs.skill_rules) ? [...prefs.skill_rules] : [];
     while (true) {
@@ -1098,6 +1246,8 @@ async function configureVerification(ctx, prefs) {
         prefs.verification_auto_fix = autoFix;
     const maxRetries = await promptInteger(ctx, "Verification max retries", prefs.verification_max_retries, "2");
     applyNumber(prefs, "verification_max_retries", maxRetries);
+    const perUnitCap = await promptNumber(ctx, "Per-unit cost cap (USD; retry cost ceiling, blank = clear to default)", prefs.per_unit_cost_cap_usd, "5.0");
+    applyNumber(prefs, "per_unit_cost_cap_usd", perUnitCap);
     const ev = await promptBoolean(ctx, "Enhanced verification (master toggle)", prefs.enhanced_verification, true);
     if (ev !== undefined)
         prefs.enhanced_verification = ev;
@@ -1162,7 +1312,7 @@ async function configureContextCodebase(ctx, prefs) {
         cm.observation_mask_turns = maskTurns;
     else if (maskTurns === "clear")
         delete cm.observation_mask_turns;
-    const thresh = await promptNumber(ctx, "Compaction threshold percent (0.5–0.95)", cm.compaction_threshold_percent, "0.60");
+    const thresh = await promptNumber(ctx, "Soft context warning threshold percent (0.5–0.95)", cm.compaction_threshold_percent, "0.60");
     if (thresh !== undefined && thresh !== "clear")
         cm.compaction_threshold_percent = thresh;
     else if (thresh === "clear")
@@ -1562,6 +1712,7 @@ export async function handlePrefsWizard(ctx, scope, prefill, opts) {
             `Hooks           ${summaries.hooks}`,
             `UoK             ${summaries.uok}`,
             `Integrations    ${summaries.integrations}`,
+            `Workspace       ${summaries.workspace}`,
             `Advanced        ${summaries.advanced}`,
             `── Save & Exit ──`,
         ];
@@ -1599,6 +1750,8 @@ export async function handlePrefsWizard(ctx, scope, prefill, opts) {
             await configureUoK(ctx, prefs);
         else if (choice.startsWith("Integrations"))
             await configureIntegrations(ctx, prefs);
+        else if (choice.startsWith("Workspace"))
+            await configureWorkspace(ctx, prefs);
         else if (choice.startsWith("Advanced"))
             await configureAdvanced(ctx, prefs);
     }
@@ -1627,6 +1780,7 @@ export async function writePreferencesFile(path, prefs, ctx, opts) {
     }
     const content = `---\n${frontmatter}---${body}`;
     await saveFile(path, content);
+    clearGSDPreferencesCache();
     if (ctx) {
         // Per-phase model prefs must beat an earlier /gsd model session pin.
         const models = prefs.models;
@@ -1668,19 +1822,25 @@ export function serializePreferencesToFrontmatter(prefs) {
                     const entries = Object.entries(item);
                     if (entries.length > 0) {
                         const [firstKey, firstVal] = entries[0];
-                        lines.push(`${prefix}  - ${firstKey}: ${yamlSafeString(firstVal)}`);
-                        for (let i = 1; i < entries.length; i++) {
-                            const [k, v] = entries[i];
-                            if (Array.isArray(v)) {
-                                lines.push(`${prefix}    ${k}:`);
-                                for (const arrItem of v) {
-                                    lines.push(`${prefix}      - ${yamlSafeString(arrItem)}`);
-                                }
+                        if (Array.isArray(firstVal)) {
+                            lines.push(`${prefix}  - ${firstKey}:`);
+                            for (const arrItem of firstVal) {
+                                lines.push(`${prefix}      - ${yamlSafeString(arrItem)}`);
                             }
-                            else {
-                                lines.push(`${prefix}    ${k}: ${yamlSafeString(v)}`);
+                        }
+                        else if (typeof firstVal === "object" && firstVal !== null) {
+                            lines.push(`${prefix}  - ${firstKey}:`);
+                            for (const [k, v] of Object.entries(firstVal)) {
+                                serializeValue(k, v, indent + 3);
                             }
                         }
+                        else {
+                            lines.push(`${prefix}  - ${firstKey}: ${yamlSafeString(firstVal)}`);
+                        }
+                        for (let i = 1; i < entries.length; i++) {
+                            const [k, v] = entries[i];
+                            serializeValue(k, v, indent + 2);
+                        }
                     }
                 }
                 else {
@@ -1718,6 +1878,7 @@ export function serializePreferencesToFrontmatter(prefs) {
         "reactive_execution", "gate_evaluation",
         "auto_visualize", "auto_report",
         "verification_commands", "verification_auto_fix", "verification_max_retries",
+        "per_unit_cost_cap_usd",
         "enhanced_verification", "enhanced_verification_pre",
         "enhanced_verification_post", "enhanced_verification_strict",
         "safety_harness",
@@ -1750,6 +1911,7 @@ export async function ensurePreferencesFile(path, ctx, scope) {
             return;
         }
         await saveFile(path, template);
+        clearGSDPreferencesCache();
         ctx.ui.notify(`Created ${scope} GSD skill preferences at ${path}`, "info");
     }
     else {
@@ -1800,6 +1962,7 @@ export async function handleLanguage(args, ctx) {
     const body = extractBodyAfterFrontmatter(rawContent)
         ?? "\n# GSD Skill Preferences\n\nSee `~/.gsd/agent/extensions/gsd/docs/preferences-reference.md` for full field documentation and examples.\n";
     await saveFile(path, `---\n${frontmatter}---${body}`);
+    clearGSDPreferencesCache();
     await ctx.waitForIdle();
     await ctx.reload();
 }

package/dist/resources/extensions/gsd/commands-usage.js

@@ -83,7 +83,7 @@ function formatThresholdLines() {
     }
     const compactionThreshold = prefs?.context_management?.compaction_threshold_percent;
     if (typeof compactionThreshold === "number") {
-        lines.push(`Compaction: ${Math.round(compactionThreshold * 100)}%`);
+        lines.push(`Soft context warning: ${Math.round(compactionThreshold * 100)}%`);
     }
     return lines;
 }

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

@@ -1,9 +1,8 @@
 // Project/App: gsd-pi
 // File Purpose: Handles manual milestone validation verdict overrides.
 import { loadFile } from "./files.js";
-import { gsdProjectionRoot, resolveMilestoneFile } from "./paths.js";
+import { resolveMilestoneFile } from "./paths.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
-import { join } from "node:path";
 import { deriveState } from "./state.js";
 import { executeValidateMilestone } from "./tools/workflow-tool-executors.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
@@ -89,17 +88,24 @@ export function parseValidationFile(content) {
     };
 }
 async function loadExistingValidation(basePath, milestoneId) {
+    // Layout-aware lookup against the canonical milestone root first (handles the
+    // worktree case via resolveCanonicalMilestoneRoot), then against the raw
+    // basePath if they differ. See open-gsd/gsd-pi#876.
     const canonicalBase = resolveCanonicalMilestoneRoot(basePath, milestoneId);
-    const canonicalValidationPath = join(gsdProjectionRoot(canonicalBase), "milestones", milestoneId, `${milestoneId}-VALIDATION.md`);
-    const canonicalContent = await loadFile(canonicalValidationPath);
-    if (canonicalContent) {
-        return { content: canonicalContent, source: canonicalValidationPath };
+    const canonicalValidationPath = resolveMilestoneFile(canonicalBase, milestoneId, "VALIDATION");
+    if (canonicalValidationPath) {
+        const canonicalContent = await loadFile(canonicalValidationPath);
+        if (canonicalContent) {
+            return { content: canonicalContent, source: canonicalValidationPath };
+        }
     }
-    const validationPath = resolveMilestoneFile(basePath, milestoneId, "VALIDATION");
-    if (validationPath && validationPath !== canonicalValidationPath) {
-        const content = await loadFile(validationPath);
-        if (content)
-            return { content, source: validationPath };
+    if (basePath !== canonicalBase) {
+        const validationPath = resolveMilestoneFile(basePath, milestoneId, "VALIDATION");
+        if (validationPath && validationPath !== canonicalValidationPath) {
+            const content = await loadFile(validationPath);
+            if (content)
+                return { content, source: validationPath };
+        }
     }
     await ensureDbOpen(basePath);
     const assessment = getLatestAssessmentByScope(milestoneId, "milestone-validation");

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

@@ -12,9 +12,9 @@ import { inferCommitType } from "./git-service.js";
 import { autoCommitCurrentBranch } from "./worktree.js";
 import { GSDError, GSD_GIT_ERROR } from "./errors.js";
 // ─── Status helper ─────────────────────────────────────────────────────────
-function getStatus(basePath, name, wtPath) {
-    const diff = diffWorktreeAll(basePath, name);
-    const numstat = diffWorktreeNumstat(basePath, name);
+function getStatus(basePath, name, wtPath, mainBranch) {
+    const diff = diffWorktreeAll(basePath, name, undefined, mainBranch);
+    const numstat = diffWorktreeNumstat(basePath, name, undefined, mainBranch);
     const filesChanged = diff.added.length + diff.modified.length + diff.removed.length;
     let linesAdded = 0;
     let linesRemoved = 0;
@@ -31,8 +31,7 @@ function getStatus(basePath, name, wtPath) {
     }
     let commits = 0;
     try {
-        const main = nativeDetectMainBranch(basePath);
-        commits = nativeCommitCountBetween(basePath, main, worktreeBranchName(name));
+        commits = nativeCommitCountBetween(basePath, mainBranch, worktreeBranchName(name));
     }
     catch {
         // commit count unavailable → leave at 0
@@ -88,7 +87,8 @@ export function formatCleanKeepReason(status) {
 async function handleList(ctx) {
     const basePath = projectRoot();
     const worktrees = listWorktrees(basePath);
-    const statuses = worktrees.map((wt) => getStatus(basePath, wt.name, wt.path));
+    const mainBranch = worktrees.length > 0 ? nativeDetectMainBranch(basePath) : "";
+    const statuses = worktrees.map((wt) => getStatus(basePath, wt.name, wt.path, mainBranch));
     ctx.ui.notify(formatWorktreeList(statuses), "info");
 }
 // ─── Subcommand: merge ──────────────────────────────────────────────────────
@@ -117,7 +117,8 @@ async function handleMerge(args, ctx) {
         ctx.ui.notify(`Worktree "${target}" not found.\n\nAvailable: ${available}`, "error");
         return;
     }
-    const status = getStatus(basePath, target, wt.path);
+    const mainBranch = nativeDetectMainBranch(basePath);
+    const status = getStatus(basePath, target, wt.path, mainBranch);
     if (status.filesChanged === 0 && !status.uncommitted) {
         try {
             removeWorktree(basePath, target, { deleteBranch: true });
@@ -144,7 +145,6 @@ async function handleMerge(args, ctx) {
         }
     }
     const commitType = inferCommitType(target);
-    const mainBranch = nativeDetectMainBranch(basePath);
     const commitMessage = `${commitType}: merge worktree ${target}\n\nGSD-Worktree: ${target}`;
     try {
         mergeWorktreeToMain(basePath, target, commitMessage);
@@ -191,8 +191,9 @@ async function handleClean(ctx) {
     }
     const removed = [];
     const kept = [];
+    const mainBranch = nativeDetectMainBranch(basePath);
     for (const wt of worktrees) {
-        const status = getStatus(basePath, wt.name, wt.path);
+        const status = getStatus(basePath, wt.name, wt.path, mainBranch);
         if (status.filesChanged === 0 && !status.uncommitted) {
             try {
                 removeWorktree(basePath, wt.name, { deleteBranch: true });
@@ -238,7 +239,8 @@ async function handleRemove(args, ctx) {
         ctx.ui.notify(`Worktree "${name}" not found.\n\nAvailable: ${available}`, "error");
         return;
     }
-    const status = getStatus(basePath, name, wt.path);
+    const mainBranch = nativeDetectMainBranch(basePath);
+    const status = getStatus(basePath, name, wt.path, mainBranch);
     if ((status.filesChanged > 0 || status.uncommitted) && !force) {
         ctx.ui.notify([
             `Worktree "${name}" has pending changes (${formatCleanKeepReason(status)}).`,
@@ -249,8 +251,17 @@ async function handleRemove(args, ctx) {
         return;
     }
     try {
-        removeWorktree(basePath, name, { deleteBranch: true });
-        ctx.ui.notify(`Removed worktree ${name}.`, "info");
+        const removed = removeWorktree(basePath, name, { deleteBranch: true });
+        if (removed) {
+            ctx.ui.notify(`Removed worktree ${name}.`, "info");
+        }
+        else {
+            ctx.ui.notify([
+                `Worktree removal aborted for "${name}" to preserve uncommitted changes.`,
+                "",
+                "Manual quarantine recovery may be needed before retrying removal.",
+            ].join("\n"), "warning");
+        }
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);