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

package/src/resources/extensions/gsd/model-router.ts

@@ -111,10 +111,12 @@ export const MODEL_CAPABILITY_TIER: Record<string, ComplexityTier> = {
   "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) ───────────────────────
@@ -149,11 +151,13 @@ const MODEL_COST_PER_1K_INPUT: Record<string, number> = {
   "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 ──────────────────────────────────────────
@@ -198,6 +202,9 @@ export const MODEL_CAPABILITY_PROFILES: Record<string, ModelCapabilities> = {
   // 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 },
@@ -212,6 +219,11 @@ export const MODEL_CAPABILITY_PROFILES: Record<string, ModelCapabilities> = {
 
   // ── 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 ───────────────────────────────────────

package/src/resources/extensions/gsd/parallel-eligibility.ts

@@ -8,7 +8,7 @@
 import { deriveState } from "./state.js";
 import { resolveMilestoneFile, resolveSliceFile } from "./paths.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";
 import type { MilestoneRegistryEntry } from "./types.js";
 
@@ -40,10 +40,11 @@ async function collectTouchedFiles(
   const files = new Set<string>();
 
   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/src/resources/extensions/gsd/parallel-monitor-overlay.ts

@@ -72,6 +72,7 @@ interface WorkerView {
   totalSlices: number;
   doneSlices: number;
   slices: SliceProgress[];
+  completions: string[];
   errors: string[];
 }
 
@@ -143,14 +144,21 @@ function discoverWorkers(basePath: string): string[] {
   return [...mids].sort();
 }
 
-function querySliceProgress(basePath: string, mid: string, workRoot: string = worktreePathFor(basePath, mid)): SliceProgress[] {
+// 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: string,
+  mid: string,
+  workRoot: string = worktreePathFor(basePath, mid),
+): { slices: SliceProgress[]; completions: string[] } {
   const dbPath = resolveGsdPathContract(workRoot, basePath).projectDb;
-  if (!existsSync(dbPath)) return [];
+  if (!existsSync(dbPath)) return { slices: [], completions: [] };
 
   const db = openWorkflowDatabaseIsolated(dbPath);
-  if (!db) return [];
+  if (!db) return { slices: [], completions: [] };
   try {
-    const rows = db.prepare(
+    const sliceRows = db.prepare(
       `SELECT
          s.id AS id,
          s.status AS status,
@@ -162,14 +170,32 @@ function querySliceProgress(basePath: string, mid: string, workRoot: string = wo
        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 { db.close(); } catch { /* ignore */ }
   }
@@ -276,36 +302,6 @@ function extractCostFromNdjson(basePath: string, mid: string): number {
   }
 }
 
-function queryRecentCompletions(basePath: string, mid: string): string[] {
-  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: string): WorkerView[] {
   const mids = discoverWorkers(basePath);
   const parallelDir = join(basePath, ".gsd", "parallel");
@@ -317,7 +313,7 @@ function collectWorkerData(basePath: string): WorkerView[] {
     const workRoot = worktreePathFor(basePath, mid);
     const status = readJsonSafe<StatusJson>(join(parallelDir, `${mid}.status.json`));
     const lock = readJsonSafe<AutoLock>(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;
@@ -378,6 +374,7 @@ function collectWorkerData(basePath: string): WorkerView[] {
       totalSlices: slices.length,
       doneSlices,
       slices,
+      completions,
       errors,
     });
   }
@@ -443,10 +440,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/src/resources/extensions/gsd/paths.ts

@@ -136,6 +136,14 @@ function cachedReaddir(dirPath: string): string[] {
   return entries;
 }
 
+function isExistingFile(path: string): boolean {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Clear the volatile directory listing caches.
  * Call after milestone transitions, file creation in planning directories,
@@ -223,6 +231,26 @@ export function buildTaskFileName(taskId: string, suffix: string): string {
   return `${taskId}-${suffix}.md`;
 }
 
+/**
+ * Build a flat-phase task artifact file name.
+ * ("S06", "T03", "SUMMARY") → "S06-T03-SUMMARY.md"
+ */
+export function buildFlatTaskFileName(sliceId: string, taskId: string, suffix: string): string {
+  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: string, suffix: string): string | null {
+  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 ─────────────────────────────────────────────────────────────
 
 /**
@@ -264,7 +292,7 @@ export function resolveFile(dir: string, idPrefix: string, suffix: string): stri
   if (!existsSync(dir)) 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) return direct;
@@ -284,18 +312,17 @@ export function resolveFile(dir: string, idPrefix: string, suffix: string): stri
 }
 
 /**
- * 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: string, suffix: string): string[] {
   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 {
     return [];
@@ -618,17 +645,20 @@ function legacyMilestonesHasSubdirs(basePath: string): boolean {
  * 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: string): boolean {
   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; } catch { return false; }
     });
   } catch {
@@ -840,7 +870,7 @@ export function resolveMilestoneFile(
   const prefix = `${String(phaseNum).padStart(2, "0")}`;
   const flatName = `${prefix}-${suffix}.md`;
   const flatPath = join(mDir, flatName);
-  if (existsSync(flatPath)) return flatPath;
+  if (isExistingFile(flatPath)) return flatPath;
   // Legacy fallback: M001-SUFFIX.md
   const file = resolveFile(mDir, milestoneId, suffix);
   return file ? join(mDir, file) : null;
@@ -875,11 +905,11 @@ export function resolveSliceFile(
   const planNum = sliceIdToPlanNum(sliceId);
   const flatName = planFileName(phaseNum, planNum, suffix);
   const flatPath = join(phaseDir, flatName);
-  if (existsSync(flatPath)) return 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)) return 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")}-`;
   try {
@@ -928,8 +958,10 @@ export function resolveTaskFile(
   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);
@@ -1063,6 +1095,35 @@ export function targetSliceFile(
   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: string, milestoneId: string, sliceId: string,
+  taskId: string, suffix: string, milestoneTitle?: string
+): string {
+  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
@@ -1102,5 +1163,5 @@ export function relTaskFile(
     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/src/resources/extensions/gsd/phase-anchor.ts

@@ -19,13 +19,17 @@ export interface PhaseAnchor {
 }
 
 function anchorsDir(basePath: string, milestoneId: string): string {
-  return join(gsdRoot(basePath), "milestones", milestoneId, "anchors");
+  return join(gsdRoot(basePath), "runtime", "anchors", milestoneId);
 }
 
 function anchorPath(basePath: string, milestoneId: string, phase: string): string {
   return join(anchorsDir(basePath, milestoneId), `${phase}.json`);
 }
 
+function legacyAnchorPath(basePath: string, milestoneId: string, phase: string): string {
+  return join(gsdRoot(basePath), "milestones", milestoneId, "anchors", `${phase}.json`);
+}
+
 export function writePhaseAnchor(basePath: string, milestoneId: string, anchor: PhaseAnchor): void {
   const dir = anchorsDir(basePath, milestoneId);
   if (!existsSync(dir)) {
@@ -35,7 +39,9 @@ export function writePhaseAnchor(basePath: string, milestoneId: string, anchor:
 }
 
 export function readPhaseAnchor(basePath: string, milestoneId: string, phase: string): PhaseAnchor | null {
-  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 {
     return JSON.parse(readFileSync(path, "utf-8")) as PhaseAnchor;

package/src/resources/extensions/gsd/planning-subagent-policy.ts

@@ -0,0 +1,58 @@
+import { CONFIGURABLE_PLANNING_SUBAGENT_UNITS, type GSDPreferences } from "./preferences-types.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
+import type { ToolsPolicy } from "./unit-context-manifest.js";
+
+const CONFIGURABLE_UNITS = new Set<string>(CONFIGURABLE_PLANNING_SUBAGENT_UNITS);
+
+function configuredAllowedSubagents(
+  unitType: string,
+  preferences: GSDPreferences | null | undefined,
+): readonly string[] {
+  if (!CONFIGURABLE_UNITS.has(unitType)) return [];
+  return preferences?.planning_subagents?.[
+    unitType as keyof NonNullable<GSDPreferences["planning_subagents"]>
+  ]?.allowed ?? [];
+}
+
+function mergeAllowedSubagents(
+  current: readonly string[],
+  configured: readonly string[],
+): readonly string[] {
+  return Array.from(new Set([...current, ...configured]));
+}
+
+export function applyPlanningSubagentPreferences(
+  unitType: string,
+  policy: ToolsPolicy | null | undefined,
+  preferences: GSDPreferences | null | undefined,
+): ToolsPolicy | null | undefined {
+  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: string,
+  policy: ToolsPolicy | null | undefined,
+  basePath?: string,
+): ToolsPolicy | null | undefined {
+  if (!basePath) return policy;
+  const preferences = loadEffectiveGSDPreferences(basePath)?.preferences;
+  return applyPlanningSubagentPreferences(unitType, policy, preferences);
+}

package/src/resources/extensions/gsd/planning-subagent-registry.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 },
+} as const satisfies Record<string, { readonly readOnlySpecialist: boolean }>;
+
+export const ALLOWED_PLANNING_DISPATCH_AGENTS = new Set<string>(
+  Object.entries(PLANNING_DISPATCH_AGENT_REGISTRY)
+    .filter(([, metadata]) => metadata.readOnlySpecialist)
+    .map(([agentId]) => agentId),
+);
+
+export function isReadOnlyPlanningDispatchAgent(agentId: string): boolean {
+  const metadata = PLANNING_DISPATCH_AGENT_REGISTRY[agentId as keyof typeof PLANNING_DISPATCH_AGENT_REGISTRY];
+  return metadata?.readOnlySpecialist === true;
+}
+
+export function allowedPlanningDispatchAgentsList(): string {
+  return [...ALLOWED_PLANNING_DISPATCH_AGENTS].join(", ");
+}

package/src/resources/extensions/gsd/post-execution-checks.ts

@@ -318,12 +318,12 @@ export function checkImportResolution(
     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;
       }

package/src/resources/extensions/gsd/preferences-types.ts

@@ -141,6 +141,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set<string>([
   "git",
   "post_unit_hooks",
   "pre_dispatch_hooks",
+  "planning_subagents",
   "dynamic_routing",
   "disabled_model_providers",
   "uok",
@@ -217,6 +218,20 @@ export const KNOWN_UNIT_LABELS = [
 ] as const;
 export type UnitLabel = (typeof KNOWN_UNIT_LABELS)[number];
 
+export const CONFIGURABLE_PLANNING_SUBAGENT_UNITS = [
+  "plan-milestone",
+  "plan-slice",
+] as const;
+export type ConfigurablePlanningSubagentUnit = (typeof CONFIGURABLE_PLANNING_SUBAGENT_UNITS)[number];
+
+export interface PlanningSubagentUnitConfig {
+  allowed?: string[];
+}
+
+export type PlanningSubagentsConfig = Partial<
+  Record<ConfigurablePlanningSubagentUnit, PlanningSubagentUnitConfig>
+>;
+
 
 export const SKILL_ACTIONS = new Set(["use", "prefer", "avoid"]);
 
@@ -476,6 +491,7 @@ export interface GSDPreferences {
   git?: GitPreferences;
   post_unit_hooks?: PostUnitHookConfig[];
   pre_dispatch_hooks?: PreDispatchHookConfig[];
+  planning_subagents?: PlanningSubagentsConfig;
   dynamic_routing?: DynamicRoutingConfig;
   /** Provider IDs to exclude from /model and automatic model routing while leaving tool auth intact. */
   disabled_model_providers?: string[];

package/src/resources/extensions/gsd/preferences-validation.ts

@@ -17,6 +17,7 @@ import { getGateIdsForTurn } from "./gate-registry.js";
 import {
   KNOWN_PREFERENCE_KEYS,
   KNOWN_UNIT_LABELS,
+  CONFIGURABLE_PLANNING_SUBAGENT_UNITS,
   GSD_MODEL_PHASE_KEYS,
 
   SKILL_ACTIONS,
@@ -26,6 +27,10 @@ import {
   type GSDSkillRule,
   type GSDThinkingLevel,
 } from "./preferences-types.js";
+import {
+  ALLOWED_PLANNING_DISPATCH_AGENTS,
+  allowedPlanningDispatchAgentsList,
+} from "./planning-subagent-registry.js";
 
 const VALID_TOKEN_PROFILES = new Set<TokenProfile>(["budget", "balanced", "quality", "burn-max"]);
 const VALID_THINKING_LEVELS = new Set<GSDThinkingLevel>([
@@ -747,6 +752,63 @@ export function validatePreferences(preferences: GSDPreferences): {
     }
   }
 
+  // ─── 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<string>(CONFIGURABLE_PLANNING_SUBAGENT_UNITS);
+      const validPlanningSubagents: NonNullable<GSDPreferences["planning_subagents"]> = {};
+
+      for (const [unitType, rawConfig] of Object.entries(preferences.planning_subagents as Record<string, unknown>)) {
+        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 as Record<string, unknown>).allowed);
+        if (allowed.length === 0) {
+          errors.push(`planning_subagents.${unitType}.allowed must include at least one read-only planning specialist`);
+          continue;
+        }
+
+        const sanitizedAllowed: string[] = [];
+        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 as keyof NonNullable<GSDPreferences["planning_subagents"]>] = {
+            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) {