gsd-pi 2.77.0-dev.eaa4973bc → 2.78.0-dev.aeeb2ca00

package/dist/resources/extensions/gsd/component-loader.js

@@ -0,0 +1,447 @@
+/**
+ * Component Loader
+ *
+ * Multi-format loader that handles:
+ * 1. New format: component.yaml + SKILL.md/AGENT.md
+ * 2. Legacy skill format: SKILL.md with YAML frontmatter
+ * 3. Legacy agent format: .md with YAML frontmatter (name, description, tools, model)
+ *
+ * Auto-detects format by checking for component.yaml first, then falling back
+ * to legacy formats based on file naming conventions.
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { parseFrontmatter } from '@gsd/pi-coding-agent';
+import { validateComponentName, validateComponentDescription, computeComponentId, } from './component-types.js';
+const SUPPORTED_COMPONENT_KINDS = ['skill', 'agent'];
+const SUPPORTED_API_VERSIONS = ['gsd/v1'];
+// ============================================================================
+// Single Component Loading
+// ============================================================================
+/**
+ * Load a component from a directory.
+ * Checks for component.yaml first, then legacy formats.
+ */
+export function loadComponentFromDir(dir, source) {
+    const diagnostics = [];
+    // Try new format first: component.yaml
+    const componentYamlPath = join(dir, 'component.yaml');
+    if (existsSync(componentYamlPath)) {
+        return loadFromComponentYaml(componentYamlPath, dir, source);
+    }
+    // Try legacy skill format: SKILL.md
+    const skillMdPath = join(dir, 'SKILL.md');
+    if (existsSync(skillMdPath)) {
+        return loadFromLegacySkill(skillMdPath, dir, source);
+    }
+    // No recognized component format found
+    return { component: null, diagnostics };
+}
+/**
+ * Load a component from a legacy agent .md file (flat file, not directory).
+ */
+export function loadComponentFromAgentFile(filePath, source) {
+    return loadFromLegacyAgent(filePath, source);
+}
+// ============================================================================
+// New Format: component.yaml
+// ============================================================================
+function loadFromComponentYaml(yamlPath, dir, source) {
+    const diagnostics = [];
+    let raw;
+    try {
+        raw = readFileSync(yamlPath, 'utf-8');
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : 'failed to read component.yaml';
+        diagnostics.push({ type: 'error', message: msg, path: yamlPath });
+        return { component: null, diagnostics };
+    }
+    let definition;
+    try {
+        definition = parseYaml(raw);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : 'failed to parse component.yaml';
+        diagnostics.push({ type: 'error', message: `invalid YAML: ${msg}`, path: yamlPath });
+        return { component: null, diagnostics };
+    }
+    // Validate required fields
+    if (!definition?.apiVersion) {
+        diagnostics.push({ type: 'error', message: 'missing apiVersion', path: yamlPath });
+        return { component: null, diagnostics };
+    }
+    if (!SUPPORTED_API_VERSIONS.includes(definition.apiVersion)) {
+        diagnostics.push({
+            type: 'error',
+            message: `unsupported apiVersion "${String(definition.apiVersion)}"`,
+            path: yamlPath,
+        });
+        return { component: null, diagnostics };
+    }
+    if (!definition.kind) {
+        diagnostics.push({ type: 'error', message: 'missing kind', path: yamlPath });
+        return { component: null, diagnostics };
+    }
+    if (!SUPPORTED_COMPONENT_KINDS.includes(definition.kind)) {
+        diagnostics.push({
+            type: 'error',
+            message: `unsupported kind "${definition.kind}"`,
+            path: yamlPath,
+        });
+        return { component: null, diagnostics };
+    }
+    if (!definition.metadata?.name) {
+        diagnostics.push({ type: 'error', message: 'missing metadata.name', path: yamlPath });
+        return { component: null, diagnostics };
+    }
+    if (!definition.metadata?.description) {
+        diagnostics.push({ type: 'error', message: 'missing metadata.description', path: yamlPath });
+        return { component: null, diagnostics };
+    }
+    const nameErrors = validateComponentName(definition.metadata.name);
+    for (const err of nameErrors) {
+        diagnostics.push({ type: 'error', message: err, path: yamlPath });
+    }
+    const descErrors = validateComponentDescription(definition.metadata.description);
+    for (const err of descErrors) {
+        diagnostics.push({ type: 'error', message: err, path: yamlPath });
+    }
+    if (nameErrors.length > 0 || descErrors.length > 0) {
+        return { component: null, diagnostics };
+    }
+    // Validate kind-specific spec
+    if (!definition.spec) {
+        diagnostics.push({ type: 'error', message: 'missing spec', path: yamlPath });
+        return { component: null, diagnostics };
+    }
+    const entryFileDiagnostic = validateEntryFile(definition.kind, definition.spec, dir, yamlPath);
+    if (entryFileDiagnostic) {
+        diagnostics.push(entryFileDiagnostic);
+        return { component: null, diagnostics };
+    }
+    const id = computeComponentId(definition.metadata.name, definition.metadata.namespace);
+    const component = {
+        id,
+        kind: definition.kind,
+        metadata: definition.metadata,
+        spec: definition.spec,
+        requires: definition.requires,
+        compatibility: definition.compatibility,
+        routing: definition.routing,
+        dirPath: dir,
+        filePath: yamlPath,
+        source,
+        format: 'component-yaml',
+        enabled: true,
+    };
+    return { component, diagnostics };
+}
+function loadFromLegacySkill(filePath, dir, source) {
+    const diagnostics = [];
+    let raw;
+    try {
+        raw = readFileSync(filePath, 'utf-8');
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : 'failed to read SKILL.md';
+        diagnostics.push({ type: 'warning', message: msg, path: filePath });
+        return { component: null, diagnostics };
+    }
+    const { frontmatter } = parseFrontmatter(raw);
+    const parentDirName = basename(dir);
+    const name = frontmatter.name || parentDirName;
+    // Validate
+    const nameErrors = validateComponentName(name);
+    for (const err of nameErrors) {
+        diagnostics.push({ type: 'warning', message: err, path: filePath });
+    }
+    const descErrors = validateComponentDescription(frontmatter.description);
+    for (const err of descErrors) {
+        diagnostics.push({ type: 'warning', message: err, path: filePath });
+    }
+    if (!frontmatter.description || frontmatter.description.trim() === '') {
+        return { component: null, diagnostics };
+    }
+    const spec = {
+        prompt: 'SKILL.md',
+        disableModelInvocation: frontmatter['disable-model-invocation'] === true,
+    };
+    const id = computeComponentId(name);
+    const component = {
+        id,
+        kind: 'skill',
+        metadata: {
+            name,
+            description: frontmatter.description,
+        },
+        spec,
+        dirPath: dir,
+        filePath,
+        source,
+        format: 'skill-md',
+        enabled: true,
+    };
+    return { component, diagnostics };
+}
+function loadFromLegacyAgent(filePath, source) {
+    const diagnostics = [];
+    let raw;
+    try {
+        raw = readFileSync(filePath, 'utf-8');
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : 'failed to read agent file';
+        diagnostics.push({ type: 'warning', message: msg, path: filePath });
+        return { component: null, diagnostics };
+    }
+    const { frontmatter } = parseFrontmatter(raw);
+    if (!frontmatter.name || !frontmatter.description) {
+        diagnostics.push({
+            type: 'warning',
+            message: 'agent file missing name or description in frontmatter',
+            path: filePath,
+        });
+        return { component: null, diagnostics };
+    }
+    // Parse tools from comma-separated string
+    const tools = frontmatter.tools
+        ? {
+            allow: frontmatter.tools
+                .split(',')
+                .map((t) => t.trim())
+                .filter(Boolean),
+        }
+        : undefined;
+    const spec = {
+        systemPrompt: basename(filePath),
+        model: frontmatter.model,
+        tools,
+    };
+    const id = computeComponentId(frontmatter.name);
+    const dir = dirname(filePath);
+    const component = {
+        id,
+        kind: 'agent',
+        metadata: {
+            name: frontmatter.name,
+            description: frontmatter.description,
+        },
+        spec,
+        dirPath: dir,
+        filePath,
+        source,
+        format: 'agent-md',
+        enabled: true,
+    };
+    return { component, diagnostics };
+}
+// ============================================================================
+// Directory Scanning
+// ============================================================================
+/**
+ * Scan a directory for components (skills format).
+ * Handles both new and legacy directory layouts.
+ *
+ * Expected layouts:
+ * - dir/{component-name}/component.yaml  (new format)
+ * - dir/{component-name}/SKILL.md        (legacy skill)
+ * - dir/{name}.md                        (legacy root-level skill)
+ */
+export function scanComponentDir(dir, source, kind) {
+    const components = [];
+    const diagnostics = [];
+    if (!existsSync(dir)) {
+        return { components, diagnostics };
+    }
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true, encoding: 'utf-8' });
+    }
+    catch {
+        return { components, diagnostics };
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith('.') || entry.name === 'node_modules') {
+            continue;
+        }
+        const fullPath = join(dir, entry.name);
+        let isDir = entry.isDirectory();
+        let isFile = entry.isFile();
+        if (entry.isSymbolicLink()) {
+            try {
+                const stats = statSync(fullPath);
+                isDir = stats.isDirectory();
+                isFile = stats.isFile();
+            }
+            catch {
+                continue;
+            }
+        }
+        if (isDir) {
+            const result = loadComponentFromDir(fullPath, source);
+            if (result.component) {
+                if (!kind || result.component.kind === kind) {
+                    components.push(result.component);
+                }
+            }
+            diagnostics.push(...result.diagnostics);
+        }
+        else if (isFile && entry.name.endsWith('.md')) {
+            // Root-level .md files — could be legacy skills or agents
+            // Peek at frontmatter to determine type
+            const result = loadFromFile(fullPath, source);
+            if (result.component) {
+                if (!kind || result.component.kind === kind) {
+                    components.push(result.component);
+                }
+            }
+            diagnostics.push(...result.diagnostics);
+        }
+    }
+    return { components, diagnostics };
+}
+/**
+ * Scan a directory specifically for agent .md files (legacy agent format).
+ */
+export function scanAgentDir(dir, source) {
+    const components = [];
+    const diagnostics = [];
+    if (!existsSync(dir)) {
+        return { components, diagnostics };
+    }
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true, encoding: 'utf-8' });
+    }
+    catch {
+        return { components, diagnostics };
+    }
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        let isDir = entry.isDirectory();
+        let isFile = entry.isFile();
+        if (entry.isSymbolicLink()) {
+            try {
+                const stats = statSync(fullPath);
+                isDir = stats.isDirectory();
+                isFile = stats.isFile();
+            }
+            catch {
+                continue;
+            }
+        }
+        if (isDir) {
+            const result = loadComponentFromDir(fullPath, source);
+            if (result.component?.kind === 'agent') {
+                components.push(result.component);
+            }
+            diagnostics.push(...result.diagnostics);
+            continue;
+        }
+        if (!entry.name.endsWith('.md'))
+            continue;
+        if (!isFile)
+            continue;
+        // Check if there's a component.yaml in a same-named directory
+        const nameWithoutExt = entry.name.replace(/\.md$/, '');
+        const componentDir = join(dir, nameWithoutExt);
+        if (existsSync(join(componentDir, 'component.yaml'))) {
+            // New format takes precedence and is loaded by the directory branch.
+            continue;
+        }
+        const result = loadComponentFromAgentFile(fullPath, source);
+        if (result.component) {
+            components.push(result.component);
+        }
+        diagnostics.push(...result.diagnostics);
+    }
+    return { components, diagnostics };
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+/**
+ * Load a single file, detecting whether it's a skill or agent by frontmatter.
+ */
+function loadFromFile(filePath, source) {
+    const diagnostics = [];
+    let raw;
+    try {
+        raw = readFileSync(filePath, 'utf-8');
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : 'failed to read file';
+        diagnostics.push({ type: 'warning', message: msg, path: filePath });
+        return { component: null, diagnostics };
+    }
+    const { frontmatter } = parseFrontmatter(raw);
+    // If it has 'tools' field, treat as agent
+    if (frontmatter.tools !== undefined) {
+        return loadFromLegacyAgent(filePath, source);
+    }
+    // Otherwise treat as a legacy skill (root-level .md)
+    const dir = dirname(filePath);
+    const name = frontmatter.name || basename(filePath, '.md');
+    const description = frontmatter.description;
+    if (!description || description.trim() === '') {
+        return { component: null, diagnostics };
+    }
+    const spec = {
+        prompt: basename(filePath),
+        disableModelInvocation: frontmatter['disable-model-invocation'] === true,
+    };
+    const id = computeComponentId(name);
+    const component = {
+        id,
+        kind: 'skill',
+        metadata: { name, description },
+        spec,
+        dirPath: dir,
+        filePath,
+        source,
+        format: 'skill-md',
+        enabled: true,
+    };
+    return { component, diagnostics };
+}
+function validateEntryFile(kind, spec, dir, yamlPath) {
+    const relativePath = kind === 'skill'
+        ? spec.prompt
+        : spec.systemPrompt;
+    const field = kind === 'skill' ? 'spec.prompt' : 'spec.systemPrompt';
+    if (!relativePath || typeof relativePath !== 'string') {
+        return {
+            type: 'error',
+            message: `missing ${field}`,
+            path: yamlPath,
+        };
+    }
+    const entryPath = join(dir, relativePath);
+    if (!existsSync(entryPath)) {
+        return {
+            type: 'error',
+            message: `missing referenced file for ${field}: ${relativePath}`,
+            path: entryPath,
+        };
+    }
+    try {
+        if (!statSync(entryPath).isFile()) {
+            return {
+                type: 'error',
+                message: `referenced ${field} is not a file: ${relativePath}`,
+                path: entryPath,
+            };
+        }
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : 'failed to inspect referenced file';
+        return {
+            type: 'error',
+            message: `${msg}: ${relativePath}`,
+            path: entryPath,
+        };
+    }
+    return null;
+}

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

