gsd-pi 2.78.1-dev.0fdacd524 → 2.78.1-dev.42ef05fbe

package/dist/resources/extensions/gsd/interrupted-session.js

@@ -1,16 +1,51 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { verifyExpectedArtifact } from "./auto-recovery.js";
 import { formatCrashInfo, isLockProcessAlive, readCrashLock, } from "./crash-recovery.js";
 import { gsdRoot } from "./paths.js";
+import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import { synthesizeCrashRecovery, } from "./session-forensics.js";
 import { deriveState } from "./state.js";
+const LEGACY_DEEP_SETUP_UNITS = new Set([
+    "workflow-preferences:WORKFLOW-PREFS",
+    "discuss-project:PROJECT",
+    "discuss-requirements:REQUIREMENTS",
+    "research-decision:RESEARCH-DECISION",
+    "research-project:RESEARCH-PROJECT",
+]);
+function isStalePseudoMilestonePause(meta) {
+    if (meta.activeEngineId && meta.activeEngineId !== "dev")
+        return false;
+    if (meta.unitType === "discuss-milestone"
+        && typeof meta.unitId === "string"
+        && !MILESTONE_ID_RE.test(meta.unitId)) {
+        return true;
+    }
+    if (typeof meta.unitType === "string"
+        && typeof meta.unitId === "string"
+        && LEGACY_DEEP_SETUP_UNITS.has(`${meta.unitType}:${meta.unitId}`)) {
+        return true;
+    }
+    return typeof meta.milestoneId === "string"
+        && !MILESTONE_ID_RE.test(meta.milestoneId)
+        && typeof meta.unitType === "string"
+        && typeof meta.unitId === "string"
+        && LEGACY_DEEP_SETUP_UNITS.has(`${meta.unitType}:${meta.unitId}`);
+}
 export function readPausedSessionMetadata(basePath) {
     const pausedPath = join(gsdRoot(basePath), "runtime", "paused-session.json");
     if (!existsSync(pausedPath))
         return null;
     try {
-        return JSON.parse(readFileSync(pausedPath, "utf-8"));
+        const meta = JSON.parse(readFileSync(pausedPath, "utf-8"));
+        if (isStalePseudoMilestonePause(meta)) {
+            try {
+                unlinkSync(pausedPath);
+            }
+            catch { /* non-fatal */ }
+            return null;
+        }
+        return meta;
     }
     catch {
         return null;

package/dist/resources/extensions/gsd/key-manager.js

@@ -9,7 +9,7 @@ import { existsSync, statSync, chmodSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { mkdirSync } from "node:fs";
 import { getErrorMessage } from "./error-utils.js";
-import { getHomeDir } from "./home-dir.js";
+import { gsdHome } from "./gsd-home.js";
 export const PROVIDER_REGISTRY = [
     // LLM Providers
     { id: "anthropic", label: "Anthropic (Claude)", category: "llm", envVar: "ANTHROPIC_API_KEY", prefixes: ["sk-ant-"], hasOAuth: true, dashboardUrl: "console.anthropic.com" },
@@ -99,7 +99,7 @@ export function describeCredential(cred) {
  * Get the auth.json path.
  */
 export function getAuthPath() {
-    return join(getHomeDir(), ".gsd", "agent", "auth.json");
+    return join(gsdHome(), "agent", "auth.json");
 }
 /**
  * Create an AuthStorage instance for key management.

package/dist/resources/extensions/gsd/migrate/command.js

@@ -13,8 +13,8 @@ import { resolve, join, dirname } from "node:path";
 import { gsdRoot } from "../paths.js";
 import { fileURLToPath } from "node:url";
 import { showNextAction } from "../../shared/tui.js";
-import { getHomeDir } from "../home-dir.js";
 import { validatePlanningDirectory, parsePlanningDirectory, transformToGSD, generatePreview, writeGSDDirectory, } from "./index.js";
+import { homedir } from "node:os";
 /** Format preview stats for embedding in the review prompt. */
 function formatPreviewStats(preview) {
     const lines = [
@@ -51,10 +51,10 @@ export async function handleMigrate(args, ctx, pi) {
     // Default to cwd when no args given; expand ~ to HOME
     let rawPath = args.trim() || ".";
     if (rawPath.startsWith("~/")) {
-        rawPath = join(getHomeDir(), rawPath.slice(2));
+        rawPath = join(homedir(), rawPath.slice(2));
     }
     else if (rawPath === "~") {
-        rawPath = getHomeDir();
+        rawPath = homedir();
     }
     let sourcePath = resolve(process.cwd(), rawPath);
     if (!sourcePath.endsWith(".planning")) {

package/dist/resources/extensions/gsd/milestone-scope-classifier.js

@@ -120,13 +120,14 @@ function mentionsWithoutNegation(text, term) {
         const start = m.index ?? 0;
         const windowStart = Math.max(0, start - 30);
         const window = lower.slice(windowStart, start);
-        // Negator anywhere in the 30-char lookback window counts as negation —
-        // covers "no backend", "without a server", "not using api", "zero
-        // dependencies on an api". If a sentence break intervenes between the
-        // negator and the term, treat as a different clause (positive mention).
-        const hasNegator = /(^|[^a-z0-9])(no|without|not|zero|skip(s|ping)?|drops?)\b/i.test(window);
-        const hasSentenceBreak = /[.;!?]/.test(window);
-        if (hasNegator && !hasSentenceBreak)
+        // Negator anywhere in the same clause counts as negation — covers "no
+        // backend", "without a server", "not using api", "zero dependencies on
+        // an api". Only inspect text after the most recent sentence break so
+        // "No backend. Add API" still treats API as a positive mention.
+        const lastBreak = Math.max(window.lastIndexOf("."), window.lastIndexOf(";"), window.lastIndexOf("!"), window.lastIndexOf("?"));
+        const clauseWindow = window.slice(lastBreak + 1);
+        const hasNegator = /(^|[^a-z0-9])(no|without|not|zero|skip(s|ping)?|drops?)\b/i.test(clauseWindow);
+        if (hasNegator)
             continue;
         return true;
     }
@@ -220,7 +221,8 @@ export function classifyMilestoneScope(input) {
         input.verificationOperational ?? "",
         input.verificationUat ?? "",
     ].join("\n");
-    const overrideHits = containsAnyKeyword(haystack, OVERRIDE_KEYWORDS);
+    const overrideHits = containsAnyKeyword(haystack, OVERRIDE_KEYWORDS)
+        .filter((kw) => mentionsWithoutNegation(haystack, kw));
     const complexHits = containsAnyKeyword(haystack, COMPLEX_KEYWORDS);
     const trivialHits = containsAnyKeyword(haystack, TRIVIAL_KEYWORDS);
     const fileCountHint = extractFileCountHint(haystack);

package/dist/resources/extensions/gsd/native-git-bridge.js

@@ -216,6 +216,20 @@ export function nativeIsRepo(basePath) {
         return false;
     }
 }
+/** Return true only when the repository has a reachable committed HEAD. */
+export function nativeHasCommittedHead(basePath) {
+    try {
+        execFileSync("git", ["rev-parse", "--verify", "HEAD"], {
+            cwd: basePath,
+            stdio: ["ignore", "ignore", "ignore"],
+            env: GIT_NO_PROMPT_ENV,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Check if there are staged changes (index differs from HEAD).
  * Native: libgit2 tree-to-index diff.

package/dist/resources/extensions/gsd/onboarding-state.js

@@ -4,9 +4,9 @@
 // web boot probe all read the same source of truth. Replaces the implicit
 // "settings.defaultProvider exists" heuristic.
 import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { logWarning } from "./workflow-logger.js";
+import { gsdHome } from "./gsd-home.js";
 /**
  * Bump `FLOW_VERSION` whenever a new required step is added to ONBOARDING_STEPS.
  * Records with an older flowVersion are treated as "needs partial re-onboarding"
@@ -18,7 +18,7 @@ const RECORD_VERSION = 1;
 // rootDir-clean for the resources tsconfig; importing from src/ pulls files
 // outside src/resources and breaks the build.
 const AGENT_DIR = process.env.GSD_CODING_AGENT_DIR ||
-    join(process.env.GSD_HOME || join(homedir(), ".gsd"), "agent");
+    join(gsdHome(), "agent");
 const FILE = join(AGENT_DIR, "onboarding.json");
 const DEFAULT = {
     version: RECORD_VERSION,

package/dist/resources/extensions/gsd/planning-depth.js

@@ -0,0 +1,115 @@
+// gsd-2 / Deep planning mode — Helper to set planning_depth in .gsd/PREFERENCES.md.
+//
+// Persists the user's deep-mode opt-in across sessions. Reads the existing
+// preferences file (if any), parses its YAML frontmatter, sets/updates
+// planning_depth, and writes the file back preserving body content and other
+// frontmatter keys.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { getProjectGSDPreferencesPath } from "./preferences.js";
+import { logWarning } from "./workflow-logger.js";
+import { researchDecisionPath, writeDefaultResearchSkipDecision, } from "./deep-project-setup-policy.js";
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+/**
+ * Set planning_depth in the project's .gsd/PREFERENCES.md.
+ * Creates the file if it does not exist. Preserves existing frontmatter
+ * keys and body content. Intended to be called when the user opts into
+ * (or out of) deep mode via `/gsd new-project --deep` or similar.
+ */
+export function setPlanningDepth(basePath, depth) {
+    const path = getProjectGSDPreferencesPath(basePath);
+    const { frontmatter, body } = readProjectPreferencesParts(path);
+    frontmatter.planning_depth = depth;
+    if (depth === "deep") {
+        applyDeepWorkflowPreferenceDefaults(frontmatter);
+    }
+    writeProjectPreferencesParts(path, frontmatter, body);
+    if (depth === "deep") {
+        ensureResearchDecisionDefault(basePath);
+    }
+}
+export function ensureWorkflowPreferencesCaptured(basePath) {
+    const path = getProjectGSDPreferencesPath(basePath);
+    const { frontmatter, body } = readProjectPreferencesParts(path);
+    frontmatter.planning_depth = "deep";
+    applyDeepWorkflowPreferenceDefaults(frontmatter);
+    writeProjectPreferencesParts(path, frontmatter, body);
+    ensureResearchDecisionDefault(basePath);
+}
+function readProjectPreferencesParts(path) {
+    let frontmatter = {};
+    let body = "";
+    if (existsSync(path)) {
+        const content = readFileSync(path, "utf-8");
+        const match = content.match(FRONTMATTER_RE);
+        if (match) {
+            try {
+                const parsed = parseYaml(match[1]);
+                if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                    frontmatter = parsed;
+                }
+                body = match[2];
+            }
+            catch (err) {
+                // Invalid YAML — don't lose user content. Treat the whole file as
+                // a legacy non-frontmatter document and preserve it via the body
+                // path. The depth setter then prepends a fresh frontmatter block.
+                logWarning("guided", `PREFERENCES.md frontmatter has invalid YAML — preserving body and rewriting frontmatter: ${err instanceof Error ? err.message : String(err)}`);
+                body = content;
+            }
+        }
+        else {
+            // No frontmatter delimiters — preserve existing content as body.
+            body = content;
+        }
+    }
+    return { frontmatter, body };
+}
+function writeProjectPreferencesParts(path, frontmatter, body) {
+    // yaml.stringify emits a trailing newline. Strip if present so we control framing.
+    const yamlBlock = stringifyYaml(frontmatter).replace(/\n$/, "");
+    const newContent = body
+        ? `---\n${yamlBlock}\n---\n\n${body.replace(/^\n+/, "")}`
+        : `---\n${yamlBlock}\n---\n`;
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, newContent, "utf-8");
+}
+function applyDeepWorkflowPreferenceDefaults(frontmatter) {
+    if (frontmatter.commit_policy === undefined) {
+        frontmatter.commit_policy = "per-task";
+    }
+    if (frontmatter.branch_model === undefined) {
+        frontmatter.branch_model = "single";
+    }
+    if (frontmatter.uat_dispatch === undefined) {
+        frontmatter.uat_dispatch = true;
+    }
+    const existingModels = frontmatter.models;
+    const models = existingModels && typeof existingModels === "object" && !Array.isArray(existingModels)
+        ? existingModels
+        : {};
+    if (models.executor_class === undefined) {
+        models.executor_class = "balanced";
+    }
+    frontmatter.models = models;
+    frontmatter.workflow_prefs_captured = true;
+}
+function ensureResearchDecisionDefault(basePath) {
+    const decisionPath = researchDecisionPath(basePath);
+    if (existsSync(decisionPath)) {
+        try {
+            const parsed = JSON.parse(readFileSync(decisionPath, "utf-8"));
+            const source = typeof parsed.source === "string" ? parsed.source : undefined;
+            if (parsed.decision === "research" && (source === "research-decision" || source === "user")) {
+                return;
+            }
+            if (parsed.decision === "skip" && source !== "workflow-preferences")
+                return;
+        }
+        catch {
+            // Invalid runtime marker is replaced with the default decision.
+        }
+    }
+    writeDefaultResearchSkipDecision(basePath);
+}

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

@@ -8,6 +8,7 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { gsdHome } from "./gsd-home.js";
 import { canonicalModelForTier, defaultRoutingConfig, resolveModelForTier } from "./model-router.js";
 import { loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
 /**
@@ -45,8 +46,24 @@ export function resolveModelWithFallbacksForUnit(unitType) {
             break;
         case "discuss-milestone":
         case "discuss-slice":
+        // Deep-mode project-level discussion units route to the same model
+        // bucket as milestone-level discussion (interactive interview style).
+        case "discuss-project":
+        case "discuss-requirements":
+        // Workflow preferences and research-decision are tiny ask_user_questions
+        // style units; they share the discuss bucket because they are
+        // conversational rather than research/execution. Falling back to planning
+        // when no `discuss` bucket is set keeps parity with the milestone units.
+        case "workflow-preferences":
+        case "research-decision":
             phaseConfig = m.discuss ?? m.planning;
             break;
+        // Deep-mode project research orchestrator. Reads PROJECT.md / REQUIREMENTS.md
+        // and fans out research subagents. Routes to the research bucket so it
+        // gets the research-tier model when one is configured.
+        case "research-project":
+            phaseConfig = m.research;
+            break;
         case "execute-task":
         case "reactive-execute":
             phaseConfig = m.execution;
@@ -186,7 +203,7 @@ export function isCustomProvider(provider) {
     if (!provider)
         return false;
     const candidates = [
-        join(homedir(), ".gsd", "agent", "models.json"),
+        join(gsdHome(), "agent", "models.json"),
         join(homedir(), ".pi", "agent", "models.json"),
     ];
     for (const path of candidates) {

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

@@ -7,6 +7,7 @@
 import { existsSync, readdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { isAbsolute, join } from "node:path";
+import { gsdHome } from "./gsd-home.js";
 import { statSync } from "node:fs";
 import { validatePreferences } from "./preferences-validation.js";
 /**
@@ -25,7 +26,7 @@ export function getSkillSearchDirs(cwd) {
         { dir: join(cwd, ".claude", "skills"), method: "project-skill" },
     ];
     // Legacy fallback — read skills from old GSD directory only if migration hasn't completed
-    const legacyDir = join(homedir(), ".gsd", "agent", "skills");
+    const legacyDir = join(gsdHome(), "agent", "skills");
     if (existsSync(legacyDir) && !existsSync(join(legacyDir, ".migrated-to-agents"))) {
         dirs.push({ dir: legacyDir, method: "user-skill" });
     }

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

@@ -98,6 +98,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "language",
     "context_window_override",
     "context_mode",
+    "planning_depth",
 ]);
 /** Canonical list of all dispatch unit types. */
 export const KNOWN_UNIT_TYPES = [
@@ -105,6 +106,9 @@ export const KNOWN_UNIT_TYPES = [
     "execute-task", "reactive-execute", "gate-evaluate", "complete-slice", "replan-slice", "reassess-roadmap",
     "run-uat", "complete-milestone", "validate-milestone", "rewrite-docs",
     "discuss-milestone", "discuss-slice", "worktree-merge",
+    // Deep planning mode (project-level) units
+    "workflow-preferences", "discuss-project", "discuss-requirements",
+    "research-decision", "research-project",
 ];
 export const SKILL_ACTIONS = new Set(["use", "prefer", "avoid"]);
 /**

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

@@ -251,6 +251,15 @@ export function validatePreferences(preferences) {
             errors.push(`token_profile must be one of: budget, balanced, quality, burn-max`);
         }
     }
+    // ─── Planning Depth (deep planning mode) ─────────────────────────
+    if (preferences.planning_depth !== undefined) {
+        if (preferences.planning_depth === "light" || preferences.planning_depth === "deep") {
+            validated.planning_depth = preferences.planning_depth;
+        }
+        else {
+            errors.push(`planning_depth must be "light" or "deep"`);
+        }
+    }
     // ─── Search Provider ─────────────────────────────────────────────
     if (preferences.search_provider !== undefined) {
         const validSearchProviders = new Set(["brave", "tavily", "ollama", "native", "auto"]);

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

@@ -17,8 +17,10 @@ import { parse as parseYaml } from "yaml";
 import { normalizeStringArray } from "../shared/format-utils.js";
 import { logWarning } from "./workflow-logger.js";
 import { resolveProfileDefaults as _resolveProfileDefaults } from "./preferences-models.js";
+import { nativeHasCommittedHead, nativeIsRepo } from "./native-git-bridge.js";
 import { KNOWN_PREFERENCE_KEYS, MODE_DEFAULTS, formatSkillRef, } from "./preferences-types.js";
 import { validatePreferences } from "./preferences-validation.js";
+import { gsdHome } from "./gsd-home.js";
 // ─── Re-exports: validation ─────────────────────────────────────────────────
 export { validatePreferences } from "./preferences-validation.js";
 // ─── Re-exports: skills ─────────────────────────────────────────────────────
@@ -37,9 +39,6 @@ export function resolveSkillStalenessDays(basePath) {
 // ─── Re-exports: models ─────────────────────────────────────────────────────
 export { resolveModelForUnit, resolveModelWithFallbacksForUnit, getNextFallbackModel, isTransientNetworkError, validateModelId, updatePreferencesModels, resolveDynamicRoutingConfig, resolveAutoSupervisorConfig, resolveProfileDefaults, getProfileTierMap, resolveEffectiveProfile, resolveInlineLevel, resolveContextSelection, resolveSearchProviderFromPreferences, resolveDisabledModelProvidersFromPreferences, } from "./preferences-models.js";
 // ─── Path Constants & Getters ───────────────────────────────────────────────
-function gsdHome() {
-    return process.env.GSD_HOME || join(homedir(), ".gsd");
-}
 function globalPreferencesPath() {
     return join(gsdHome(), "PREFERENCES.md");
 }
@@ -363,6 +362,7 @@ function mergePreferences(base, override) {
             ? { ...(base.slice_parallel ?? {}), ...(override.slice_parallel ?? {}) }
             : undefined,
         language: override.language ?? base.language,
+        planning_depth: override.planning_depth ?? base.planning_depth,
     };
 }
 function mergeStringLists(base, override) {
@@ -493,8 +493,11 @@ export function resolvePreDispatchHooks() {
  */
 export function getIsolationMode(basePath) {
     const prefs = loadEffectiveGSDPreferences(basePath)?.preferences?.git;
-    if (prefs?.isolation === "worktree")
+    if (prefs?.isolation === "worktree") {
+        if (basePath && nativeIsRepo(basePath) && !nativeHasCommittedHead(basePath))
+            return "none";
         return "worktree";
+    }
     if (prefs?.isolation === "branch")
         return "branch";
     return "none"; // default — no isolation, work on current branch

package/dist/resources/extensions/gsd/project-research-policy.js

@@ -0,0 +1,182 @@
+import { existsSync, mkdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { classifyMilestoneScope, } from "./milestone-scope-classifier.js";
+import { clearParseCache } from "./files.js";
+import { gsdRoot, clearPathCache } from "./paths.js";
+import { parseProject, parseRequirements } from "./schemas/parsers.js";
+export const PROJECT_RESEARCH_DIMENSIONS = ["STACK", "FEATURES", "ARCHITECTURE", "PITFALLS"];
+export const PROJECT_RESEARCH_BLOCKER = "PROJECT-RESEARCH-BLOCKER.md";
+export const PROJECT_RESEARCH_INFLIGHT_MARKER = "research-project-inflight";
+function researchDir(basePath) {
+    return join(gsdRoot(basePath), "research");
+}
+function runtimeDir(basePath) {
+    return join(gsdRoot(basePath), "runtime");
+}
+function researchDecisionPath(basePath) {
+    return join(runtimeDir(basePath), "research-decision.json");
+}
+function clearResearchCaches() {
+    clearPathCache();
+    clearParseCache();
+}
+function isProjectResearchDimensionSatisfied(dir, name) {
+    return existsSync(join(dir, `${name}.md`)) || existsSync(join(dir, `${name}-BLOCKER.md`));
+}
+function writeIfMissing(path, content) {
+    if (existsSync(path))
+        return false;
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, content, "utf-8");
+    return true;
+}
+function markdownTitle(content) {
+    return content.match(/^#\s+(.+)$/m)?.[1]?.trim() ?? "Project";
+}
+function selectedSections(sections) {
+    return [
+        "What This Is",
+        "Core Value",
+        "Current State",
+        "Architecture / Key Patterns",
+        "Constraints",
+        "Milestone Sequence",
+    ]
+        .map((name) => sections[name] ?? "")
+        .filter(Boolean)
+        .join("\n\n");
+}
+export function classifyProjectResearchScope(projectContent, requirementsContent) {
+    const project = parseProject(projectContent);
+    const requirements = parseRequirements(requirementsContent);
+    const activeRequirements = requirements.requirements.filter((r) => r.status === "active" || r.parentSection === "Active");
+    const activeCapabilities = activeRequirements.filter((r) => r.class !== "constraint" && r.class !== "anti-feature");
+    const requirementCoverage = activeRequirements
+        .map((r) => [
+        r.id,
+        r.title,
+        r.class,
+        r.status,
+        r.description,
+        r.notes,
+    ].filter(Boolean).join(" — "))
+        .join("\n");
+    const result = classifyMilestoneScope({
+        title: markdownTitle(projectContent),
+        vision: selectedSections(project.sections),
+        successCriteria: activeCapabilities.map((r) => `${r.title}: ${r.description}`),
+        definitionOfDone: activeCapabilities.map((r) => r.validation).filter(Boolean),
+        requirementCoverage: [
+            requirementCoverage,
+            Object.entries(requirements.coverageSummary)
+                .map(([key, value]) => `${key}: ${value}`)
+                .join("\n"),
+        ].filter(Boolean).join("\n\n"),
+    });
+    return {
+        ...result,
+        source: "project-research",
+    };
+}
+export function getProjectResearchStatus(basePath) {
+    const dir = researchDir(basePath);
+    const globalBlocker = existsSync(join(dir, PROJECT_RESEARCH_BLOCKER));
+    const completedDimensions = [];
+    const blockerDimensions = [];
+    const missingDimensions = [];
+    for (const name of PROJECT_RESEARCH_DIMENSIONS) {
+        if (existsSync(join(dir, `${name}.md`)))
+            completedDimensions.push(name);
+        else if (existsSync(join(dir, `${name}-BLOCKER.md`)))
+            blockerDimensions.push(name);
+        else
+            missingDimensions.push(name);
+    }
+    const allSatisfied = PROJECT_RESEARCH_DIMENSIONS.every((name) => isProjectResearchDimensionSatisfied(dir, name));
+    const allDimensionBlockers = allSatisfied &&
+        completedDimensions.length === 0 &&
+        blockerDimensions.length === PROJECT_RESEARCH_DIMENSIONS.length;
+    const blocked = globalBlocker || allDimensionBlockers;
+    return {
+        complete: allSatisfied && !blocked,
+        blocked,
+        allDimensionBlockers,
+        globalBlocker,
+        missingDimensions,
+        completedDimensions,
+        blockerDimensions,
+        hasRealResearch: completedDimensions.length > 0,
+    };
+}
+export function writeProjectResearchAutoSkipDecision(basePath, classification) {
+    mkdirSync(runtimeDir(basePath), { recursive: true });
+    writeFileSync(researchDecisionPath(basePath), JSON.stringify({
+        decision: "skip",
+        decided_at: new Date().toISOString(),
+        source: "project-research-fast-path",
+        previous_source: "workflow-preferences",
+        reason: "trivial-static-local-project",
+        classifier_variant: classification.variant,
+        classifier_reasons: classification.reasons,
+    }, null, 2) + "\n", "utf-8");
+}
+export function clearProjectResearchInflightMarker(basePath) {
+    const marker = join(runtimeDir(basePath), PROJECT_RESEARCH_INFLIGHT_MARKER);
+    if (existsSync(marker))
+        unlinkSync(marker);
+}
+export function finalizeProjectResearchTimeout(basePath, reason) {
+    const dir = researchDir(basePath);
+    mkdirSync(dir, { recursive: true });
+    clearProjectResearchInflightMarker(basePath);
+    const before = getProjectResearchStatus(basePath);
+    const written = [];
+    if (before.complete) {
+        clearResearchCaches();
+        return { kind: "completed", status: before, written };
+    }
+    if (before.blocked) {
+        clearResearchCaches();
+        return { kind: "global-blocker", status: before, written };
+    }
+    if (before.hasRealResearch) {
+        for (const dimension of before.missingDimensions) {
+            const blockerPath = join(dir, `${dimension}-BLOCKER.md`);
+            if (writeIfMissing(blockerPath, [
+                `# ${dimension} research blocker`,
+                ``,
+                `Auto-mode stopped project research before this dimension produced a durable artifact.`,
+                ``,
+                `**Reason**: ${reason}`,
+                ``,
+                `At least one other project research dimension completed, so this blocker satisfies the project research gate without rerunning every scout.`,
+            ].join("\n"))) {
+                written.push(blockerPath);
+            }
+        }
+        clearResearchCaches();
+        return {
+            kind: "partial-blockers",
+            status: getProjectResearchStatus(basePath),
+            written,
+        };
+    }
+    const blockerPath = join(dir, PROJECT_RESEARCH_BLOCKER);
+    if (writeIfMissing(blockerPath, [
+        `# Project research blocker`,
+        ``,
+        `Auto-mode stopped project research before any usable research dimension completed.`,
+        ``,
+        `**Reason**: ${reason}`,
+        ``,
+        `This fail-closed blocker prevents milestone planning from relying on missing project research.`,
+    ].join("\n"))) {
+        written.push(blockerPath);
+    }
+    clearResearchCaches();
+    return {
+        kind: "global-blocker",
+        status: getProjectResearchStatus(basePath),
+        written,
+    };
+}

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

@@ -19,8 +19,8 @@ import { readFileSync, readdirSync, existsSync } from "node:fs";
 import { GSDError, GSD_PARSE_ERROR } from "./errors.js";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { homedir } from "node:os";
 import { logWarning } from "./workflow-logger.js";
+import { gsdHome } from "./gsd-home.js";
 function hasRequiredExtensionAssets(rootDir, exists = existsSync) {
     return (exists(join(rootDir, "prompts")) &&
         exists(join(rootDir, "templates", "task-summary.md")));
@@ -54,8 +54,7 @@ export function resolveExtensionDirFromCandidates(moduleDir, agentGsdDir, exists
  */
 function resolveExtensionDir() {
     const moduleDir = dirname(fileURLToPath(import.meta.url));
-    const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
-    const agentGsdDir = join(gsdHome, "agent", "extensions", "gsd");
+    const agentGsdDir = join(gsdHome(), "agent", "extensions", "gsd");
     return resolveExtensionDirFromCandidates(moduleDir, agentGsdDir);
 }
 const __extensionDir = resolveExtensionDir();