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

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,8 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "git",
     "post_unit_hooks",
     "pre_dispatch_hooks",
+    "planning_subagent_registry",
+    "planning_subagents",
     "dynamic_routing",
     "disabled_model_providers",
     "uok",
@@ -134,6 +136,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 { 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",
@@ -18,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([
@@ -68,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;
@@ -456,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 }`
@@ -487,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;
@@ -727,6 +729,86 @@ 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 ||
+            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 (!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(validated.planning_subagent_registry)}. ` +
+                            `For custom planning agents, add planning_subagent_registry.${agentId}.read_only_specialist: true`);
+                        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) {

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

@@ -635,6 +635,8 @@ 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 ?? {}) }
             : undefined,
@@ -752,6 +754,28 @@ function mergePreDispatchHooks(base, override) {
     }
     return merged.length > 0 ? merged : undefined;
 }
+function mergePlanningSubagents(base, override) {
+    if (!base && !override)
+        return undefined;
+    const merged = {};
+    const unitTypes = new Set([
+        ...Object.keys(base ?? {}),
+        ...Object.keys(override ?? {}),
+    ]);
+    for (const unitType of unitTypes) {
+        const allowed = mergeStringLists(base?.[unitType]?.allowed, override?.[unitType]?.allowed);
+        if (allowed?.length) {
+            merged[unitType] = { allowed };
+        }
+    }
+    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/prompts/validate-milestone.md

@@ -24,18 +24,18 @@ Roadmap, slice summaries, assessments, requirements, decisions, and project cont
 
 ### Step 1 - Dispatch Parallel Reviewers
 
-The Inlined Context above already preloads the evidence reviewers need — the roadmap, per-slice SUMMARY/ASSESSMENT excerpts, requirements, and verification classes. **Embed the relevant preloaded evidence directly into each reviewer's task prompt** so reviewers work from it instead of re-reading the same artifacts from disk. Each reviewer should read a full file only when its excerpt is missing, truncated, or internally inconsistent — never as a routine first step. This avoids three reviewers independently re-surveying artifacts the orchestrator already holds.
+The Inlined Context above already preloads the evidence reviewers need — the roadmap, per-slice SUMMARY/ASSESSMENT excerpts, requirements, and verification classes. **Embed the relevant preloaded evidence directly into each reviewer's task prompt** so reviewers work from it instead of re-reading the same artifacts from disk. Each reviewer should read a full file only when its excerpt is missing, truncated, or internally inconsistent — never as a routine first step. When a reviewer needs a full artifact, use only explicit file paths from the On-demand Validation Artifacts / On-demand Milestone Context blocks or discover files with `find .gsd -type f`; never pass a phase, slice, `tasks/`, or `slices/` directory to `read` or `readFileSync`. This avoids three reviewers independently re-surveying artifacts the orchestrator already holds.
 
 Call `subagent` with `tasks: [...]` containing ALL THREE reviewers simultaneously:
 
 **Reviewer A - Requirements Coverage**
-Prompt: "Review milestone {{milestoneId}} requirements coverage. Working directory: {{workingDirectory}}. Use the preloaded requirements and slice SUMMARY evidence embedded in this task — do not re-read them from disk. For each requirement, mark COVERED, PARTIAL, or MISSING against that evidence. Read a full SUMMARY under `.gsd/milestones/{{milestoneId}}/slices/` only if its preloaded excerpt is missing, truncated, or inconsistent. Output table: Requirement | Status | Evidence. End with one-line verdict: PASS if all covered, NEEDS-ATTENTION if partials exist, FAIL if any missing."
+Prompt: "Review milestone {{milestoneId}} requirements coverage. Working directory: {{workingDirectory}}. Use the preloaded requirements and slice SUMMARY evidence embedded in this task — do not re-read them from disk. For each requirement, mark COVERED, PARTIAL, or MISSING against that evidence. Read a full SUMMARY only from an explicit file path in the On-demand Validation Artifacts list, or discover candidates with `find .gsd -type f -name '*-SUMMARY.md'`; never read a directory path. Output table: Requirement | Status | Evidence. End with one-line verdict: PASS if all covered, NEEDS-ATTENTION if partials exist, FAIL if any missing."
 
 **Reviewer B - Cross-Slice Integration**
-Prompt: "Review milestone {{milestoneId}} cross-slice integration. Working directory: {{workingDirectory}}. Use the preloaded roadmap and slice SUMMARY evidence embedded in this task — do not re-read them from disk. Find the boundary map (produces/consumes contracts) in the roadmap. For each boundary, confirm producer SUMMARY produced the artifact and consumer SUMMARY consumed it. Read `{{roadmapPath}}` or a full SUMMARY only if the preloaded evidence is missing, truncated, or inconsistent. Output table: Boundary | Producer Summary | Consumer Summary | Status. End with one-line verdict: PASS if all boundaries honored, NEEDS-ATTENTION if any gaps."
+Prompt: "Review milestone {{milestoneId}} cross-slice integration. Working directory: {{workingDirectory}}. Use the preloaded roadmap and slice SUMMARY evidence embedded in this task — do not re-read them from disk. Find the boundary map (produces/consumes contracts) in the roadmap. For each boundary, confirm producer SUMMARY produced the artifact and consumer SUMMARY consumed it. Read `{{roadmapPath}}` or a full SUMMARY from the On-demand Validation Artifacts list only if the preloaded evidence is missing, truncated, or inconsistent; never read a directory path. Output table: Boundary | Producer Summary | Consumer Summary | Status. End with one-line verdict: PASS if all boundaries honored, NEEDS-ATTENTION if any gaps."
 
 **Reviewer C - Assessment & Acceptance Criteria**
-Prompt: "Review milestone {{milestoneId}} assessment evidence and acceptance criteria. Working directory: {{workingDirectory}}. Use the preloaded milestone context, slice SUMMARY, and ASSESSMENT evidence embedded in this task — do not re-read them from disk. Read `.gsd/milestones/{{milestoneId}}/{{milestoneId}}-CONTEXT.md`, a full SUMMARY, or a full ASSESSMENT only if the preloaded excerpt is missing, truncated, or inconsistent. UAT files are specs, not evidence. Verify each criterion maps to passing evidence. Then review the inlined `Verification Classes (from planning)` table. For every planned row in that table, output a `Verification Classes` table with columns `Class | Planned Check | Evidence | Verdict`. Preserve every planned non-empty class row; do not summarize, rename, combine, or omit planned classes. The first cell of each row must be exactly `Contract`, `Integration`, `Operational`, or `UAT` when that class is present in planning. If a planned class lacks evidence, still include its canonical row and mark the verdict NEEDS-ATTENTION or FAIL. If a planned browser/UAT class has no ASSESSMENT with browser/runtime actions and assertions, return NEEDS-ATTENTION. If no verification classes were planned, say that explicitly. Output sections `Acceptance Criteria` with checklist `[ ] Criterion | Evidence`, and `Verification Classes` with the table. End with one-line verdict: PASS if all criteria and classes are covered by evidence, NEEDS-ATTENTION if gaps exist."
+Prompt: "Review milestone {{milestoneId}} assessment evidence and acceptance criteria. Working directory: {{workingDirectory}}. Use the preloaded milestone context, slice SUMMARY, and ASSESSMENT evidence embedded in this task — do not re-read them from disk. Read the milestone context from the On-demand Milestone Context file path, and read full SUMMARY or ASSESSMENT files only from explicit paths in the On-demand Validation Artifacts list, if the preloaded excerpt is missing, truncated, or inconsistent. UAT files are specs, not evidence. Verify each criterion maps to passing evidence. Then review the inlined `Verification Classes (from planning)` table. For every planned row in that table, output a `Verification Classes` table with columns `Class | Planned Check | Evidence | Verdict`. Preserve every planned non-empty class row; do not summarize, rename, combine, or omit planned classes. The first cell of each row must be exactly `Contract`, `Integration`, `Operational`, or `UAT` when that class is present in planning. If a planned class lacks evidence, still include its canonical row and mark the verdict NEEDS-ATTENTION or FAIL. If a planned browser/UAT class has no ASSESSMENT with browser/runtime actions and assertions, return NEEDS-ATTENTION. If no verification classes were planned, say that explicitly. Output sections `Acceptance Criteria` with checklist `[ ] Criterion | Evidence`, and `Verification Classes` with the table. End with one-line verdict: PASS if all criteria and classes are covered by evidence, NEEDS-ATTENTION if gaps exist."
 
 ### Step 2 - Synthesize Findings
 
@@ -85,6 +85,6 @@ If verdict is `needs-remediation`:
 
 **You MUST call `gsd_validate_milestone` before finishing. Do not manually write `{{validationPath}}`.**
 
-**File system safety:** When scanning milestone directories, use `ls` or `find` first. Never pass a directory path such as `tasks/` or `slices/` directly to `read`; it only accepts files.
+**File system safety:** When scanning milestone directories, use `find .gsd -type f` first and read only files. In flat-phase projects, `.gsd/phases/<NN>-<slug>/` is a directory, not an artifact. Never pass a directory path such as a phase directory, `tasks/`, or `slices/` directly to `read`, `readFile`, or `readFileSync`.
 
 When done, say: "Milestone {{milestoneId}} validation complete — verdict: <verdict>." Say this exactly once — if you already said it in a prior message, do not repeat it.

package/dist/resources/extensions/gsd/provider-payload-policy.js

@@ -2,12 +2,14 @@
  * Provider Payload Policy - ordered shaping of provider request payloads.
  *
  * The order is intentional:
- * 1. observation budgeting masks old tool results in auto-mode,
- * 2. display truncation caps tool-result text for every mode,
- * 3. the protected Source Context Block is appended after truncation,
- * 4. supported models receive the configured service tier.
+ * 1. superseded GSD context injections (memory/guided/forensics) are removed,
+ *    keeping only the latest, for every mode,
+ * 2. observation budgeting masks old tool results in auto-mode,
+ * 3. display truncation caps tool-result text for every mode,
+ * 4. the protected Source Context Block is appended after truncation,
+ * 5. supported models receive the configured service tier.
  */
-import { createObservationMask, createResponsesInputObservationMask, truncateContextResultMessages, truncateResponsesInputResultItems, } from "./context-masker.js";
+import { createObservationMask, createResponsesInputObservationMask, filterSupersededContextInjections, filterSupersededResponsesContextInjections, truncateContextResultMessages, truncateResponsesInputResultItems, } from "./context-masker.js";
 import { getSourceObservationStore, isAutoActive } from "./auto-runtime-state.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { getEffectiveServiceTier, supportsServiceTier } from "./service-tier.js";
@@ -42,9 +44,18 @@ export function applyProviderPayloadPolicy({ payload, modelId, deps: overrides,
 }
 function applyContextManagement(payload, deps) {
     const config = deps.loadContextManagementConfig();
+    applyContextInjectionFilter(payload);
     applyObservationBudget(payload, config, deps.isAutoActive());
     applyDisplayTruncation(payload, config);
 }
+function applyContextInjectionFilter(payload) {
+    if (Array.isArray(payload.messages)) {
+        payload.messages = filterSupersededContextInjections(payload.messages);
+    }
+    if (Array.isArray(payload.input)) {
+        payload.input = filterSupersededResponsesContextInjections(payload.input);
+    }
+}
 function applyObservationBudget(payload, config, autoActive) {
     if (!autoActive || config?.observation_masking === false)
         return;

package/dist/resources/extensions/gsd/safety/destructive-guard.js

@@ -6,7 +6,7 @@
  * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
  */
 const DESTRUCTIVE_PATTERNS = [
-    { pattern: /\brm\s+(-[^\s]*[rfRF][^\s]*\s+|.*\s+-[^\s]*[rfRF])/, label: "recursive delete" },
+    { pattern: /\brm\s+((?:-(?!-)[^\s]*[rR][^\s]*|--recursive)\s+|.*\s+(?:-(?!-)[^\s]*[rR][^\s]*|--recursive)(?:\s|$))/, label: "recursive delete" },
     { pattern: /\bgit\s+push\s+.*--force/, label: "force push" },
     { pattern: /\bgit\s+push\s+-f\b/, label: "force push" },
     { pattern: /\bgit\s+reset\s+--hard/, label: "hard reset" },

package/dist/resources/extensions/gsd/skill-activation.js

@@ -104,11 +104,24 @@ function resolvePreferredSkillNames(prefs, visibleSkills, contextTokens, base) {
 /** Skill names must be lowercase alphanumeric with hyphens — reject anything else
  *  to prevent prompt injection via crafted directory names. */
 const SAFE_SKILL_NAME = /^[a-z0-9][a-z0-9-]*$/;
-function formatSkillActivationBlock(skillNames) {
+function escapeXml(str) {
+    return str
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+function formatSkillActivationBlock(skillNames, skillPaths) {
     const safe = skillNames.filter(name => SAFE_SKILL_NAME.test(name));
     if (safe.length === 0)
         return "";
-    const reads = safe.map(name => `Read the installed '${name}' skill file from <available_skills>`).join(". ");
+    const reads = safe.map(name => {
+        const path = skillPaths.get(name);
+        if (path)
+            return `Read the skill file at \`${escapeXml(path)}\``;
+        return `Find '${name}' in <available_skills>, copy its <location> value, and pass that exact path to read`;
+    }).join(". ");
     return `<skill_activation>${reads}.</skill_activation>`;
 }
 /**
@@ -149,6 +162,7 @@ export function buildSkillActivationBlock(params) {
     const visibleSkills = loaded;
     const manifestScopedSkills = filterSkillsByManifest(visibleSkills, params.unitType);
     const installedNames = new Set(visibleSkills.map(skill => normalizeSkillReference(skill.name)));
+    const installedSkillPaths = new Map(visibleSkills.map(skill => [normalizeSkillReference(skill.name), skill.filePath]));
     warnIfManifestHasMissingSkills(params.unitType, installedNames);
     const avoided = new Set(resolvePreferenceSkillNames(prefs?.avoid_skills ?? [], params.base));
     const matched = new Set();
@@ -196,7 +210,7 @@ export function buildSkillActivationBlock(params) {
     const ordered = [...matched]
         .filter(name => installedNames.has(name) && !avoided.has(name))
         .sort();
-    const activationBlock = formatSkillActivationBlock(ordered);
+    const activationBlock = formatSkillActivationBlock(ordered, installedSkillPaths);
     // Omit recommendations when the system catalog is manifest-scoped for this
     // unit — skill names are already listed in <available_skills>.
     let recommendationsBlock = "";

package/dist/resources/extensions/gsd/state-reconciliation/drift/external-markdown-edit.js

@@ -8,9 +8,81 @@
 // renderAllFromDb pass re-projects; the write-time invalidation hook then
 // refreshes the marker entry, closing the loop.
 import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { computeProjectionSha, readCompatMarker, writeCompatMarker, } from "../../compat/compat-marker.js";
+import { _getAdapter } from "../../gsd-db.js";
 import { logWarning } from "../../workflow-logger.js";
+function deepestProjectionScope(entities) {
+    let best = null;
+    for (const entity of entities) {
+        const parts = entity.split("/").filter(Boolean);
+        if (parts.length === 0)
+            continue;
+        if (!best || parts.length > best.length)
+            best = parts;
+    }
+    if (!best)
+        return null;
+    return {
+        milestoneId: best[0],
+        sliceId: best[1] ?? null,
+        taskId: best[2] ?? null,
+    };
+}
+function artifactTypeFromProjectionPath(projectionPath) {
+    const name = basename(projectionPath);
+    const match = name.match(/^(?:[A-Za-z]\d+|\d+(?:-\d+)?)-(.+)\.md$/);
+    return match?.[1]?.toUpperCase() ?? null;
+}
+function dbProjectionMatches(projectionPath, entry, actualSha) {
+    const adapter = _getAdapter();
+    if (!adapter)
+        return false;
+    try {
+        const rows = adapter
+            .prepare("SELECT full_content FROM artifacts WHERE path = :path")
+            .all({ ":path": projectionPath });
+        const scope = deepestProjectionScope(entry.entities);
+        const artifactType = artifactTypeFromProjectionPath(projectionPath);
+        if (scope?.taskId) {
+            rows.push(...adapter
+                .prepare(`SELECT full_content
+             FROM artifacts
+             WHERE milestone_id = :mid AND slice_id = :sid AND task_id = :tid
+               AND (:type IS NULL OR artifact_type = :type)`)
+                .all({
+                ":mid": scope.milestoneId,
+                ":sid": scope.sliceId,
+                ":tid": scope.taskId,
+                ":type": artifactType,
+            }));
+        }
+        else if (scope?.sliceId) {
+            rows.push(...adapter
+                .prepare(`SELECT full_content
+             FROM artifacts
+             WHERE milestone_id = :mid AND slice_id = :sid AND task_id IS NULL
+               AND (:type IS NULL OR artifact_type = :type)`)
+                .all({
+                ":mid": scope.milestoneId,
+                ":sid": scope.sliceId,
+                ":type": artifactType,
+            }));
+        }
+        else if (scope) {
+            rows.push(...adapter
+                .prepare(`SELECT full_content
+             FROM artifacts
+             WHERE milestone_id = :mid AND slice_id IS NULL AND task_id IS NULL
+               AND (:type IS NULL OR artifact_type = :type)`)
+                .all({ ":mid": scope.milestoneId, ":type": artifactType }));
+        }
+        return rows.some((row) => computeProjectionSha(row.full_content) === actualSha);
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Detect sha drift between the marker baseline and current file contents.
  *
@@ -21,11 +93,15 @@ import { logWarning } from "../../workflow-logger.js";
  * - Sha mismatch → one record per drifted file, scoped to its recorded entities.
  */
 function detectExternalMarkdownEdit(_state, ctx) {
-    const marker = readCompatMarker(ctx.basePath);
+    const marker = readCompatMarker(ctx.basePath, {
+        healInvalidKeys: !ctx.dryRun,
+        quarantineInvalid: !ctx.dryRun,
+    });
     const entries = Object.entries(marker.projections);
     if (entries.length === 0)
         return [];
     const records = [];
+    let markerChanged = false;
     for (const [projectionPath, entry] of entries) {
         const abs = join(ctx.basePath, ".gsd", projectionPath);
         if (!existsSync(abs))
@@ -33,6 +109,21 @@ function detectExternalMarkdownEdit(_state, ctx) {
         const actual = computeProjectionSha(readFileSync(abs, "utf-8"));
         if (actual === entry.sha)
             continue;
+        if (dbProjectionMatches(projectionPath, entry, actual)) {
+            if (!ctx.dryRun) {
+                marker.projections[projectionPath] = {
+                    sha: actual,
+                    entities: entry.entities,
+                };
+                markerChanged = true;
+                logWarning("reconcile", `external-markdown-edit: refreshed stale compat marker for ${projectionPath} (expectedSha=${entry.sha}, actualSha=${actual})`);
+            }
+            else {
+                logWarning("reconcile", `external-markdown-edit: stale compat marker for ${projectionPath} (expectedSha=${entry.sha}, actualSha=${actual})`);
+            }
+            continue;
+        }
+        logWarning("reconcile", `external-markdown-edit drift for ${projectionPath} (expectedSha=${entry.sha}, actualSha=${actual})`);
         records.push({
             kind: "external-markdown-edit",
             projectionPath,
@@ -41,6 +132,11 @@ function detectExternalMarkdownEdit(_state, ctx) {
             entities: entry.entities,
         });
     }
+    if (markerChanged) {
+        marker.lastWriter = "gsd-pi";
+        marker.lastProjectedAt = new Date().toISOString();
+        writeCompatMarker(ctx.basePath, marker);
+    }
     return records;
 }
 /**

package/dist/resources/extensions/gsd/state-reconciliation/drift/external-planning-edit.js

@@ -55,7 +55,10 @@ function detectUnseededPlanningFiles(ctx, projections, passthrough) {
     return records;
 }
 async function detectExternalPlanningEdit(_state, ctx) {
-    const marker = readCompatMarker(ctx.basePath);
+    const marker = readCompatMarker(ctx.basePath, {
+        healInvalidKeys: !ctx.dryRun,
+        quarantineInvalid: !ctx.dryRun,
+    });
     if (!marker.planning?.active) {
         // Not yet activated. Activation (layout parse + DB import) is owned by
         // capturePlanningCompatIfNeeded, called from reconcileBeforeDispatch when

package/dist/resources/extensions/gsd/state-reconciliation/drift/roadmap.js

@@ -9,7 +9,7 @@ import { renderRoadmapFromDb } from "../../markdown-renderer.js";
 import { findMilestoneIds } from "../../milestone-ids.js";
 import { parseRoadmap } from "../../parsers-legacy.js";
 import { resolveMilestoneFile } from "../../paths.js";
-import { isClosedStatus } from "../../status-guards.js";
+import { isClosedStatus, isSkippedForDispatch } from "../../status-guards.js";
 function arraysEqual(a, b) {
     if (a.length !== b.length)
         return false;
@@ -76,7 +76,10 @@ export function detectRoadmapDivergenceDrift(_state, ctx) {
     for (const milestoneId of findMilestoneIds(ctx.basePath)) {
         // Skip milestones that don't yet have a DB row — that's the
         // unregistered-milestone drift handler's responsibility.
-        if (!getMilestone(milestoneId))
+        const milestone = getMilestone(milestoneId);
+        if (!milestone)
+            continue;
+        if (isSkippedForDispatch(milestone.status))
             continue;
         if (milestoneHasDivergence(ctx.basePath, milestoneId)) {
             drifts.push({ kind: "roadmap-divergence", milestoneId });

package/dist/resources/extensions/gsd/stop-notice.js

@@ -22,6 +22,12 @@ export function formatStopNoticePrefix(reason) {
     const prefix = stopNoticeKind(reason) === "blocked" ? "Auto-mode blocked" : "Auto-mode stopped";
     return displayReason ? `${prefix} — ${displayReason}` : prefix;
 }
+export function formatVerdictRecordedNotice(message) {
+    return `Verdict recorded: ${message}`;
+}
+export function formatVerdictRejectedNotice(message) {
+    return `Verdict rejected: ${message}`;
+}
 // ─── Classification (headless host side) ────────────────────────────────
 // The canonical lowercase prefixes the headless event loop recognizes in
 // notify messages. Emitters above and ad-hoc emitters elsewhere must start
@@ -33,6 +39,8 @@ export const TERMINAL_NOTICE_PREFIXES = [
     "auto-mode complete",
     "no active milestone",
     "auto-mode idle",
+    "verdict recorded",
+    "verdict rejected",
 ];
 /** Manual-resolution notices emitted before auto-mode can formally pause/stop. */
 export function isManualResolutionNotice(message) {
@@ -65,6 +73,7 @@ export function isInteractiveMenuUnavailableNotice(message) {
 }
 export function isBlockedNoticeMessage(message) {
     return (message.includes("blocked:") ||
+        message.startsWith("verdict rejected") ||
         (isPauseNotice(message) && !isNonBlockingPauseNotice(message)) ||
         isManualResolutionNotice(message) ||
         isInteractiveMenuUnavailableNotice(message));

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

@@ -92,6 +92,14 @@ 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]
+#   plan-slice:
+#     allowed: [scout, planner, reviewer, security]
 # language:
 # experimental:
 #   rtk: false