@@ -0,0 +1,69 @@
+/**
+ * Unified Component Type Definitions
+ *
+ * Shared metadata for installable/discoverable skills and agents.
+ *
+ * Replaces the separate type systems in:
+ * - packages/pi-coding-agent/src/core/skills.ts (SkillFrontmatter, Skill)
+ * - src/resources/extensions/subagent/agents.ts (AgentConfig)
+ *
+ * Legacy skill and agent formats are supported via backward-compatible loading.
+ */
+// ============================================================================
+// Validation
+// ============================================================================
+/** Max name length per spec */
+export const MAX_NAME_LENGTH = 64;
+/** Max description length per spec */
+export const MAX_DESCRIPTION_LENGTH = 1024;
+/** Valid name pattern: lowercase a-z, 0-9, hyphens, no leading/trailing/consecutive hyphens */
+export const NAME_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+/**
+ * Validate a component name.
+ * @returns Array of error messages (empty if valid).
+ */
+export function validateComponentName(name) {
+    const errors = [];
+    if (!name || name.trim() === '') {
+        errors.push('name is required');
+        return errors;
+    }
+    if (name.length > MAX_NAME_LENGTH) {
+        errors.push(`name exceeds ${MAX_NAME_LENGTH} characters (${name.length})`);
+    }
+    if (name.includes('--')) {
+        errors.push('name must not contain consecutive hyphens');
+    }
+    if (!NAME_PATTERN.test(name)) {
+        if (/[A-Z]/.test(name)) {
+            errors.push('name must be lowercase');
+        }
+        else if (name.startsWith('-') || name.endsWith('-')) {
+            errors.push('name must not start or end with a hyphen');
+        }
+        else if (!name.includes('--')) {
+            errors.push('name must contain only lowercase a-z, 0-9, and hyphens');
+        }
+    }
+    return errors;
+}
+/**
+ * Validate a component description.
+ * @returns Array of error messages (empty if valid).
+ */
+export function validateComponentDescription(description) {
+    const errors = [];
+    if (!description || description.trim() === '') {
+        errors.push('description is required');
+    }
+    else if (description.length > MAX_DESCRIPTION_LENGTH) {
+        errors.push(`description exceeds ${MAX_DESCRIPTION_LENGTH} characters (${description.length})`);
+    }
+    return errors;
+}
+/**
+ * Compute the canonical ID for a component.
+ */
+export function computeComponentId(name, namespace) {
+    return namespace ? `${namespace}:${name}` : name;
+}

