@opengsd/gsd-pi 1.10.0 → 1.11.0

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/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;