@opengsd/gsd-pi 1.8.1 → 1.9.0-dev.97ef11e3

package/dist/resources/extensions/gsd/migrate/presentation.js

@@ -0,0 +1,64 @@
+// gsd-pi - /gsd migrate presentation helpers.
+// File Purpose: Pure formatting for migration previews and post-write review prompts.
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { gsdRoot } from "../paths.js";
+function formatRequirements(preview) {
+    if (preview.requirements.total === 0)
+        return null;
+    return `Requirements: ${preview.requirements.total} (${preview.requirements.validated} validated, ${preview.requirements.active} active, ${preview.requirements.deferred} deferred, ${preview.requirements.outOfScope} out of scope)`;
+}
+function formatLegacyInputs(preview) {
+    if (!preview.migrationInputs)
+        return null;
+    return `Legacy inputs: ${preview.migrationInputs.milestonePhaseDirs} milestone phase dir(s), ${preview.migrationInputs.decisions} decision file(s), ${preview.migrationInputs.seeds} seed file(s)`;
+}
+export function buildMigrationPreviewSummary(preview, targetRoot) {
+    const lines = [
+        `Decisions: ${preview.decisions.total}`,
+        `Milestones: ${preview.milestoneCount}`,
+        `Slices: ${preview.totalSlices} (${preview.doneSlices} done — ${preview.sliceCompletionPct}%)`,
+        `Tasks: ${preview.totalTasks} (${preview.doneTasks} done — ${preview.taskCompletionPct}%)`,
+    ];
+    const requirements = formatRequirements(preview);
+    if (requirements)
+        lines.push(requirements);
+    const legacyInputs = formatLegacyInputs(preview);
+    if (legacyInputs)
+        lines.push(legacyInputs);
+    const targetGsdPath = gsdRoot(targetRoot);
+    if (existsSync(targetGsdPath)) {
+        lines.push("");
+        lines.push(`⚠ A .gsd directory already exists at ${targetGsdPath}.`);
+        lines.push("It will be backed up, deleted, and rewritten fresh before DB import.");
+    }
+    return lines;
+}
+export function formatMigrationPreviewStats(preview) {
+    const lines = [
+        `- Decisions: ${preview.decisions.total}`,
+        `- Milestones: ${preview.milestoneCount}`,
+        `- Slices: ${preview.totalSlices} (${preview.doneSlices} done — ${preview.sliceCompletionPct}%)`,
+        `- Tasks: ${preview.totalTasks} (${preview.doneTasks} done — ${preview.taskCompletionPct}%)`,
+    ];
+    const requirements = formatRequirements(preview);
+    if (requirements)
+        lines.push(`- ${requirements}`);
+    const legacyInputs = formatLegacyInputs(preview);
+    if (legacyInputs)
+        lines.push(`- ${legacyInputs}`);
+    return lines.join("\n");
+}
+function defaultReviewTemplatePath() {
+    const promptsDir = join(dirname(fileURLToPath(import.meta.url)), "..", "prompts");
+    return join(promptsDir, "review-migration.md");
+}
+export function buildReviewPrompt(input) {
+    const templatePath = input.templatePath ?? defaultReviewTemplatePath();
+    let content = readFileSync(templatePath, "utf-8");
+    content = content.replaceAll("{{sourcePath}}", input.sourcePath);
+    content = content.replaceAll("{{gsdPath}}", input.gsdPath);
+    content = content.replaceAll("{{previewStats}}", formatMigrationPreviewStats(input.preview));
+    return content.trim();
+}

package/dist/resources/extensions/gsd/model-cost-table.js

