gsd-pi 2.50.0 → 2.51.0-dev.7d435fe

package/dist/resources/extensions/gsd/memory-store.js

@@ -71,6 +71,9 @@ export function getActiveMemoriesRanked(limit = 30) {
 /**
  * Generate the next memory ID: MEM + zero-padded 3-digit from MAX(seq).
  * Returns MEM001 if no memories exist.
+ *
+ * NOTE: For race-safe creation, prefer createMemory() which inserts with a
+ * placeholder ID then updates to the seq-derived ID atomically.
  */
 export function nextMemoryId() {
     if (!isDbAvailable())
@@ -94,7 +97,9 @@ export function nextMemoryId() {
 }
 // ─── Mutation Functions ─────────────────────────────────────────────────────
 /**
- * Insert a new memory with auto-assigned ID.
+ * Insert a new memory with a race-safe auto-assigned ID.
+ * Uses AUTOINCREMENT seq to derive the ID after insert, avoiding
+ * the read-then-write race in concurrent scenarios (e.g. worktrees).
  * Returns the assigned ID, or null on failure.
  */
 export function createMemory(fields) {
@@ -104,11 +109,12 @@ export function createMemory(fields) {
     if (!adapter)
         return null;
     try {
-        const id = nextMemoryId();
         const now = new Date().toISOString();
+        // Insert with a temporary placeholder ID — seq is auto-assigned
+        const placeholder = `_TMP_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
         adapter.prepare(`INSERT INTO memories (id, category, content, confidence, source_unit_type, source_unit_id, created_at, updated_at)
        VALUES (:id, :category, :content, :confidence, :source_unit_type, :source_unit_id, :created_at, :updated_at)`).run({
-            ':id': id,
+            ':id': placeholder,
             ':category': fields.category,
             ':content': fields.content,
             ':confidence': fields.confidence ?? 0.8,
@@ -117,7 +123,17 @@ export function createMemory(fields) {
             ':created_at': now,
             ':updated_at': now,
         });
-        return id;
+        // Derive the real ID from the assigned seq
+        const row = adapter.prepare('SELECT seq FROM memories WHERE id = :id').get({ ':id': placeholder });
+        if (!row)
+            return placeholder; // fallback — should not happen
+        const seq = row['seq'];
+        const realId = `MEM${String(seq).padStart(3, '0')}`;
+        adapter.prepare('UPDATE memories SET id = :real_id WHERE id = :placeholder').run({
+            ':real_id': realId,
+            ':placeholder': placeholder,
+        });
+        return realId;
     }
     catch {
         return null;
@@ -258,15 +274,14 @@ export function enforceMemoryCap(max = 50) {
         if (count <= max)
             return;
         const excess = count - max;
-        // Find the IDs of the lowest-ranked active memories
-        const rows = adapter.prepare(`SELECT id FROM memories
-       WHERE superseded_by IS NULL
-       ORDER BY (confidence * (1.0 + hit_count * 0.1)) ASC
-       LIMIT :limit`).all({ ':limit': excess });
-        const now = new Date().toISOString();
-        for (const row of rows) {
-            adapter.prepare('UPDATE memories SET superseded_by = :reason, updated_at = :now WHERE id = :id').run({ ':reason': 'CAP_EXCEEDED', ':now': now, ':id': row['id'] });
-        }
+        // Batch update: supersede lowest-ranked active memories in a single statement
+        adapter.prepare(`UPDATE memories SET superseded_by = 'CAP_EXCEEDED', updated_at = :now
+       WHERE id IN (
+         SELECT id FROM memories
+         WHERE superseded_by IS NULL
+         ORDER BY (confidence * (1.0 + hit_count * 0.1)) ASC
+         LIMIT :limit
+       )`).run({ ':now': new Date().toISOString(), ':limit': excess });
     }
     catch {
         // non-fatal

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

@@ -15,6 +15,7 @@ import { join } from "node:path";
 import { resolveMilestonePath, resolveMilestoneFile, buildMilestoneFileName, } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
 import { loadQueueOrder, saveQueueOrder } from "./queue-order.js";
+import { isDbAvailable, updateMilestoneStatus } from "./gsd-db.js";
 // ─── Park ──────────────────────────────────────────────────────────────────
 /**
  * Park a milestone — creates a PARKED.md marker file with reason and timestamp.
@@ -44,6 +45,15 @@ export function parkMilestone(basePath, milestoneId, reason) {
         "",
     ].join("\n");
     writeFileSync(parkedPath, content, "utf-8");
+    // Sync DB status so deriveStateFromDb also skips this milestone (#2694)
+    if (isDbAvailable()) {
+        try {
+            updateMilestoneStatus(milestoneId, "parked");
+        }
+        catch (err) {
+            process.stderr.write(`gsd: parkMilestone DB sync failed for ${milestoneId}: ${err.message}\n`);
+        }
+    }
     invalidateAllCaches();
     return true;
 }
@@ -60,6 +70,15 @@ export function unparkMilestone(basePath, milestoneId) {
     if (!existsSync(parkedPath))
         return false; // not parked
     unlinkSync(parkedPath);
+    // Sync DB status so deriveStateFromDb picks up the unparked milestone (#2694)
+    if (isDbAvailable()) {
+        try {
+            updateMilestoneStatus(milestoneId, "active");
+        }
+        catch (err) {
+            process.stderr.write(`gsd: unparkMilestone DB sync failed for ${milestoneId}: ${err.message}\n`);
+        }
+    }
     invalidateAllCaches();
     return true;
 }

package/dist/resources/extensions/gsd/model-router.js

@@ -68,6 +68,20 @@ export function resolveModelForComplexity(classification, phaseConfig, routingCo
     const configuredPrimary = phaseConfig.primary;
     const configuredTier = getModelTier(configuredPrimary);
     const requestedTier = classification.tier;
+    // If the configured model is unknown (not in MODEL_CAPABILITY_TIER),
+    // honor the user's explicit choice — don't downgrade based on a guess.
+    // Unknown models default to "heavy" in getModelTier, which makes every
+    // standard/light unit get downgraded to tier_models, silently ignoring
+    // the user's configuration. (#2192)
+    if (!isKnownModel(configuredPrimary)) {
+        return {
+            modelId: configuredPrimary,
+            fallbacks: phaseConfig.fallbacks,
+            tier: requestedTier,
+            wasDowngraded: false,
+            reason: `configured model "${configuredPrimary}" is not in the known tier map — honoring explicit config`,
+        };
+    }
     // Downgrade-only: if requested tier >= configured tier, no change
     if (tierOrdinal(requestedTier) >= tierOrdinal(configuredTier)) {
         return {
@@ -141,6 +155,17 @@ function getModelTier(modelId) {
     // Unknown models are assumed heavy (safest assumption)
     return "heavy";
 }
+/** Check if a model ID has a known capability tier mapping. (#2192) */
+function isKnownModel(modelId) {
+    const bareId = modelId.includes("/") ? modelId.split("/").pop() : modelId;
+    if (MODEL_CAPABILITY_TIER[bareId])
+        return true;
+    for (const knownId of Object.keys(MODEL_CAPABILITY_TIER)) {
+        if (bareId.includes(knownId) || knownId.includes(bareId))
+            return true;
+    }
+    return false;
+}
 function findModelForTier(tier, config, availableModelIds, crossProvider) {
     // 1. Check explicit tier_models config
     const explicitModel = config.tier_models?.[tier];

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

@@ -49,6 +49,17 @@ export function buildDesktopNotificationCommand(platform, title, message, level
     const normalizedTitle = normalizeNotificationText(title);
     const normalizedMessage = normalizeNotificationText(message);
     if (platform === "darwin") {
+        // Prefer terminal-notifier: registers as its own Notification Center app,
+        // so it gets a proper permission entry in System Settings → Notifications.
+        // osascript notifications are silently swallowed when the calling terminal
+        // (Ghostty, iTerm2, etc.) lacks notification permissions — exits 0, no error.
+        // See: https://github.com/gsd-build/gsd-2/issues/2632
+        const tnPath = findExecutable("terminal-notifier");
+        if (tnPath) {
+            const sound = level === "error" ? "Basso" : "Glass";
+            return { file: tnPath, args: ["-title", normalizedTitle, "-message", normalizedMessage, "-sound", sound] };
+        }
+        // Fallback: osascript (works if terminal app has notification permissions)
         const sound = level === "error" ? 'sound name "Basso"' : 'sound name "Glass"';
         const script = `display notification "${escapeAppleScript(normalizedMessage)}" with title "${escapeAppleScript(normalizedTitle)}" ${sound}`;
         return { file: "osascript", args: ["-e", script] };
@@ -65,3 +76,15 @@ function normalizeNotificationText(s) {
 function escapeAppleScript(s) {
     return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 }
+/**
+ * Locate an executable on PATH. Returns absolute path or null.
+ * Non-fatal — returns null on any error.
+ */
+function findExecutable(name) {
+    try {
+        return execFileSync("which", [name], { timeout: 2000, stdio: ["ignore", "pipe", "ignore"] }).toString().trim() || null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/resources/extensions/gsd/observability-validator.js

@@ -0,0 +1,422 @@
+import { loadFile } from "./files.js";
+import { resolveSliceFile, resolveTaskFile, resolveTasksDir, resolveTaskFiles } from "./paths.js";
+function getSection(content, heading, level = 2) {
+    const prefix = "#".repeat(level) + " ";
+    const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(`^${prefix}${escaped}\\s*$`, "m");
+    const match = regex.exec(content);
+    if (!match)
+        return null;
+    const start = match.index + match[0].length;
+    const rest = content.slice(start);
+    const nextHeading = rest.match(new RegExp(`^#{1,${level}} `, "m"));
+    const end = nextHeading ? nextHeading.index : rest.length;
+    return rest.slice(0, end).trim();
+}
+function getFrontmatter(content) {
+    const trimmed = content.trimStart();
+    if (!trimmed.startsWith("---"))
+        return null;
+    const afterFirst = trimmed.indexOf("\n");
+    if (afterFirst === -1)
+        return null;
+    const rest = trimmed.slice(afterFirst + 1);
+    const endIdx = rest.indexOf("\n---");
+    if (endIdx === -1)
+        return null;
+    return rest.slice(0, endIdx);
+}
+function hasFrontmatterKey(content, key) {
+    const fm = getFrontmatter(content);
+    if (!fm)
+        return false;
+    return new RegExp(`^${key}:`, "m").test(fm);
+}
+function normalizeMeaningfulLines(text) {
+    return text
+        .split("\n")
+        .map(line => line.trim())
+        .filter(line => line.length > 0)
+        .filter(line => !line.startsWith("<!--"))
+        .filter(line => !line.endsWith("-->"))
+        .filter(line => !/^[-*]\s*\{\{.+\}\}$/.test(line))
+        .filter(line => !/^\{\{.+\}\}$/.test(line));
+}
+function sectionLooksPlaceholderOnly(text) {
+    if (!text)
+        return true;
+    const lines = normalizeMeaningfulLines(text)
+        .map(line => line.replace(/^[-*]\s+/, "").trim())
+        .filter(line => line.length > 0);
+    if (lines.length === 0)
+        return true;
+    return lines.every(line => {
+        const lower = line.toLowerCase();
+        return lower === "none" ||
+            lower.endsWith(": none") ||
+            lower.includes("{{") ||
+            lower.includes("}}") ||
+            lower.startsWith("required for non-trivial") ||
+            lower.startsWith("describe how a future agent") ||
+            lower.startsWith("prefer:") ||
+            lower.startsWith("keep this section concise");
+    });
+}
+function textSuggestsObservabilityRelevant(content) {
+    const lower = content.toLowerCase();
+    const needles = [
+        " api", "route", "server", "worker", "queue", "job", "sync", "import",
+        "webhook", "auth", "db", "database", "migration", "cache", "background",
+        "polling", "realtime", "socket", "stateful", "integration", "ui", "form",
+        "submit", "status", "service", "pipeline", "health endpoint", "error path"
+    ];
+    return needles.some(needle => lower.includes(needle));
+}
+function verificationMentionsDiagnostics(section) {
+    if (!section)
+        return false;
+    const lower = section.toLowerCase();
+    const needles = [
+        "error", "failure", "diagnostic", "status", "health", "inspect", "log",
+        "network", "console", "retry", "last error", "correlation", "readiness"
+    ];
+    return needles.some(needle => lower.includes(needle));
+}
+export function validateSlicePlanContent(file, content) {
+    const issues = [];
+    // ── Plan quality rules (always run, not gated by runtime relevance) ──
+    const tasksSection = getSection(content, "Tasks", 2);
+    if (tasksSection) {
+        const lines = tasksSection.split("\n");
+        const taskLinePattern = /^- \[[ x]\] \*\*T\d+:/;
+        const taskLineIndices = [];
+        for (let i = 0; i < lines.length; i++) {
+            if (taskLinePattern.test(lines[i]))
+                taskLineIndices.push(i);
+        }
+        for (let t = 0; t < taskLineIndices.length; t++) {
+            const start = taskLineIndices[t];
+            const end = t + 1 < taskLineIndices.length ? taskLineIndices[t + 1] : lines.length;
+            // Check lines between this task header and the next (or section end)
+            const bodyLines = lines.slice(start + 1, end);
+            const meaningful = bodyLines.filter(l => l.trim().length > 0);
+            if (meaningful.length === 0) {
+                issues.push({
+                    severity: "warning",
+                    scope: "slice-plan",
+                    file,
+                    ruleId: "empty_task_entry",
+                    message: "Inline task entry has no description content beneath the checkbox line.",
+                    suggestion: "Add at least a Why/Files/Do/Verify summary so the task is self-describing.",
+                });
+            }
+        }
+    }
+    // ── Observability rules (gated by runtime relevance) ──
+    const relevant = textSuggestsObservabilityRelevant(content);
+    if (!relevant)
+        return issues;
+    const obs = getSection(content, "Observability / Diagnostics", 2);
+    const verification = getSection(content, "Verification", 2);
+    if (!obs) {
+        issues.push({
+            severity: "warning",
+            scope: "slice-plan",
+            file,
+            ruleId: "missing_observability_section",
+            message: "Slice plan appears non-trivial but is missing `## Observability / Diagnostics`.",
+            suggestion: "Add runtime signals, inspection surfaces, failure visibility, and redaction constraints.",
+        });
+    }
+    else if (sectionLooksPlaceholderOnly(obs)) {
+        issues.push({
+            severity: "warning",
+            scope: "slice-plan",
+            file,
+            ruleId: "observability_section_placeholder_only",
+            message: "Slice plan has `## Observability / Diagnostics` but it still looks like placeholder text.",
+            suggestion: "Replace placeholders with concrete signals and inspection surfaces a future agent should trust.",
+        });
+    }
+    if (!verificationMentionsDiagnostics(verification)) {
+        issues.push({
+            severity: "warning",
+            scope: "slice-plan",
+            file,
+            ruleId: "verification_missing_diagnostic_check",
+            message: "Slice verification does not appear to include any diagnostic or failure-path check.",
+            suggestion: "Add at least one verification step for inspectable failure state, structured error output, status surface, or equivalent.",
+        });
+    }
+    return issues;
+}
+export function validateTaskPlanContent(file, content) {
+    const issues = [];
+    // ── Plan quality rules (always run, not gated by runtime relevance) ──
+    // Rule: empty or missing Steps section
+    const stepsSection = getSection(content, "Steps", 2);
+    if (stepsSection === null || sectionLooksPlaceholderOnly(stepsSection)) {
+        issues.push({
+            severity: "warning",
+            scope: "task-plan",
+            file,
+            ruleId: "empty_steps_section",
+            message: "Task plan has an empty or missing `## Steps` section.",
+            suggestion: "Add concrete numbered implementation steps so execution has a clear sequence.",
+        });
+    }
+    // Rule: placeholder-only Verification section
+    const verificationSection = getSection(content, "Verification", 2);
+    if (verificationSection !== null && sectionLooksPlaceholderOnly(verificationSection)) {
+        issues.push({
+            severity: "warning",
+            scope: "task-plan",
+            file,
+            ruleId: "placeholder_verification",
+            message: "Task plan has `## Verification` but it still looks like placeholder text.",
+            suggestion: "Replace placeholders with concrete verification commands, test runs, or observable checks.",
+        });
+    }
+    // Rule: scope estimate thresholds
+    const fm = getFrontmatter(content);
+    if (fm) {
+        const stepsMatch = fm.match(/^estimated_steps:\s*(\d+)/m);
+        const filesMatch = fm.match(/^estimated_files:\s*(\d+)/m);
+        if (stepsMatch) {
+            const estimatedSteps = parseInt(stepsMatch[1], 10);
+            if (estimatedSteps >= 10) {
+                issues.push({
+                    severity: "warning",
+                    scope: "task-plan",
+                    file,
+                    ruleId: "scope_estimate_steps_high",
+                    message: `Task plan estimates ${estimatedSteps} steps (threshold: 10). Consider splitting into smaller tasks.`,
+                    suggestion: "Break the task into sub-tasks or reduce scope so each task stays focused and completable in one pass.",
+                });
+            }
+        }
+        if (filesMatch) {
+            const estimatedFiles = parseInt(filesMatch[1], 10);
+            if (estimatedFiles >= 12) {
+                issues.push({
+                    severity: "warning",
+                    scope: "task-plan",
+                    file,
+                    ruleId: "scope_estimate_files_high",
+                    message: `Task plan estimates ${estimatedFiles} files (threshold: 12). Consider splitting into smaller tasks.`,
+                    suggestion: "Break the task into sub-tasks or reduce scope to keep the change footprint manageable.",
+                });
+            }
+        }
+    }
+    // Rule: Inputs and Expected Output should contain backtick-wrapped file paths
+    const inputsSection = getSection(content, "Inputs", 2);
+    const outputSection = getSection(content, "Expected Output", 2);
+    const backtickPathPattern = /`[^`]*[./][^`]*`/;
+    if (outputSection === null || !backtickPathPattern.test(outputSection)) {
+        issues.push({
+            severity: "warning",
+            scope: "task-plan",
+            file,
+            ruleId: "missing_output_file_paths",
+            message: "Task plan `## Expected Output` is missing or has no backtick-wrapped file paths.",
+            suggestion: "List concrete output file paths in backticks (e.g. `src/types.ts`). These are machine-parsed to derive task dependencies.",
+        });
+    }
+    if (inputsSection !== null && inputsSection.trim().length > 0 && !backtickPathPattern.test(inputsSection)) {
+        issues.push({
+            severity: "info",
+            scope: "task-plan",
+            file,
+            ruleId: "missing_input_file_paths",
+            message: "Task plan `## Inputs` has content but no backtick-wrapped file paths.",
+            suggestion: "List input file paths in backticks (e.g. `src/config.json`). These are machine-parsed to derive task dependencies.",
+        });
+    }
+    // ── Observability rules (gated by runtime relevance) ──
+    const relevant = textSuggestsObservabilityRelevant(content);
+    if (!relevant)
+        return issues;
+    const obs = getSection(content, "Observability Impact", 2);
+    if (!obs) {
+        issues.push({
+            severity: "warning",
+            scope: "task-plan",
+            file,
+            ruleId: "missing_observability_impact",
+            message: "Task plan appears runtime-relevant but is missing `## Observability Impact`.",
+            suggestion: "Explain what signals change, how a future agent inspects this task, and what failure state becomes visible.",
+        });
+    }
+    else if (sectionLooksPlaceholderOnly(obs)) {
+        issues.push({
+            severity: "warning",
+            scope: "task-plan",
+            file,
+            ruleId: "observability_impact_placeholder_only",
+            message: "Task plan has `## Observability Impact` but it still looks empty or placeholder-only.",
+            suggestion: "Fill in concrete inspection surfaces or explicitly justify why observability is not applicable.",
+        });
+    }
+    return issues;
+}
+export function validateTaskSummaryContent(file, content) {
+    const issues = [];
+    if (!hasFrontmatterKey(content, "observability_surfaces")) {
+        issues.push({
+            severity: "warning",
+            scope: "task-summary",
+            file,
+            ruleId: "missing_observability_frontmatter",
+            message: "Task summary is missing `observability_surfaces` in frontmatter.",
+            suggestion: "List the durable status/log/error surfaces a future agent should use.",
+        });
+    }
+    const diagnostics = getSection(content, "Diagnostics", 2);
+    if (!diagnostics) {
+        issues.push({
+            severity: "warning",
+            scope: "task-summary",
+            file,
+            ruleId: "missing_diagnostics_section",
+            message: "Task summary is missing `## Diagnostics`.",
+            suggestion: "Document how to inspect what this task built later.",
+        });
+    }
+    else if (sectionLooksPlaceholderOnly(diagnostics)) {
+        issues.push({
+            severity: "warning",
+            scope: "task-summary",
+            file,
+            ruleId: "diagnostics_placeholder_only",
+            message: "Task summary diagnostics section still looks like placeholder text.",
+            suggestion: "Replace placeholders with concrete commands, endpoints, logs, error shapes, or failure artifacts.",
+        });
+    }
+    const evidence = getSection(content, "Verification Evidence", 2);
+    if (!evidence) {
+        issues.push({
+            severity: "warning",
+            scope: "task-summary",
+            file,
+            ruleId: "evidence_block_missing",
+            message: "Task summary is missing `## Verification Evidence`.",
+            suggestion: "Add a verification evidence table showing gate check results (command, exit code, verdict, duration).",
+        });
+    }
+    else if (sectionLooksPlaceholderOnly(evidence)) {
+        issues.push({
+            severity: "warning",
+            scope: "task-summary",
+            file,
+            ruleId: "evidence_block_placeholder",
+            message: "Task summary verification evidence section still looks like placeholder text.",
+            suggestion: "Replace placeholders with actual gate results or note that no verification commands were discovered.",
+        });
+    }
+    return issues;
+}
+export function validateSliceSummaryContent(file, content) {
+    const issues = [];
+    if (!hasFrontmatterKey(content, "observability_surfaces")) {
+        issues.push({
+            severity: "warning",
+            scope: "slice-summary",
+            file,
+            ruleId: "missing_observability_frontmatter",
+            message: "Slice summary is missing `observability_surfaces` in frontmatter.",
+            suggestion: "List the authoritative diagnostics and durable inspection surfaces for this slice.",
+        });
+    }
+    const diagnostics = getSection(content, "Authoritative diagnostics", 3);
+    if (!diagnostics) {
+        issues.push({
+            severity: "warning",
+            scope: "slice-summary",
+            file,
+            ruleId: "missing_authoritative_diagnostics",
+            message: "Slice summary is missing `### Authoritative diagnostics` in Forward Intelligence.",
+            suggestion: "Tell future agents where to look first and why that signal is trustworthy.",
+        });
+    }
+    else if (sectionLooksPlaceholderOnly(diagnostics)) {
+        issues.push({
+            severity: "warning",
+            scope: "slice-summary",
+            file,
+            ruleId: "authoritative_diagnostics_placeholder_only",
+            message: "Slice summary includes authoritative diagnostics but it still looks like placeholder text.",
+            suggestion: "Replace placeholders with the real first-stop diagnostic surface for this slice.",
+        });
+    }
+    return issues;
+}
+export async function validatePlanBoundary(basePath, milestoneId, sliceId) {
+    const issues = [];
+    const slicePlan = resolveSliceFile(basePath, milestoneId, sliceId, "PLAN");
+    if (slicePlan) {
+        const content = await loadFile(slicePlan);
+        if (content)
+            issues.push(...validateSlicePlanContent(slicePlan, content));
+    }
+    const tasksDir = resolveTasksDir(basePath, milestoneId, sliceId);
+    const taskPlans = tasksDir ? resolveTaskFiles(tasksDir, "PLAN") : [];
+    for (const file of taskPlans) {
+        const taskId = file.split("-")[0];
+        const taskPlan = resolveTaskFile(basePath, milestoneId, sliceId, taskId, "PLAN");
+        if (!taskPlan)
+            continue;
+        const content = await loadFile(taskPlan);
+        if (content)
+            issues.push(...validateTaskPlanContent(taskPlan, content));
+    }
+    return issues;
+}
+export async function validateExecuteBoundary(basePath, milestoneId, sliceId, taskId) {
+    const issues = [];
+    const slicePlan = resolveSliceFile(basePath, milestoneId, sliceId, "PLAN");
+    if (slicePlan) {
+        const content = await loadFile(slicePlan);
+        if (content)
+            issues.push(...validateSlicePlanContent(slicePlan, content));
+    }
+    const taskPlan = resolveTaskFile(basePath, milestoneId, sliceId, taskId, "PLAN");
+    if (taskPlan) {
+        const content = await loadFile(taskPlan);
+        if (content)
+            issues.push(...validateTaskPlanContent(taskPlan, content));
+    }
+    return issues;
+}
+export async function validateCompleteBoundary(basePath, milestoneId, sliceId) {
+    const issues = [];
+    const tasksDir = resolveTasksDir(basePath, milestoneId, sliceId);
+    const taskSummaries = tasksDir ? resolveTaskFiles(tasksDir, "SUMMARY") : [];
+    for (const file of taskSummaries) {
+        const taskId = file.split("-")[0];
+        const taskSummary = resolveTaskFile(basePath, milestoneId, sliceId, taskId, "SUMMARY");
+        if (!taskSummary)
+            continue;
+        const content = await loadFile(taskSummary);
+        if (content)
+            issues.push(...validateTaskSummaryContent(taskSummary, content));
+    }
+    const sliceSummary = resolveSliceFile(basePath, milestoneId, sliceId, "SUMMARY");
+    if (sliceSummary) {
+        const content = await loadFile(sliceSummary);
+        if (content)
+            issues.push(...validateSliceSummaryContent(sliceSummary, content));
+    }
+    return issues;
+}
+export function formatValidationIssues(issues, limit = 4) {
+    if (issues.length === 0)
+        return "";
+    const lines = issues.slice(0, limit).map(issue => {
+        const fileName = issue.file.split("/").pop() || issue.file;
+        return `- ${fileName}: ${issue.message}`;
+    });
+    if (issues.length > limit)
+        lines.push(`- ...and ${issues.length - limit} more`);
+    return lines.join("\n");
+}

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

@@ -98,18 +98,6 @@ export function getNextFallbackModel(currentModelId, modelConfig) {
         return modelsToTry[0];
     }
 }
-/**
- * Detect whether an error message indicates a transient network error
- * (worth retrying the same model) vs a permanent provider error
- * (auth failure, quota exceeded, etc. -- should fall back immediately).
- */
-export function isTransientNetworkError(errorMsg) {
-    if (!errorMsg)
-        return false;
-    const hasNetworkSignal = /network|ECONNRESET|ETIMEDOUT|ECONNREFUSED|socket hang up|fetch failed|connection.*reset|dns/i.test(errorMsg);
-    const hasPermanentSignal = /auth|unauthorized|forbidden|invalid.*key|quota|billing/i.test(errorMsg);
-    return hasNetworkSignal && !hasPermanentSignal;
-}
 /**
  * Validate a model ID string.
  * Returns true if the ID looks like a valid model identifier.
@@ -273,7 +261,7 @@ export function resolveContextSelection() {
     return profile === "budget" ? "smart" : "full";
 }
 /**
- * Resolve the search provider preference from preferences.md.
+ * Resolve the search provider preference from PREFERENCES.md.
  * Returns undefined if not configured (caller falls back to existing behavior).
  */
 export function resolveSearchProviderFromPreferences() {

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

@@ -7,19 +7,25 @@
 import { existsSync, readdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { isAbsolute, join } from "node:path";
-import { getAgentDir } from "@gsd/pi-coding-agent";
 import { statSync } from "node:fs";
 import { validatePreferences } from "./preferences-validation.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 /**
  * Known skill directories, in priority order.
- * User skills (~/.gsd/agent/skills/) take precedence over project skills.
+ * Global skills (~/.agents/skills/) take precedence over project skills.
+ * Legacy ~/.gsd/agent/skills/ is included as a fallback for pre-migration installs.
  */
 export function getSkillSearchDirs(cwd) {
-    return [
-        { dir: join(getAgentDir(), "skills"), method: "user-skill" },
-        { dir: join(cwd, ".pi", "agent", "skills"), method: "project-skill" },
+    const dirs = [
+        { dir: join(homedir(), ".agents", "skills"), method: "user-skill" },
+        { dir: join(cwd, ".agents", "skills"), method: "project-skill" },
     ];
+    // Legacy fallback — read skills from old GSD directory only if migration hasn't completed
+    const legacyDir = join(homedir(), ".gsd", "agent", "skills");
+    if (existsSync(legacyDir) && !existsSync(join(legacyDir, ".migrated-to-agents"))) {
+        dirs.push({ dir: legacyDir, method: "user-skill" });
+    }
+    return dirs;
 }
 /**
  * Resolve a single skill reference to an absolute path.