@opengsd/gsd-pi 1.9.0-dev.e10b60d4 → 1.10.0-dev.a5e42e99

package/dist/resources/extensions/gsd/gsd-db.js

@@ -38,6 +38,7 @@ export * from "./db/queries.js";
 export * from "./db/writers/cascades.js";
 import { TERMINAL_STATUS_SQL } from "./db/sql-constants.js";
 import { applyStatusTransition } from "./db/writers/status.js";
+import { LAYOUT_SEGMENTS, derivePhaseSlug, milestoneIdToPhaseNum, milestoneIdUniqueSuffix, phaseDirName, } from "./layout-policy.js";
 export function insertDecision(d) {
     if (!getDbOrNull())
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
@@ -169,6 +170,44 @@ export function insertArtifact(a) {
         ":content_hash": contentHash,
     });
 }
+function canonicalPhaseDirNameForDb(milestoneId, title) {
+    const phaseNum = milestoneIdToPhaseNum(milestoneId);
+    const slug = derivePhaseSlug(title || milestoneId);
+    const suffix = milestoneIdUniqueSuffix(milestoneId);
+    return phaseDirName(phaseNum, suffix ? `${suffix}-${slug}` : slug);
+}
+function reconcileMilestonePhaseArtifactPaths(milestoneId, title) {
+    const db = getDbOrNull();
+    const phaseNumPrefix = String(milestoneIdToPhaseNum(milestoneId)).padStart(2, "0");
+    const canonicalDir = canonicalPhaseDirNameForDb(milestoneId, title);
+    const staleRows = db.prepare(`SELECT path
+       FROM artifacts
+      WHERE milestone_id = :milestone_id
+        AND path LIKE :phase_prefix`).all({
+        ":milestone_id": milestoneId,
+        ":phase_prefix": `${LAYOUT_SEGMENTS.level1}/${phaseNumPrefix}-%/%`,
+    });
+    const updatePath = db.prepare("UPDATE artifacts SET path = :new_path WHERE path = :old_path");
+    const deletePath = db.prepare("DELETE FROM artifacts WHERE path = :path");
+    const existingPath = db.prepare("SELECT 1 AS present FROM artifacts WHERE path = :path");
+    for (const row of staleRows) {
+        const parts = row.path.split("/");
+        if (parts.length < 3)
+            continue;
+        if (parts[0] !== LAYOUT_SEGMENTS.level1)
+            continue;
+        if (parts[1] === canonicalDir)
+            continue;
+        if (!parts[1]?.startsWith(`${phaseNumPrefix}-`))
+            continue;
+        const newPath = [LAYOUT_SEGMENTS.level1, canonicalDir, ...parts.slice(2)].join("/");
+        if (existingPath.get({ ":path": newPath })) {
+            deletePath.run({ ":path": row.path });
+            continue;
+        }
+        updatePath.run({ ":new_path": newPath, ":old_path": row.path });
+    }
+}
 export function insertMilestone(m) {
     if (!getDbOrNull())
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
@@ -207,37 +246,42 @@ export function insertMilestone(m) {
 export function upsertMilestonePlanning(milestoneId, planning) {
     if (!getDbOrNull())
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
-    getDbOrNull().prepare(`UPDATE milestones SET
-      title = COALESCE(NULLIF(:title, ''), title),
-      status = COALESCE(NULLIF(:status, ''), status),
-      depends_on = COALESCE(:depends_on, depends_on),
-      vision = COALESCE(:vision, vision),
-      success_criteria = COALESCE(:success_criteria, success_criteria),
-      key_risks = COALESCE(:key_risks, key_risks),
-      proof_strategy = COALESCE(:proof_strategy, proof_strategy),
-      verification_contract = COALESCE(:verification_contract, verification_contract),
-      verification_integration = COALESCE(:verification_integration, verification_integration),
-      verification_operational = COALESCE(:verification_operational, verification_operational),
-      verification_uat = COALESCE(:verification_uat, verification_uat),
-      definition_of_done = COALESCE(:definition_of_done, definition_of_done),
-      requirement_coverage = COALESCE(:requirement_coverage, requirement_coverage),
-      boundary_map_markdown = COALESCE(:boundary_map_markdown, boundary_map_markdown)
-     WHERE id = :id`).run({
-        ":id": milestoneId,
-        ":title": planning.title ?? "",
-        ":status": planning.status ?? "",
-        ":depends_on": planning.depends_on ? JSON.stringify(planning.depends_on) : null,
-        ":vision": planning.vision ?? null,
-        ":success_criteria": planning.successCriteria ? JSON.stringify(planning.successCriteria) : null,
-        ":key_risks": planning.keyRisks ? JSON.stringify(planning.keyRisks) : null,
-        ":proof_strategy": planning.proofStrategy ? JSON.stringify(planning.proofStrategy) : null,
-        ":verification_contract": planning.verificationContract ?? null,
-        ":verification_integration": planning.verificationIntegration ?? null,
-        ":verification_operational": planning.verificationOperational ?? null,
-        ":verification_uat": planning.verificationUat ?? null,
-        ":definition_of_done": planning.definitionOfDone ? JSON.stringify(planning.definitionOfDone) : null,
-        ":requirement_coverage": planning.requirementCoverage ?? null,
-        ":boundary_map_markdown": planning.boundaryMapMarkdown ?? null,
+    transaction(() => {
+        getDbOrNull().prepare(`UPDATE milestones SET
+        title = COALESCE(NULLIF(:title, ''), title),
+        status = COALESCE(NULLIF(:status, ''), status),
+        depends_on = COALESCE(:depends_on, depends_on),
+        vision = COALESCE(:vision, vision),
+        success_criteria = COALESCE(:success_criteria, success_criteria),
+        key_risks = COALESCE(:key_risks, key_risks),
+        proof_strategy = COALESCE(:proof_strategy, proof_strategy),
+        verification_contract = COALESCE(:verification_contract, verification_contract),
+        verification_integration = COALESCE(:verification_integration, verification_integration),
+        verification_operational = COALESCE(:verification_operational, verification_operational),
+        verification_uat = COALESCE(:verification_uat, verification_uat),
+        definition_of_done = COALESCE(:definition_of_done, definition_of_done),
+        requirement_coverage = COALESCE(:requirement_coverage, requirement_coverage),
+        boundary_map_markdown = COALESCE(:boundary_map_markdown, boundary_map_markdown)
+       WHERE id = :id`).run({
+            ":id": milestoneId,
+            ":title": planning.title ?? "",
+            ":status": planning.status ?? "",
+            ":depends_on": planning.depends_on ? JSON.stringify(planning.depends_on) : null,
+            ":vision": planning.vision ?? null,
+            ":success_criteria": planning.successCriteria ? JSON.stringify(planning.successCriteria) : null,
+            ":key_risks": planning.keyRisks ? JSON.stringify(planning.keyRisks) : null,
+            ":proof_strategy": planning.proofStrategy ? JSON.stringify(planning.proofStrategy) : null,
+            ":verification_contract": planning.verificationContract ?? null,
+            ":verification_integration": planning.verificationIntegration ?? null,
+            ":verification_operational": planning.verificationOperational ?? null,
+            ":verification_uat": planning.verificationUat ?? null,
+            ":definition_of_done": planning.definitionOfDone ? JSON.stringify(planning.definitionOfDone) : null,
+            ":requirement_coverage": planning.requirementCoverage ?? null,
+            ":boundary_map_markdown": planning.boundaryMapMarkdown ?? null,
+        });
+        const finalTitle = planning.title?.trim();
+        if (finalTitle)
+            reconcileMilestonePhaseArtifactPaths(milestoneId, finalTitle);
     });
 }
 export function insertSlice(s) {

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

@@ -48,8 +48,9 @@ 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" },
+    { id: "gpt-5.6-sol", inputPer1k: 0.005, outputPer1k: 0.03, tiers: [{ inputTokensAbove: 272000, inputPer1k: 0.01, outputPer1k: 0.045 }], updatedAt: "2026-07-11" },
+    { id: "gpt-5.6-terra", inputPer1k: 0.0025, outputPer1k: 0.015, tiers: [{ inputTokensAbove: 272000, inputPer1k: 0.005, outputPer1k: 0.0225 }], updatedAt: "2026-07-11" },
+    { id: "gpt-5.6-luna", inputPer1k: 0.001, outputPer1k: 0.006, tiers: [{ inputTokensAbove: 272000, inputPer1k: 0.002, outputPer1k: 0.009 }], updatedAt: "2026-07-11" },
     // 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" },
@@ -63,7 +64,9 @@ export const BUNDLED_COST_TABLE = [
 export function lookupModelCost(modelId) {
     const bareId = modelId.includes("/") ? modelId.split("/").pop() : modelId;
     return BUNDLED_COST_TABLE.find(e => e.id === bareId)
-        ?? BUNDLED_COST_TABLE.find(e => bareId.includes(e.id) || e.id.includes(bareId));
+        ?? BUNDLED_COST_TABLE.find(e => bareId.startsWith(`${e.id}-`) ||
+            bareId.startsWith(`${e.id}:`) ||
+            bareId.startsWith(`${e.id}@`));
 }
 /**
  * Compare two models by input cost. Returns negative if a is cheaper.

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

@@ -46,7 +46,9 @@ export const MODEL_CAPABILITY_TIER = {
     "gpt-5.3-codex": "heavy",
     "gpt-5.4": "heavy",
     "gpt-5.5": "heavy",
-    "gpt-5.6": "heavy",
+    "gpt-5.6-sol": "heavy",
+    "gpt-5.6-terra": "heavy",
+    "gpt-5.6-luna": "heavy",
     "o1": "heavy",
     "o3": "heavy",
     "o4-mini": "heavy",
@@ -84,7 +86,9 @@ 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,
+    "gpt-5.6-sol": 0.005,
+    "gpt-5.6-terra": 0.0025,
+    "gpt-5.6-luna": 0.001,
     "o4-mini": 0.005,
     "o4-mini-deep-research": 0.005,
     "gemini-2.0-flash": 0.0001,
@@ -132,9 +136,10 @@ 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 },
+    // GPT-5.6 profiles are provisional until official eval results are available.
+    "gpt-5.6-sol": { coding: 97, debugging: 94, research: 90, reasoning: 96, speed: 42, longContext: 91, instruction: 94 },
+    "gpt-5.6-terra": { coding: 96, debugging: 93, research: 89, reasoning: 95, speed: 48, longContext: 91, instruction: 93 },
+    "gpt-5.6-luna": { coding: 92, debugging: 88, research: 84, reasoning: 91, speed: 72, longContext: 91, instruction: 90 },
     // ── 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 },

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

@@ -16,10 +16,18 @@ const PLANNING_DISPATCH_AGENT_REGISTRY = {
 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) {
+function configuredPlanningDispatchAgents(registry) {
+    return Object.entries(registry ?? {})
+        .filter(([, metadata]) => metadata.read_only_specialist === true)
+        .map(([agentId]) => agentId);
+}
+export function isReadOnlyPlanningDispatchAgent(agentId, registry) {
     const metadata = PLANNING_DISPATCH_AGENT_REGISTRY[agentId];
-    return metadata?.readOnlySpecialist === true;
+    return metadata?.readOnlySpecialist === true || registry?.[agentId]?.read_only_specialist === true;
 }
-export function allowedPlanningDispatchAgentsList() {
-    return [...ALLOWED_PLANNING_DISPATCH_AGENTS].join(", ");
+export function allowedPlanningDispatchAgentsList(registry) {
+    return Array.from(new Set([
+        ...ALLOWED_PLANNING_DISPATCH_AGENTS,
+        ...configuredPlanningDispatchAgents(registry),
+    ])).join(", ");
 }

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

@@ -8,10 +8,31 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { getProviders } from "@gsd/pi-ai";
 import { gsdHome } from "./gsd-home.js";
 import { canonicalModelForTier, defaultRoutingConfig, resolveModelForTier } from "./model-router.js";
 import { clearGSDPreferencesCache, loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
 import { getUnitPhaseChain } from "./unit-registry.js";
+/**
+ * First-party providers shipped as bundled extensions that delegate to a
+ * vendor CLI (`authMode: "externalCli"`). They are registered into the live
+ * model registry at runtime, so they are absent from the generated `@gsd/pi-ai`
+ * catalog (`getProviders()`), but they are NOT custom: `PREFERENCES.md` can
+ * route to them, so they must defer to `PREFERENCES.md` like any other built-in
+ * provider. Without this exclusion the registry check below would classify the
+ * default `claude-code` provider (and the other CLI providers) as custom and
+ * silently skip `PREFERENCES.md` in auto-mode (#801, extends #4122).
+ *
+ * Kept in sync with the `registerProvider(...)` calls in the bundled CLI
+ * extensions (claude-code-cli, cursor-cli, google-cli). Names are lowercase for
+ * direct comparison against normalized provider ids.
+ */
+const BUILTIN_EXTENSION_PROVIDERS = new Set([
+    "claude-code",
+    "cursor-agent",
+    "google-gemini-cli",
+    "google-antigravity",
+]);
 /**
  * Resolve which model ID to use for a given auto-mode unit type.
  * Returns undefined if no model preference is set for this unit type.
@@ -281,9 +302,8 @@ export function resolveDefaultSessionModel(sessionProvider, basePath, availableM
     return undefined;
 }
 /**
- * Returns true if `provider` is defined as a custom provider in the user's
- * `~/.gsd/agent/models.json` (Ollama, vLLM, LM Studio, OpenAI-compatible
- * proxies, etc.).
+ * Returns true if `provider` is a custom provider. Custom providers may be
+ * declared in `models.json` or registered dynamically by a Pi extension.
  *
  * Used by auto-mode bootstrap to decide whether the session model
  * (set via `/gsd model`) should override `PREFERENCES.md`.  Custom providers
@@ -292,13 +312,16 @@ export function resolveDefaultSessionModel(sessionProvider, basePath, availableM
  * priority — otherwise auto-mode tries to start the built-in provider from
  * PREFERENCES.md and fails with "Not logged in · Please run /login" (#4122).
  *
- * Reads models.json directly with a lightweight JSON parse to avoid
- * pulling in the full model-registry at this call site.  Falls back to
- * `~/.pi/agent/models.json` for parity with `resolveModelsJsonPath()`.
- * Any read or parse error yields `false` (treat as not-custom) so a
- * malformed models.json never breaks the session bootstrap.
+ * Reads models.json directly with a lightweight JSON parse, then checks the
+ * live model registry for extension-registered providers that are not in the
+ * generated built-in provider catalog (`getProviders()`) and not one of the
+ * bundled external-CLI providers (`BUILTIN_EXTENSION_PROVIDERS`, e.g.
+ * `claude-code`), which register at runtime but are still built-in.  Falls back
+ * to `~/.pi/agent/models.json` for parity with `resolveModelsJsonPath()`. Any
+ * read, parse, or registry error yields `false` (treat as not-custom) so
+ * bootstrap stays non-fatal.
  */
-export function isCustomProvider(provider) {
+export function isCustomProvider(provider, registry) {
     if (!provider)
         return false;
     const candidates = [
@@ -319,7 +342,24 @@ export function isCustomProvider(provider) {
             // Ignore — malformed models.json must not break bootstrap.
         }
     }
-    return false;
+    try {
+        const normalizedProvider = provider.trim().toLowerCase();
+        if (!normalizedProvider)
+            return false;
+        if (BUILTIN_EXTENSION_PROVIDERS.has(normalizedProvider))
+            return false;
+        const builtInProviders = new Set(getProviders().map((p) => p.toLowerCase()));
+        if (builtInProviders.has(normalizedProvider))
+            return false;
+        const registryModels = registry?.getAllWithDiscovered?.()
+            ?? registry?.getAll?.()
+            ?? registry?.getAvailable?.()
+            ?? [];
+        return registryModels.some((m) => m.provider.toLowerCase() === normalizedProvider);
+    }
+    catch {
+        return false;
+    }
 }
 /**
  * Determines the next fallback model to try when the current model fails.

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_subagent_registry",
     "planning_subagents",
     "dynamic_routing",
     "disabled_model_providers",

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

@@ -10,7 +10,7 @@ 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, 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";
+import { allowedPlanningDispatchAgentsList, isReadOnlyPlanningDispatchAgent, } from "./planning-subagent-registry.js";
 const VALID_TOKEN_PROFILES = new Set(["budget", "balanced", "quality", "burn-max"]);
 const VALID_THINKING_LEVELS = new Set([
     "off",
@@ -19,6 +19,7 @@ const VALID_THINKING_LEVELS = new Set([
     "medium",
     "high",
     "xhigh",
+    "max",
 ]);
 const KNOWN_MODEL_PHASE_KEYS = new Set(GSD_MODEL_PHASE_KEYS);
 const VALID_UOK_TURN_ACTIONS = new Set([
@@ -69,7 +70,7 @@ function sanitizeModelField(raw, label, errors, warnings) {
             }
             else {
                 warnings?.push(`${label} thinking "${String(obj.thinking)}" is not a valid thinking level ` +
-                    `(off, minimal, low, medium, high, xhigh) — ignored`);
+                    `(off, minimal, low, medium, high, xhigh, max) — ignored`);
             }
         }
         return sanitized;
@@ -457,7 +458,7 @@ export function validatePreferences(preferences) {
                     const level = entry.thinking;
                     if (level !== undefined && !VALID_THINKING_LEVELS.has(level)) {
                         warnings.push(`models.${phase}.thinking "${String(level)}" is not a valid thinking level ` +
-                            `(off, minimal, low, medium, high, xhigh) — ignored`);
+                            `(off, minimal, low, medium, high, xhigh, max) — ignored`);
                         const { thinking: _ignored, ...rest } = entry;
                         // If stripping the bad thinking leaves no usable model, drop the
                         // phase entirely rather than storing a hollow `{}` / `{ provider }`
@@ -488,7 +489,7 @@ export function validatePreferences(preferences) {
                 }
                 if (!VALID_THINKING_LEVELS.has(level)) {
                     warnings.push(`thinking.${phase} "${String(level)}" is not a valid thinking level ` +
-                        `(off, minimal, low, medium, high, xhigh) — ignored`);
+                        `(off, minimal, low, medium, high, xhigh, max) — ignored`);
                     continue;
                 }
                 validatedThinking[phase] = level;
@@ -728,6 +729,38 @@ export function validatePreferences(preferences) {
             validated.pre_dispatch_hooks = validPreHooks;
         }
     }
+    // ─── Planning Subagent Registry ──────────────────────────────────────────
+    if (preferences.planning_subagent_registry !== undefined) {
+        if (!preferences.planning_subagent_registry ||
+            typeof preferences.planning_subagent_registry !== "object" ||
+            Array.isArray(preferences.planning_subagent_registry)) {
+            errors.push("planning_subagent_registry must be an object keyed by agent id");
+        }
+        else {
+            const validRegistry = {};
+            for (const [rawAgentId, rawConfig] of Object.entries(preferences.planning_subagent_registry)) {
+                const agentId = rawAgentId.trim();
+                if (!agentId) {
+                    errors.push("planning_subagent_registry includes an empty agent id");
+                    continue;
+                }
+                if (!rawConfig || typeof rawConfig !== "object" || Array.isArray(rawConfig)) {
+                    errors.push(`planning_subagent_registry.${agentId} must be an object with read_only_specialist: true`);
+                    continue;
+                }
+                const readOnlySpecialist = rawConfig.read_only_specialist;
+                if (readOnlySpecialist !== true) {
+                    errors.push(`planning_subagent_registry.${agentId}.read_only_specialist must be true to classify ` +
+                        `"${agentId}" as a read-only planning specialist`);
+                    continue;
+                }
+                validRegistry[agentId] = { read_only_specialist: true };
+            }
+            if (Object.keys(validRegistry).length > 0) {
+                validated.planning_subagent_registry = validRegistry;
+            }
+        }
+    }
     // ─── Planning Subagents ─────────────────────────────────────────────────
     if (preferences.planning_subagents !== undefined) {
         if (!preferences.planning_subagents ||
@@ -755,9 +788,11 @@ export function validatePreferences(preferences) {
                 }
                 const sanitizedAllowed = [];
                 for (const agentId of allowed) {
-                    if (!ALLOWED_PLANNING_DISPATCH_AGENTS.has(agentId)) {
+                    if (!isReadOnlyPlanningDispatchAgent(agentId, validated.planning_subagent_registry)) {
                         errors.push(`planning_subagents.${unitType}.allowed includes "${agentId}", which is not classified as a ` +
-                            `read-only planning specialist. Allowed agents: ${allowedPlanningDispatchAgentsList()}`);
+                            `read-only planning specialist. Allowed agents: ` +
+                            `${allowedPlanningDispatchAgentsList(validated.planning_subagent_registry)}. ` +
+                            `For custom planning agents, add planning_subagent_registry.${agentId}.read_only_specialist: true`);
                         continue;
                     }
                     sanitizedAllowed.push(agentId);

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

@@ -635,6 +635,7 @@ function mergePreferences(base, override) {
             : undefined,
         post_unit_hooks: mergePostUnitHooks(base.post_unit_hooks, override.post_unit_hooks),
         pre_dispatch_hooks: mergePreDispatchHooks(base.pre_dispatch_hooks, override.pre_dispatch_hooks),
+        planning_subagent_registry: mergePlanningSubagentRegistry(base.planning_subagent_registry, override.planning_subagent_registry),
         planning_subagents: mergePlanningSubagents(base.planning_subagents, override.planning_subagents),
         dynamic_routing: (base.dynamic_routing || override.dynamic_routing)
             ? { ...(base.dynamic_routing ?? {}), ...(override.dynamic_routing ?? {}) }
@@ -769,6 +770,12 @@ function mergePlanningSubagents(base, override) {
     }
     return Object.keys(merged).length > 0 ? merged : undefined;
 }
+function mergePlanningSubagentRegistry(base, override) {
+    if (!base && !override)
+        return undefined;
+    const merged = { ...(base ?? {}), ...(override ?? {}) };
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
 // ─── System Prompt Rendering ──────────────────────────────────────────────────
 export function renderPreferencesForSystemPrompt(preferences, resolutions, options) {
     const validated = validatePreferences(preferences);

package/dist/resources/extensions/gsd/templates/PREFERENCES.md

@@ -92,6 +92,9 @@ remote_questions:
 uat_dispatch:
 post_unit_hooks: []
 pre_dispatch_hooks: []
+# planning_subagent_registry:
+#   my-custom-planner:
+#     read_only_specialist: true
 # planning_subagents:
 #   plan-milestone:
 #     allowed: [scout, planner, security]

package/dist/resources/extensions/gsd/tools/plan-slice.js

@@ -6,7 +6,7 @@ import { isNonEmptyString, validateStringArray } from "../validation.js";
 import { getGateIdsForTurn } from "../gate-registry.js";
 import { transaction, getMilestone, getSlice, getSliceTasks, insertTask, upsertSlicePlanning, upsertTaskPlanning, insertGateRow, updateSliceStatus, setSliceSketchFlag, deleteTask, deleteArtifactByPath, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
-import { renderPlanFromDb } from "../markdown-renderer.js";
+import { renderPlanCheckboxes, renderPlanFromDb } from "../markdown-renderer.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -371,9 +371,13 @@ export async function handlePlanSlice(rawParams, basePath) {
             deleteArtifactByPath(artifactPath);
         }
         const sliceTasks = getSliceTasks(params.milestoneId, params.sliceId);
+        const hasClosedTasks = sliceTasks.some((task) => isClosedStatus(task.status));
         const renderResult = sliceTasks.length === 0
             ? { planPath: "", taskPlanPaths: [] }
             : await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
+        if (sliceTasks.length > 0 && hasClosedTasks) {
+            await renderPlanCheckboxes(basePath, params.milestoneId, params.sliceId);
+        }
         if (sliceTasks.length > 0) {
             setSliceSketchFlag(params.milestoneId, params.sliceId, false);
         }

package/dist/resources/extensions/gsd/verification-evidence.js

@@ -11,13 +11,14 @@
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 /**
- * Write a T##-VERIFY.json artifact to the tasks directory.
+ * Write a T##-VERIFY.json artifact to the evidence directory.
  * Creates the directory with mkdirSync({ recursive: true }) if it doesn't exist.
+ * Flat-phase callers can pass sliceId to write S##-T##-VERIFY.json.
  *
  * stdout/stderr are excluded from the JSON — the full output lives in VerificationResult
  * in memory and is logged to stderr during the gate run.
  */
-export function writeVerificationJSON(result, tasksDir, taskId, unitId, retryAttempt, maxRetries) {
+export function writeVerificationJSON(result, tasksDir, taskId, unitId, retryAttempt, maxRetries, sliceId) {
     mkdirSync(tasksDir, { recursive: true });
     const evidence = {
         schemaVersion: 1,
@@ -52,7 +53,8 @@ export function writeVerificationJSON(result, tasksDir, taskId, unitId, retryAtt
             fixAvailable: w.fixAvailable,
         }));
     }
-    const filePath = join(tasksDir, `${taskId}-VERIFY.json`);
+    const fileName = sliceId ? `${sliceId}-${taskId}-VERIFY.json` : `${taskId}-VERIFY.json`;
+    const filePath = join(tasksDir, fileName);
     writeFileSync(filePath, JSON.stringify(evidence, null, 2) + "\n", "utf-8");
 }
 /**

package/dist/resources/extensions/gsd/worktree-state-projection.js

@@ -21,7 +21,7 @@
 import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, statSync, unlinkSync, } from "node:fs";
 import { join } from "node:path";
 import { reconcileWorktreeDb } from "./gsd-db.js";
-import { resolveGsdPathContract } from "./paths.js";
+import { dirIsContentBearingLegacyMilestone, resolveGsdPathContract } from "./paths.js";
 import { safeCopy, safeCopyRecursive } from "./safe-fs.js";
 import { logError, logWarning } from "./workflow-logger.js";
 // ─── Private helpers ──────────────────────────────────────────────────────
@@ -129,6 +129,8 @@ function syncOtherMilestoneArtifacts(srcMilestonesDir, dstMilestonesDir, current
             if (milestoneEntry.name === currentMilestoneId)
                 continue;
             const srcMilestoneDir = join(srcMilestonesDir, milestoneEntry.name);
+            if (!dirIsContentBearingLegacyMilestone(srcMilestoneDir))
+                continue;
             const dstMilestoneDir = join(dstMilestonesDir, milestoneEntry.name);
             // Additively project the entire milestone subtree (force:false), not just
             // top-level files. Prior completed milestones keep their per-slice and
@@ -219,25 +221,25 @@ export function _projectRootToWorktreeImpl(projectRoot, worktreePath_, milestone
     // Without this, worktree-local files (e.g. VALIDATION.md written
     // by validate-milestone) get clobbered by stale project root copies,
     // causing an infinite re-validation loop (#1886).
-    safeCopyRecursive(join(prGsd, "milestones", milestoneId), join(wtGsd, "milestones", milestoneId), { force: false });
-    // Additively project the full subtree of every OTHER milestone so
-    // worktree-bound units can read prior-milestone context artifacts and so
-    // completed milestones retain their per-slice/per-task SUMMARY.md and
-    // UAT.md on the worktree filesystem (otherwise the stale-render detector
-    // flags them as "complete in DB but missing on disk").
-    syncOtherMilestoneArtifacts(join(prGsd, "milestones"), join(wtGsd, "milestones"), milestoneId);
-    // Force-sync ASSESSMENT files that have a verdict from project root (#2821).
-    // The additive-only copy above preserves worktree-local files, but
-    // ASSESSMENT files are special: after run-uat writes a verdict and post-unit
-    // syncs it to the project root, the worktree may retain a stale copy (e.g.
-    // verdict:fail while the project root has verdict:pass from a retry). On
-    // session resume the DB is rebuilt from disk, and if the stale ASSESSMENT
-    // persists, checkNeedsRunUat finds no passing verdict → re-dispatches
-    // run-uat indefinitely (stuck-loop ×9).
     const prMilestoneDir = join(prGsd, "milestones", milestoneId);
     const wtMilestoneDir = join(wtGsd, "milestones", milestoneId);
-    forceOverwriteValidationWithVerdict(prMilestoneDir, wtMilestoneDir, milestoneId);
-    forceOverwriteAssessmentsWithVerdict(prMilestoneDir, wtMilestoneDir);
+    if (dirIsContentBearingLegacyMilestone(prMilestoneDir)) {
+        safeCopyRecursive(prMilestoneDir, wtMilestoneDir, { force: false });
+        // Force-sync ASSESSMENT files that have a verdict from project root (#2821).
+        // The additive-only copy above preserves worktree-local files, but
+        // ASSESSMENT files are special: after run-uat writes a verdict and post-unit
+        // syncs it to the project root, the worktree may retain a stale copy (e.g.
+        // verdict:fail while the project root has verdict:pass from a retry). On
+        // session resume the DB is rebuilt from disk, and if the stale ASSESSMENT
+        // persists, checkNeedsRunUat finds no passing verdict → re-dispatches
+        // run-uat indefinitely (stuck-loop ×9).
+        forceOverwriteValidationWithVerdict(prMilestoneDir, wtMilestoneDir, milestoneId);
+        forceOverwriteAssessmentsWithVerdict(prMilestoneDir, wtMilestoneDir);
+    }
+    // Additively project the full subtree of every OTHER content-bearing legacy
+    // milestone so worktree-bound units can read prior-milestone context artifacts
+    // without recreating empty/meta-only milestones/ scaffolds in flat-phase projects.
+    syncOtherMilestoneArtifacts(join(prGsd, "milestones"), join(wtGsd, "milestones"), milestoneId);
     // Forward-sync completed-units.json from project root to worktree.
     // Project root is authoritative for completion state after crash recovery;
     // without this, the worktree re-dispatches already-completed units (#1886).

package/dist/resources/extensions/ollama/ollama-chat-provider.js

@@ -160,7 +160,7 @@ export function streamOllamaChat(model, context, options) {
  * - `"low" | "medium" | "high"` are passed through as strings; gpt-oss honors
  *   them as strength levels, other thinking models treat any present value
  *   as "thinking enabled".
- * - `"xhigh"` is collapsed to `"high"` (ollama caps strength at high).
+ * - `"xhigh"` and `"max"` are collapsed to `"high"` (ollama caps strength at high).
  */
 export function buildThinkParam(model, options) {
     if (!model.reasoning)
@@ -170,7 +170,7 @@ export function buildThinkParam(model, options) {
         return undefined;
     if (level === "minimal")
         return false;
-    if (level === "xhigh")
+    if (level === "xhigh" || level === "max")
         return "high";
     return level;
 }

package/dist/resources/extensions/subagent/index.js

@@ -591,7 +591,7 @@ thinkingOverride) {
             }
     }
 }
-const ThinkingLevelSchema = StringEnum(["off", "minimal", "low", "medium", "high", "xhigh"], {
+const ThinkingLevelSchema = StringEnum(["off", "minimal", "low", "medium", "high", "xhigh", "max"], {
     description: "Reasoning effort override for the subagent (forwarded as --thinking). " +
         "Independent of model choice; unsupported levels are clamped to the model at dispatch.",
 });

package/dist/startup-model-validation.d.ts

@@ -15,7 +15,7 @@ interface MinimalModel {
 interface MinimalModelRegistry {
     getAvailable(): MinimalModel[];
 }
-type ThinkingLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+type ThinkingLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
 interface MinimalSettingsManager {
     getDefaultProvider(): string | undefined;
     getDefaultModel(): string | undefined;