@@ -48,6 +48,8 @@ export const BUNDLED_COST_TABLE = [
     // GPT-5.5 API list price, also used for live Codex OAuth routing.
     // Source: https://openai.com/api/pricing/
     { id: "gpt-5.5", inputPer1k: 0.005, outputPer1k: 0.03, updatedAt: "2026-04-23" },
+    // Mirrors gpt-5.5 list pricing until OpenAI publishes official gpt-5.6 pricing.
+    { id: "gpt-5.6", inputPer1k: 0.005, outputPer1k: 0.03, updatedAt: "2026-07-08" },
     // Google
     { id: "gemini-2.0-flash", inputPer1k: 0.0001, outputPer1k: 0.0004, updatedAt: "2025-03-15" },
     { id: "gemini-flash-2.0", inputPer1k: 0.0001, outputPer1k: 0.0004, updatedAt: "2025-03-15" },

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

@@ -46,10 +46,12 @@ export const MODEL_CAPABILITY_TIER = {
     "gpt-5.3-codex": "heavy",
     "gpt-5.4": "heavy",
     "gpt-5.5": "heavy",
+    "gpt-5.6": "heavy",
     "o1": "heavy",
     "o3": "heavy",
     "o4-mini": "heavy",
     "o4-mini-deep-research": "heavy",
+    "grok-4.5": "heavy",
 };
 // ─── Cost Table (per 1K input tokens, approximate USD) ───────────────────────
 // Used for cross-provider cost comparison when multiple providers offer
@@ -82,11 +84,13 @@ const MODEL_COST_PER_1K_INPUT = {
     "gpt-5.3-codex-spark": 0.0003,
     "gpt-5.4": 0.005,
     "gpt-5.5": 0.005,
+    "gpt-5.6": 0.005,
     "o4-mini": 0.005,
     "o4-mini-deep-research": 0.005,
     "gemini-2.0-flash": 0.0001,
     "gemini-2.5-pro": 0.00125,
     "deepseek-chat": 0.00014,
+    "grok-4.5": 0.002,
 };
 // ─── Capability Profiles Data Table ──────────────────────────────────────────
 // Per-model capability profiles (0–100 scale). Used for capability-aware
@@ -128,6 +132,9 @@ export const MODEL_CAPABILITY_PROFILES = {
     // OpenAI's 2026-04-23 published eval deltas across coding, tool use, and long context.
     // Source: https://openai.com/index/introducing-gpt-5-5/
     "gpt-5.5": { coding: 96, debugging: 93, research: 89, reasoning: 95, speed: 42, longContext: 90, instruction: 93 },
+    // GPT-5.6 profile is provisional: a small uniform step over gpt-5.5, to be
+    // recalibrated once OpenAI publishes official eval results.
+    "gpt-5.6": { coding: 97, debugging: 94, research: 90, reasoning: 96, speed: 42, longContext: 91, instruction: 94 },
     // ── OpenAI o-series (reasoning-first) ──────────────────────────────────────
     "o1": { coding: 78, debugging: 82, research: 78, reasoning: 90, speed: 20, longContext: 65, instruction: 82 },
     "o3": { coding: 80, debugging: 85, research: 80, reasoning: 92, speed: 25, longContext: 70, instruction: 85 },
@@ -139,6 +146,10 @@ export const MODEL_CAPABILITY_PROFILES = {
     "gemini-flash-2.0": { coding: 50, debugging: 40, research: 50, reasoning: 40, speed: 95, longContext: 60, instruction: 65 },
     // ── DeepSeek ───────────────────────────────────────────────────────────────
     "deepseek-chat": { coding: 75, debugging: 65, research: 55, reasoning: 70, speed: 70, longContext: 55, instruction: 65 },
+    // ── xAI ────────────────────────────────────────────────────────────────────
+    // Grok 4.5 (2026-07): Opus-class frontier model tuned for coding and agentic
+    // work; notably faster and more token-efficient than peer heavy models.
+    "grok-4.5": { coding: 95, debugging: 90, research: 82, reasoning: 93, speed: 55, longContext: 80, instruction: 90 },
 };
 // ─── Base Task Requirements Data Table ───────────────────────────────────────
 // Per-unit-type base requirement vectors. Weights indicate how important each

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

@@ -6,7 +6,7 @@
  */
 import { deriveState } from "./state.js";
 import { findMilestoneIds } from "./guided-flow.js";
-import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, getTasksBySliceIds } from "./gsd-db.js";
 import { openExistingWorkflowDatabase } from "./db-workspace.js";
 // ─── File Collection ─────────────────────────────────────────────────────────
 /**
@@ -16,10 +16,11 @@ import { openExistingWorkflowDatabase } from "./db-workspace.js";
 async function collectTouchedFiles(basePath, milestoneId) {
     const files = new Set();
     if (isDbAvailable()) {
-        // DB path: query slices and their tasks for file lists
+        // DB path: query slices and their tasks for file lists (one batched task
+        // query instead of one per slice; file order is irrelevant here — Set dedup)
         const slices = getMilestoneSlices(milestoneId);
-        for (const slice of slices) {
-            const tasks = getSliceTasks(milestoneId, slice.id);
+        const tasksBySlice = getTasksBySliceIds(slices.map((slice) => ({ milestoneId, sliceId: slice.id })));
+        for (const tasks of tasksBySlice.values()) {
             for (const task of tasks) {
                 if (Array.isArray(task.files)) {
                     for (const f of task.files) {

package/dist/resources/extensions/gsd/parallel-monitor-overlay.js

@@ -75,15 +75,18 @@ function discoverWorkers(basePath) {
     }
     return [...mids].sort();
 }
-function querySliceProgress(basePath, mid, workRoot = worktreePathFor(basePath, mid)) {
+// Slice progress + recent completions share one DB connection per worker per
+// tick. Opening the isolated worker DB twice per refresh (once for each) was
+// pure churn on the 5s interval.
+function queryWorkerProgress(basePath, mid, workRoot = worktreePathFor(basePath, mid)) {
     const dbPath = resolveGsdPathContract(workRoot, basePath).projectDb;
     if (!existsSync(dbPath))
-        return [];
+        return { slices: [], completions: [] };
     const db = openWorkflowDatabaseIsolated(dbPath);
     if (!db)
-        return [];
+        return { slices: [], completions: [] };
     try {
-        const rows = db.prepare(`SELECT
+        const sliceRows = db.prepare(`SELECT
          s.id AS id,
          s.status AS status,
          COUNT(t.id) AS total,
@@ -93,15 +96,29 @@ function querySliceProgress(basePath, mid, workRoot = worktreePathFor(basePath,
        WHERE s.milestone_id=:mid
        GROUP BY s.id
        ORDER BY s.id`).all({ ":mid": mid });
-        return rows.map((row) => ({
+        const slices = sliceRows.map((row) => ({
             id: String(row["id"] ?? ""),
             status: String(row["status"] ?? ""),
             total: Number(row["total"] ?? 0),
             done: Number(row["done"] ?? 0),
         }));
+        const completionRows = db.prepare(`SELECT id, slice_id, one_liner
+       FROM tasks
+       WHERE milestone_id=:mid
+         AND status='complete'
+         AND completed_at IS NOT NULL
+       ORDER BY completed_at DESC
+       LIMIT 5`).all({ ":mid": mid });
+        const completions = completionRows.map((row) => {
+            const taskId = String(row["id"] ?? "");
+            const sliceId = String(row["slice_id"] ?? "");
+            const oneLiner = String(row["one_liner"] ?? "");
+            return `✓ ${mid}/${sliceId}/${taskId}${oneLiner ? ": " + oneLiner : ""}`;
+        });
+        return { slices, completions };
     }
     catch {
-        return [];
+        return { slices: [], completions: [] };
     }
     finally {
         try {
@@ -200,39 +217,6 @@ function extractCostFromNdjson(basePath, mid) {
         return ndjsonCostCache.get(stdoutPath)?.total ?? 0;
     }
 }
-function queryRecentCompletions(basePath, mid) {
-    const workRoot = worktreePathFor(basePath, mid);
-    const dbPath = resolveGsdPathContract(workRoot, basePath).projectDb;
-    if (!existsSync(dbPath))
-        return [];
-    const db = openWorkflowDatabaseIsolated(dbPath);
-    if (!db)
-        return [];
-    try {
-        const rows = db.prepare(`SELECT id, slice_id, one_liner
-       FROM tasks
-       WHERE milestone_id=:mid
-         AND status='complete'
-         AND completed_at IS NOT NULL
-       ORDER BY completed_at DESC
-       LIMIT 5`).all({ ":mid": mid });
-        return rows.map((row) => {
-            const taskId = String(row["id"] ?? "");
-            const sliceId = String(row["slice_id"] ?? "");
-            const oneLiner = String(row["one_liner"] ?? "");
-            return `✓ ${mid}/${sliceId}/${taskId}${oneLiner ? ": " + oneLiner : ""}`;
-        });
-    }
-    catch {
-        return [];
-    }
-    finally {
-        try {
-            db.close();
-        }
-        catch { /* ignore */ }
-    }
-}
 function collectWorkerData(basePath) {
     const mids = discoverWorkers(basePath);
     const parallelDir = join(basePath, ".gsd", "parallel");
@@ -243,7 +227,7 @@ function collectWorkerData(basePath) {
         const workRoot = worktreePathFor(basePath, mid);
         const status = readJsonSafe(join(parallelDir, `${mid}.status.json`));
         const lock = readJsonSafe(join(workRoot, ".gsd", "auto.lock"));
-        const slices = querySliceProgress(basePath, mid, workRoot);
+        const { slices, completions } = queryWorkerProgress(basePath, mid, workRoot);
         const pid = lock?.pid || status?.pid || 0;
         const alive = pid ? isPidAlive(pid) : false;
         // Heartbeat: prefer status.json if PID matches, else use file mtime
@@ -303,6 +287,7 @@ function collectWorkerData(basePath) {
             totalSlices: slices.length,
             doneSlices,
             slices,
+            completions,
             errors,
         });
     }