package/dist/resources/extensions/gsd/context-store.js

@@ -180,7 +180,13 @@ export function queryProject() {
 // ─── Knowledge Query ───────────────────────────────────────────────────────
 /**
  * Filter KNOWLEDGE.md sections by keyword matching.
- * Uses H2 sections, matches keywords case-insensitively against:
+ *
+ * Structure-adaptive (issue #4719): files that organise entries as H3 items
+ * under one or more H2 topics are filtered at H3 granularity. Files with only
+ * H2 topic headers (no H3) fall back to H2-level filtering for backwards
+ * compatibility.
+ *
+ * Matches keywords case-insensitively against:
  * 1. Section header text
  * 2. First paragraph of section content (up to first blank line or next heading)
  *
@@ -189,28 +195,38 @@ export function queryProject() {
  *
  * @param content - Full KNOWLEDGE.md content
  * @param keywords - Keywords to match (case-insensitive)
- * @returns Concatenated matching sections with H2 headers, or empty string
+ * @returns Concatenated matching sections with their original heading prefix, or empty string
  */
 export async function queryKnowledge(content, keywords) {
     if (!content || keywords.length === 0)
         return '';
     // Lazy import to avoid circular dependency
     const { extractAllSections } = await import('./files.js');
-    const sections = extractAllSections(content, 2);
+    // Prefer H3 granularity when available; fall back to H2 for H2-only files.
+    // This prevents single-H2-with-many-H3 layouts from returning the entire
+    // file on a keyword match against the H2 header or its first paragraph.
+    const h3Sections = extractAllSections(content, 3);
+    const useH3 = h3Sections.size > 0;
+    const sections = useH3 ? h3Sections : extractAllSections(content, 2);
     if (sections.size === 0)
         return '';
-    // Normalize keywords for case-insensitive matching
-    const normalizedKeywords = keywords.map(k => k.toLowerCase());
+    const prefix = useH3 ? '###' : '##';
+    // Trim, lowercase, drop empties, and de-dupe so callers can pass raw
+    // user-provided strings without risking empty-string / whitespace matches.
+    const normalizedKeywords = [...new Set(keywords
+            .map(k => k.trim().toLowerCase())
+            .filter(k => k.length > 0))];
+    if (normalizedKeywords.length === 0)
+        return '';
     const matchingSections = [];
     for (const [header, body] of sections) {
         // Extract first paragraph: everything up to first blank line or next heading
         const firstParagraph = body.split(/\n\s*\n|\n#/)[0] || '';
-        // Check if any keyword matches header or first paragraph
         const headerLower = header.toLowerCase();
         const paragraphLower = firstParagraph.toLowerCase();
         const matches = normalizedKeywords.some(kw => headerLower.includes(kw) || paragraphLower.includes(kw));
         if (matches) {
-            matchingSections.push(`## ${header}\n\n${body}`);
+            matchingSections.push(`${prefix} ${header}\n\n${body}`);
         }
     }
     return matchingSections.join('\n\n');

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

@@ -6,7 +6,7 @@
  * flow to show when entering a project directory.
  */
 import { existsSync, openSync, readSync, closeSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join, parse as parsePath } from "node:path";
 import { homedir } from "node:os";
 import { gsdRoot } from "./paths.js";
 const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
@@ -951,6 +951,54 @@ function resolveVersionCatalogAccessors(basePath, versionCatalogFiles, settingsF
     }
     return accessors;
 }
+/**
+ * Walk ancestor directories of `startDir` looking for any file in
+ * `PROJECT_FILES`. Stops at the filesystem root or at a `.git` boundary
+ * (so ancestors above a git repo root — e.g. `$HOME` or `/usr/local` —
+ * can't trigger false positives). Returns true if an ancestor contains
+ * one of the project markers.
+ *
+ * Used by the worktree health check (#2347) to avoid warning about
+ * monorepos where package.json / Cargo.toml / etc. live in a parent
+ * directory rather than in the worktree's own checkout.
+ *
+ * `existsFn` is injectable so this remains deterministically testable
+ * without touching the real filesystem; defaults to `fs.existsSync`.
+ */
+export function hasProjectFileInAncestor(startDir, existsFn = existsSync) {
+    let checkDir = dirname(startDir);
+    const { root } = parsePath(checkDir);
+    while (checkDir !== root) {
+        if (PROJECT_FILES.some((f) => existsFn(join(checkDir, f)))) {
+            return true;
+        }
+        // Stop at git repository boundary — ancestors above the repo root
+        // may contain unrelated project files. Check AFTER project-file scan
+        // so a repo root containing both .git and a marker is still recognized.
+        if (existsFn(join(checkDir, ".git")))
+            return false;
+        checkDir = dirname(checkDir);
+    }
+    return false;
+}
+/**
+ * Check whether a project's `.gsd/` directory contains the bootstrap artifacts
+ * (`PREFERENCES.md` or `milestones/`) that indicate a completed init run.
+ *
+ * A zombie `.gsd/` state — symlink exists but neither artifact is present —
+ * must be treated as "needs init wizard". The previous guard checked only
+ * `existsSync(gsdRoot(basePath))`, which accepted zombie states and skipped
+ * the wizard (#2942).
+ *
+ * `existsFn` is injectable so tests can run deterministically; defaults to
+ * `fs.existsSync`.
+ */
+export function hasGsdBootstrapArtifacts(gsdPath, existsFn = existsSync) {
+    return (existsFn(gsdPath) &&
+        (existsFn(join(gsdPath, "PREFERENCES.md")) ||
+            existsFn(join(gsdPath, "preferences.md")) ||
+            existsFn(join(gsdPath, "milestones"))));
+}
 export function scanProjectFiles(basePath) {
     const files = [];
     const queue = [{ path: basePath, depth: 0 }];

package/dist/resources/extensions/gsd/dispatch-guard.js

@@ -5,23 +5,8 @@ import { parseUnitId } from "./unit-id.js";
 import { isDbAvailable, getMilestoneSlices, getMilestone } from "./gsd-db.js";
 import { parseRoadmap } from "./parsers-legacy.js";
 import { isClosedStatus } from "./status-guards.js";
+import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
 import { readFileSync } from "node:fs";
-/**
- * Detect failure-path milestone SUMMARY content (#4663 sibling to #4658).
- * A failure SUMMARY must not let the dispatch guard treat an active
- * milestone as complete. The markers mirror those produced by
- * writeBlockerPlaceholder and the "verification FAILED" retry path.
- *
- * This is intentionally a minimal local detector so this fix does not
- * depend on PR #4660's `classifyMilestoneSummaryContent`. It can migrate
- * to the shared classifier once that lands.
- */
-function isFailureMilestoneSummary(content) {
-    return (/(?:^|\n)\s*#\s*BLOCKER\b/i.test(content) ||
-        /auto-mode recovery failed/i.test(content) ||
-        /verification\s+failed/i.test(content) ||
-        /\bnot complete\b/i.test(content));
-}
 const SLICE_DISPATCH_TYPES = new Set([
     "research-slice",
     "plan-slice",
@@ -78,7 +63,7 @@ export function getPriorSliceCompletionBlocker(base, _mainBranch, unitType, unit
                 summaryContent = readFileSync(summaryPath, "utf-8");
             }
             catch { /* ignore */ }
-            if (!summaryContent || !isFailureMilestoneSummary(summaryContent)) {
+            if (!summaryContent || classifyMilestoneSummaryContent(summaryContent) !== "failure") {
                 continue;
             }
         }

package/dist/resources/extensions/gsd/docs/preferences-reference.md

@@ -159,7 +159,7 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
 
 - `phases`: fine-grained control over which phases run. Usually set by `token_profile`, but can be overridden. Keys:
   - `skip_research`: boolean — skip milestone-level research. Default: `false`.
-  - `reassess_after_slice`: boolean — run roadmap reassessment after each completed slice. Default: `true`.
+  - `reassess_after_slice`: boolean — run a dedicated roadmap-reassessment unit after each completed slice. Default: `false` (per ADR-003 §4). The plan-slice agent for the next slice performs JIT reassessment via a prompt preamble at zero additional token cost; a dedicated reassess session is opt-in. Set to `true` (e.g. via the `burn-max` profile) if you want the explicit session.
   - `skip_reassess`: boolean — force-disable roadmap reassessment even if `reassess_after_slice` is enabled. Default: `false`.
   - `skip_slice_research`: boolean — skip per-slice research. Default: `false`.