@@ -355,10 +340,10 @@ export class ParallelMonitorOverlay {
         if (this.disposed)
             return;
         this.workers = collectWorkerData(this.basePath);
-        // Collect completion events
+        // Collect completion events (already read during collectWorkerData's single
+        // DB open per worker — no second connection here).
         for (const wk of this.workers) {
-            const completions = queryRecentCompletions(this.basePath, wk.mid);
-            for (const evt of completions) {
+            for (const evt of wk.completions) {
                 if (!this.events.includes(evt))
                     this.events.push(evt);
             }

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

@@ -122,6 +122,14 @@ function cachedReaddir(dirPath) {
     dirListCache.set(dirPath, entries);
     return entries;
 }
+function isExistingFile(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Clear the volatile directory listing caches.
  * Call after milestone transitions, file creation in planning directories,
@@ -198,6 +206,25 @@ export function buildTaskFileName(taskId, suffix) {
     // This helper is deprecated but kept for backward-compat callers.
     return `${taskId}-${suffix}.md`;
 }
+/**
+ * Build a flat-phase task artifact file name.
+ * ("S06", "T03", "SUMMARY") → "S06-T03-SUMMARY.md"
+ */
+export function buildFlatTaskFileName(sliceId, taskId, suffix) {
+    return `${sliceId}-${taskId}-${suffix}.md`;
+}
+/**
+ * Extract the task ID from a task artifact filename.
+ * Supports flat-phase S##-T##-SUFFIX.md plus legacy T##-SUFFIX.md and
+ * T##-DESCRIPTOR-SUFFIX.md names.
+ */
+export function taskIdFromTaskFileName(fileName, suffix) {
+    const flat = new RegExp(`^S\\d+-(T\\d+)-${suffix}\\.md$`, "i").exec(fileName);
+    if (flat?.[1])
+        return flat[1].toUpperCase();
+    const legacy = new RegExp(`^(T\\d+)(?:-.*)?-${suffix}\\.md$`, "i").exec(fileName);
+    return legacy?.[1]?.toUpperCase() ?? null;
+}
 // ─── Resolvers ─────────────────────────────────────────────────────────────
 /**
  * Find a directory entry by ID prefix within a parent directory.
@@ -238,7 +265,7 @@ export function resolveFile(dir, idPrefix, suffix) {
         return null;
     const target = `${idPrefix}-${suffix}.md`.toUpperCase();
     try {
-        const entries = cachedReaddir(dir);
+        const entries = cachedReaddirWithTypes(dir).filter(e => e.isFile()).map(e => e.name);
         // Direct match: ID-SUFFIX.md
         const direct = entries.find(e => e.toUpperCase() === target);
         if (direct)
@@ -259,19 +286,18 @@ export function resolveFile(dir, idPrefix, suffix) {
     }
 }
 /**
- * Find all task files matching a pattern in a tasks directory.
- * Returns sorted file names matching T##-SUFFIX.md or legacy T##-*-SUFFIX.md
+ * Find all task files matching a pattern in a tasks directory or flat phase dir.
+ * Returns sorted file names matching S##-T##-SUFFIX.md, T##-SUFFIX.md,
+ * or legacy T##-*-SUFFIX.md.
  */
 export function resolveTaskFiles(tasksDir, suffix) {
     if (!existsSync(tasksDir))
         return [];
     try {
-        // Current convention: T01-PLAN.md
-        const currentPattern = new RegExp(`^T\\d+-${suffix}\\.md$`, "i");
-        // Legacy convention: T01-INSTALL-PACKAGES-PLAN.md
-        const legacyPattern = new RegExp(`^T\\d+-.*-${suffix}\\.md$`, "i");
-        return cachedReaddir(tasksDir)
-            .filter(f => currentPattern.test(f) || legacyPattern.test(f))
+        return cachedReaddirWithTypes(tasksDir)
+            .filter(e => e.isFile())
+            .map(e => e.name)
+            .filter(f => taskIdFromTaskFileName(f, suffix) !== null)
             .sort();
     }
     catch {
@@ -585,19 +611,22 @@ function legacyMilestonesHasSubdirs(basePath) {
  * See the matching TODO in markdown-renderer.ts detectStaleRenders, which
  * disabled stale-render detection for the same reason.
  */
+const LEGACY_MILESTONE_RUNTIME_DIRS = new Set(["anchors"]);
 export function dirIsContentBearingLegacyMilestone(dir) {
     try {
         const entries = readdirSync(dir, { withFileTypes: true });
         // 1. Any non-META regular file → real legacy content.
         if (entries.some(e => e.isFile() && !e.name.endsWith("-META.json")))
             return true;
-        // 2. A non-empty subdirectory → real legacy content (e.g. slices/ with slice dirs).
+        // 2. A non-empty non-runtime subdirectory → real legacy content (e.g. slices/ with slice dirs).
         //    An *empty* subdir is treated as scaffolding (e.g. git-service.ts may create
         //    an empty slices/ alongside the integration META file) and must NOT flip the
         //    layout — that is the Bugbot finding this guard addresses.
         return entries.some(e => {
             if (!e.isDirectory())
                 return false;
+            if (LEGACY_MILESTONE_RUNTIME_DIRS.has(e.name))
+                return false;
             try {
                 return readdirSync(join(dir, e.name)).length > 0;
             }
@@ -807,7 +836,7 @@ export function resolveMilestoneFile(basePath, milestoneId, suffix) {
     const prefix = `${String(phaseNum).padStart(2, "0")}`;
     const flatName = `${prefix}-${suffix}.md`;
     const flatPath = join(mDir, flatName);
-    if (existsSync(flatPath))
+    if (isExistingFile(flatPath))
         return flatPath;
     // Legacy fallback: M001-SUFFIX.md
     const file = resolveFile(mDir, milestoneId, suffix);
@@ -840,12 +869,12 @@ export function resolveSliceFile(basePath, milestoneId, sliceId, suffix) {
     const planNum = sliceIdToPlanNum(sliceId);
     const flatName = planFileName(phaseNum, planNum, suffix);
     const flatPath = join(phaseDir, flatName);
-    if (existsSync(flatPath))
+    if (isExistingFile(flatPath))
         return flatPath;
     // Also check plan-number-only format MM-SUFFIX.md (written by buildSliceFileName)
     const planOnlyName = `${String(planNum).padStart(2, "0")}-${suffix}.md`;
     const planOnlyPath = join(phaseDir, planOnlyName);
-    if (existsSync(planOnlyPath))
+    if (isExistingFile(planOnlyPath))
         return planOnlyPath;
     // Try prefix match for the phase+plan number (handles suffix variations)
     const planPrefix = `${String(phaseNum).padStart(2, "0")}-${String(planNum).padStart(2, "0")}-`;
@@ -890,8 +919,11 @@ export function resolveTaskFile(basePath, milestoneId, sliceId, taskId, suffix)
     const legacyBase = legacyMilestonesDir(basePath);
     const isLegacy = phaseDir.startsWith(legacyBase + "/") || phaseDir.startsWith(legacyBase + "\\");
     if (suffix !== "PLAN" && !isLegacy) {
-        const flatPath = join(phaseDir, buildTaskFileName(taskId, suffix));
-        return existsSync(flatPath) ? flatPath : null;
+        const flatPath = join(phaseDir, buildFlatTaskFileName(sliceId, taskId, suffix));
+        if (isExistingFile(flatPath))
+            return flatPath;
+        const legacyFlatPath = join(phaseDir, buildTaskFileName(taskId, suffix));
+        return isExistingFile(legacyFlatPath) ? legacyFlatPath : null;
     }
     const tDir = resolveTasksDir(basePath, milestoneId, sliceId);
     if (tDir) {
@@ -1003,6 +1035,28 @@ export function targetSliceFile(basePath, milestoneId, sliceId, suffix, mileston
         : planFileName(milestoneIdToPhaseNum(milestoneId), sliceIdToPlanNum(sliceId), suffix);
     return join(dir, fileName);
 }
+/**
+ * Build the canonical absolute write target for a task file.
+ * Readers that need legacy flat-phase fallback should call resolveTaskFile.
+ */
+export function targetTaskFile(basePath, milestoneId, sliceId, taskId, suffix, milestoneTitle) {
+    if (suffix === "PLAN") {
+        return targetSliceFile(basePath, milestoneId, sliceId, "PLAN", milestoneTitle);
+    }
+    const mDir = resolveMilestonePath(basePath, milestoneId);
+    const legacyBase = legacyMilestonesDir(basePath);
+    const isLegacy = mDir
+        ? mDir.startsWith(legacyBase + "/") || mDir.startsWith(legacyBase + "\\")
+        : isLegacyMilestonesLayout(basePath);
+    const milestoneDir = mDir
+        ?? dirname(targetMilestoneFile(basePath, milestoneId, "ROADMAP", milestoneTitle));
+    if (isLegacy) {
+        const slicesDir = join(milestoneDir, "slices");
+        const sliceDir = join(slicesDir, resolveDir(slicesDir, sliceId) ?? sliceId);
+        return join(sliceDir, "tasks", buildTaskFileName(taskId, suffix));
+    }
+    return join(milestoneDir, buildFlatTaskFileName(sliceId, taskId, suffix));
+}
 /**
  * Build relative .gsd/ path to a slice file.
  * Preserves an existing compatibility filename when present; otherwise falls
@@ -1033,5 +1087,5 @@ export function relTaskFile(basePath, milestoneId, sliceId, taskId, suffix, mile
         return relSliceFile(basePath, milestoneId, sliceId, "PLAN");
     }
     const relS = relSlicePath(basePath, milestoneId, sliceId, milestoneTitle);
-    return `${relS}/${buildTaskFileName(taskId, suffix)}`;
+    return `${relS}/${buildFlatTaskFileName(sliceId, taskId, suffix)}`;
 }

package/dist/resources/extensions/gsd/phase-anchor.js

@@ -7,11 +7,14 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
 function anchorsDir(basePath, milestoneId) {
-    return join(gsdRoot(basePath), "milestones", milestoneId, "anchors");
+    return join(gsdRoot(basePath), "runtime", "anchors", milestoneId);
 }
 function anchorPath(basePath, milestoneId, phase) {
     return join(anchorsDir(basePath, milestoneId), `${phase}.json`);
 }
+function legacyAnchorPath(basePath, milestoneId, phase) {
+    return join(gsdRoot(basePath), "milestones", milestoneId, "anchors", `${phase}.json`);
+}
 export function writePhaseAnchor(basePath, milestoneId, anchor) {
     const dir = anchorsDir(basePath, milestoneId);
     if (!existsSync(dir)) {
@@ -20,7 +23,9 @@ export function writePhaseAnchor(basePath, milestoneId, anchor) {
     writeFileSync(anchorPath(basePath, milestoneId, anchor.phase), JSON.stringify(anchor, null, 2), "utf-8");
 }
 export function readPhaseAnchor(basePath, milestoneId, phase) {
-    const path = anchorPath(basePath, milestoneId, phase);
+    const path = existsSync(anchorPath(basePath, milestoneId, phase))
+        ? anchorPath(basePath, milestoneId, phase)
+        : legacyAnchorPath(basePath, milestoneId, phase);
     if (!existsSync(path))
         return null;
     try {

package/dist/resources/extensions/gsd/planning-subagent-policy.js

@@ -0,0 +1,37 @@
+import { CONFIGURABLE_PLANNING_SUBAGENT_UNITS } from "./preferences-types.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
+const CONFIGURABLE_UNITS = new Set(CONFIGURABLE_PLANNING_SUBAGENT_UNITS);
+function configuredAllowedSubagents(unitType, preferences) {
+    if (!CONFIGURABLE_UNITS.has(unitType))
+        return [];
+    return preferences?.planning_subagents?.[unitType]?.allowed ?? [];
+}
+function mergeAllowedSubagents(current, configured) {
+    return Array.from(new Set([...current, ...configured]));
+}
+export function applyPlanningSubagentPreferences(unitType, policy, preferences) {
+    if (!policy)
+        return policy;
+    const configured = configuredAllowedSubagents(unitType, preferences);
+    if (configured.length === 0)
+        return policy;
+    if (policy.mode === "planning") {
+        return {
+            mode: "planning-dispatch",
+            allowedSubagents: mergeAllowedSubagents([], configured),
+        };
+    }
+    if (policy.mode === "planning-dispatch") {
+        return {
+            ...policy,
+            allowedSubagents: mergeAllowedSubagents(policy.allowedSubagents, configured),
+        };
+    }
+    return policy;
+}
+export function resolveEffectivePlanningToolsPolicy(unitType, policy, basePath) {
+    if (!basePath)
+        return policy;
+    const preferences = loadEffectiveGSDPreferences(basePath)?.preferences;
+    return applyPlanningSubagentPreferences(unitType, policy, preferences);
+}

package/dist/resources/extensions/gsd/planning-subagent-registry.js

@@ -0,0 +1,25 @@
+/**
+ * Read-only planning specialists that controlled planning dispatch may use.
+ *
+ * Unit manifests and project preferences still declare per-unit subsets. This
+ * registry is the global safety classification checked by the write gate and
+ * preference validation before any configured planning allowlist takes effect.
+ */
+const PLANNING_DISPATCH_AGENT_REGISTRY = {
+    mnemo: { readOnlySpecialist: true },
+    scout: { readOnlySpecialist: true },
+    planner: { readOnlySpecialist: true },
+    reviewer: { readOnlySpecialist: true },
+    security: { readOnlySpecialist: true },
+    tester: { readOnlySpecialist: true },
+};
+export const ALLOWED_PLANNING_DISPATCH_AGENTS = new Set(Object.entries(PLANNING_DISPATCH_AGENT_REGISTRY)
+    .filter(([, metadata]) => metadata.readOnlySpecialist)
+    .map(([agentId]) => agentId));
+export function isReadOnlyPlanningDispatchAgent(agentId) {
+    const metadata = PLANNING_DISPATCH_AGENT_REGISTRY[agentId];
+    return metadata?.readOnlySpecialist === true;
+}
+export function allowedPlanningDispatchAgentsList() {
+    return [...ALLOWED_PLANNING_DISPATCH_AGENTS].join(", ");
+}

package/dist/resources/extensions/gsd/post-execution-checks.js

@@ -242,11 +242,11 @@ export function checkImportResolution(taskRow, _priorTasks, basePath) {
         }
         const imports = extractRelativeImports(source);
         for (const { importPath, lineNum } of imports) {
-            // Framework-generated type modules may not exist on disk during post-exec
-            // checks (typically generated during framework builds/typegen). Don't
-            // block task completion on these imports.
+            // Framework/codegen-generated modules may not exist on disk during
+            // post-exec checks. Don't block task completion on these imports.
             if (/^\.{1,2}\/\+types\//.test(importPath) ||
-                /^(?:\.{1,2}\/)+(?:[^/]+\/)*\$types(?:$|\/)/.test(importPath)) {
+                /^(?:\.{1,2}\/)+(?:[^/]+\/)*\$types(?:$|\/)/.test(importPath) ||
+                /^(?:\.{1,2}\/)+(?:[^/]+\/)*_generated(?:$|\/)/.test(importPath)) {
                 continue;
             }
             const resolution = resolveImportPath(importPath, file, basePath);

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

@@ -61,6 +61,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "git",
     "post_unit_hooks",
     "pre_dispatch_hooks",
+    "planning_subagents",
     "dynamic_routing",
     "disabled_model_providers",
     "uok",
@@ -134,6 +135,10 @@ export const KNOWN_UNIT_LABELS = [
     "workflow-preferences", "discuss-project", "discuss-requirements",
     "research-decision", "research-project",
 ];
+export const CONFIGURABLE_PLANNING_SUBAGENT_UNITS = [
+    "plan-milestone",
+    "plan-slice",
+];
 export const SKILL_ACTIONS = new Set(["use", "prefer", "avoid"]);
 /** The nine model-routing phase buckets. */
 export const GSD_MODEL_PHASE_KEYS = [

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

@@ -9,7 +9,8 @@ import { isAbsolute } from "node:path";
 import { VALID_BRANCH_NAME } from "./git-service.js";
 import { normalizeStringArray } from "../shared/format-utils.js";
 import { getGateIdsForTurn } from "./gate-registry.js";
-import { KNOWN_PREFERENCE_KEYS, KNOWN_UNIT_LABELS, GSD_MODEL_PHASE_KEYS, SKILL_ACTIONS, } from "./preferences-types.js";
+import { KNOWN_PREFERENCE_KEYS, KNOWN_UNIT_LABELS, CONFIGURABLE_PLANNING_SUBAGENT_UNITS, GSD_MODEL_PHASE_KEYS, SKILL_ACTIONS, } from "./preferences-types.js";
+import { ALLOWED_PLANNING_DISPATCH_AGENTS, allowedPlanningDispatchAgentsList, } from "./planning-subagent-registry.js";
 const VALID_TOKEN_PROFILES = new Set(["budget", "balanced", "quality", "burn-max"]);
 const VALID_THINKING_LEVELS = new Set([
     "off",
@@ -727,6 +728,52 @@ export function validatePreferences(preferences) {
             validated.pre_dispatch_hooks = validPreHooks;
         }
     }
+    // ─── Planning Subagents ─────────────────────────────────────────────────
+    if (preferences.planning_subagents !== undefined) {
+        if (!preferences.planning_subagents ||
+            typeof preferences.planning_subagents !== "object" ||
+            Array.isArray(preferences.planning_subagents)) {
+            errors.push("planning_subagents must be an object keyed by planning unit type");
+        }
+        else {
+            const validUnits = new Set(CONFIGURABLE_PLANNING_SUBAGENT_UNITS);
+            const validPlanningSubagents = {};
+            for (const [unitType, rawConfig] of Object.entries(preferences.planning_subagents)) {
+                if (!validUnits.has(unitType)) {
+                    errors.push(`planning_subagents unknown or unsupported unit "${unitType}" — supported units: ` +
+                        `${CONFIGURABLE_PLANNING_SUBAGENT_UNITS.join(", ")}`);
+                    continue;
+                }
+                if (!rawConfig || typeof rawConfig !== "object" || Array.isArray(rawConfig)) {
+                    errors.push(`planning_subagents.${unitType} must be an object with an allowed array`);
+                    continue;
+                }
+                const allowed = normalizeStringArray(rawConfig.allowed);
+                if (allowed.length === 0) {
+                    errors.push(`planning_subagents.${unitType}.allowed must include at least one read-only planning specialist`);
+                    continue;
+                }
+                const sanitizedAllowed = [];
+                for (const agentId of allowed) {
+                    if (!ALLOWED_PLANNING_DISPATCH_AGENTS.has(agentId)) {
+                        errors.push(`planning_subagents.${unitType}.allowed includes "${agentId}", which is not classified as a ` +
+                            `read-only planning specialist. Allowed agents: ${allowedPlanningDispatchAgentsList()}`);
+                        continue;
+                    }
+                    sanitizedAllowed.push(agentId);
+                }
+                const dedupedAllowed = Array.from(new Set(sanitizedAllowed));
+                if (dedupedAllowed.length > 0) {
+                    validPlanningSubagents[unitType] = {
+                        allowed: dedupedAllowed,
+                    };
+                }
+            }
+            if (Object.keys(validPlanningSubagents).length > 0) {
+                validated.planning_subagents = validPlanningSubagents;
+            }
+        }
+    }
     // ─── Dynamic Routing ─────────────────────────────────────────────────
     if (preferences.dynamic_routing !== undefined) {
         if (typeof preferences.dynamic_routing === "object" && preferences.dynamic_routing !== null) {