gsd-pi 2.37.1 → 2.38.0-dev.63ad7e5

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

@@ -1,7 +1,7 @@
-import { existsSync, mkdirSync } from "node:fs";
+import { existsSync, mkdirSync, lstatSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { loadFile, parsePlan, parseRoadmap, parseSummary, saveFile, parseTaskPlanMustHaves, countMustHavesMentionedInSummary } from "./files.js";
-import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTasksDir, milestonesDir, relMilestoneFile, relSliceFile, relTaskFile, relSlicePath, relGsdRootFile, resolveGsdRootFile } from "./paths.js";
+import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTasksDir, milestonesDir, gsdRoot, relMilestoneFile, relSliceFile, relTaskFile, relSlicePath, relGsdRootFile, resolveGsdRootFile, relMilestonePath } from "./paths.js";
 import { deriveState, isMilestoneComplete } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
@@ -9,7 +9,7 @@ import { COMPLETION_TRANSITION_CODES } from "./doctor-types.js";
 import { checkGitHealth, checkRuntimeHealth } from "./doctor-checks.js";
 import { checkEnvironmentHealth } from "./doctor-environment.js";
 import { runProviderChecks } from "./doctor-providers.js";
-export { summarizeDoctorIssues, filterDoctorIssues, formatDoctorReport, formatDoctorIssuesForPrompt } from "./doctor-format.js";
+export { summarizeDoctorIssues, filterDoctorIssues, formatDoctorReport, formatDoctorIssuesForPrompt, formatDoctorReportJson } from "./doctor-format.js";
 export { runEnvironmentChecks, runFullEnvironmentChecks, formatEnvironmentReport } from "./doctor-environment.js";
 export { computeProgressScore, computeProgressScoreWithContext, formatProgressLine, formatProgressReport } from "./progress-score.js";
 /**
@@ -324,10 +324,68 @@ export async function selectDoctorScope(basePath, requestedScope) {
     }
     return state.registry[0]?.id;
 }
+// ── Helper: circular dependency detection ──────────────────────────────────
+function detectCircularDependencies(slices) {
+    const known = new Set(slices.map(s => s.id));
+    const adj = new Map();
+    for (const s of slices)
+        adj.set(s.id, s.depends.filter(d => known.has(d)));
+    const state = new Map();
+    for (const s of slices)
+        state.set(s.id, "unvisited");
+    const cycles = [];
+    function dfs(id, path) {
+        const st = state.get(id);
+        if (st === "done")
+            return;
+        if (st === "visiting") {
+            cycles.push([...path.slice(path.indexOf(id)), id]);
+            return;
+        }
+        state.set(id, "visiting");
+        for (const dep of adj.get(id) ?? [])
+            dfs(dep, [...path, id]);
+        state.set(id, "done");
+    }
+    for (const s of slices)
+        if (state.get(s.id) === "unvisited")
+            dfs(s.id, []);
+    return cycles;
+}
+async function appendDoctorHistory(basePath, report) {
+    try {
+        const historyPath = join(gsdRoot(basePath), "doctor-history.jsonl");
+        const entry = JSON.stringify({
+            ts: new Date().toISOString(),
+            ok: report.ok,
+            errors: report.issues.filter(i => i.severity === "error").length,
+            warnings: report.issues.filter(i => i.severity === "warning").length,
+            fixes: report.fixesApplied.length,
+            codes: [...new Set(report.issues.map(i => i.code))],
+        });
+        const existing = existsSync(historyPath) ? readFileSync(historyPath, "utf-8") : "";
+        await saveFile(historyPath, existing + entry + "\n");
+    }
+    catch { /* non-fatal */ }
+}
+/** Read the last N doctor history entries. Returns most-recent-first. */
+export async function readDoctorHistory(basePath, lastN = 50) {
+    try {
+        const historyPath = join(gsdRoot(basePath), "doctor-history.jsonl");
+        if (!existsSync(historyPath))
+            return [];
+        const lines = readFileSync(historyPath, "utf-8").split("\n").filter(l => l.trim());
+        return lines.slice(-lastN).reverse().map(l => JSON.parse(l));
+    }
+    catch {
+        return [];
+    }
+}
 export async function runGSDDoctor(basePath, options) {
     const issues = [];
     const fixesApplied = [];
     const fix = options?.fix === true;
+    const dryRun = options?.dryRun === true;
     const fixLevel = options?.fixLevel ?? "all";
     // Issue codes that represent completion state transitions — creating summary
     // stubs, marking slices/milestones done in the roadmap. These belong to the
@@ -336,12 +394,18 @@ export async function runGSDDoctor(basePath, options) {
     // detected and reported but never auto-fixed.
     /** Whether a given issue code should be auto-fixed at the current fixLevel. */
     const shouldFix = (code) => {
-        if (!fix)
+        if (!fix || dryRun)
             return false;
         if (fixLevel === "task" && COMPLETION_TRANSITION_CODES.has(code))
             return false;
         return true;
     };
+    /** Log a dry-run "would fix" entry when fix=true but dryRun=true. */
+    const dryRunCanFix = (code, message) => {
+        if (dryRun && fix && !(fixLevel === "task" && COMPLETION_TRANSITION_CODES.has(code))) {
+            fixesApplied.push(`[dry-run] would fix: ${message}`);
+        }
+    };
     const prefs = loadEffectiveGSDPreferences();
     if (prefs) {
         const prefIssues = validatePreferenceShape(prefs.preferences);
@@ -357,18 +421,30 @@ export async function runGSDDoctor(basePath, options) {
             });
         }
     }
-    // Git health checks (orphaned worktrees, stale branches, corrupt merge state, tracked runtime files)
+    // Git health checks — timed
+    const t0git = Date.now();
     const isolationMode = options?.isolationMode ??
         (prefs?.preferences?.git?.isolation === "none" ? "none" :
             prefs?.preferences?.git?.isolation === "branch" ? "branch" : "worktree");
     await checkGitHealth(basePath, issues, fixesApplied, shouldFix, isolationMode);
-    // Runtime health checks (crash locks, completed-units, hook state, activity logs, STATE.md, gitignore)
+    const gitMs = Date.now() - t0git;
+    // Runtime health checks — timed
+    const t0runtime = Date.now();
     await checkRuntimeHealth(basePath, issues, fixesApplied, shouldFix);
-    // Environment health checks (#1221: missing tools, port conflicts, stale deps, disk space)
-    await checkEnvironmentHealth(basePath, issues, { includeRemote: !options?.scope });
+    const runtimeMs = Date.now() - t0runtime;
+    // Environment health checks — timed
+    const t0env = Date.now();
+    await checkEnvironmentHealth(basePath, issues, {
+        includeRemote: !options?.scope,
+        includeBuild: options?.includeBuild,
+        includeTests: options?.includeTests,
+    });
+    const envMs = Date.now() - t0env;
     const milestonesPath = milestonesDir(basePath);
     if (!existsSync(milestonesPath)) {
-        return { ok: issues.every(issue => issue.severity !== "error"), basePath, issues, fixesApplied };
+        const report = { ok: issues.every(i => i.severity !== "error"), basePath, issues, fixesApplied, timing: { git: gitMs, runtime: runtimeMs, environment: envMs, gsdState: 0 } };
+        await appendDoctorHistory(basePath, report);
+        return report;
     }
     const requirementsPath = resolveGsdRootFile(basePath, "REQUIREMENTS");
     const requirementsContent = await loadFile(requirementsPath);
@@ -432,6 +508,46 @@ export async function runGSDDoctor(basePath, options) {
         if (!roadmapContent)
             continue;
         const roadmap = parseRoadmap(roadmapContent);
+        // ── Circular dependency detection ──────────────────────────────────────
+        for (const cycle of detectCircularDependencies(roadmap.slices)) {
+            issues.push({
+                severity: "error",
+                code: "circular_slice_dependency",
+                scope: "milestone",
+                unitId: milestoneId,
+                message: `Circular dependency detected: ${cycle.join(" → ")}`,
+                file: relMilestoneFile(basePath, milestoneId, "ROADMAP"),
+                fixable: false,
+            });
+        }
+        // ── Orphaned slice directories ─────────────────────────────────────────
+        try {
+            const slicesDir = join(milestonePath, "slices");
+            if (existsSync(slicesDir)) {
+                const knownSliceIds = new Set(roadmap.slices.map(s => s.id));
+                for (const entry of readdirSync(slicesDir)) {
+                    try {
+                        if (!lstatSync(join(slicesDir, entry)).isDirectory())
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (!knownSliceIds.has(entry)) {
+                        issues.push({
+                            severity: "warning",
+                            code: "orphaned_slice_directory",
+                            scope: "milestone",
+                            unitId: milestoneId,
+                            message: `Directory "${entry}" exists in ${milestoneId}/slices/ but is not referenced in the roadmap`,
+                            file: `${relMilestonePath(basePath, milestoneId)}/slices/${entry}`,
+                            fixable: false,
+                        });
+                    }
+                }
+            }
+        }
+        catch { /* non-fatal */ }
         for (const slice of roadmap.slices) {
             const unitId = `${milestoneId}/${slice.id}`;
             if (options?.scope && !matchesScope(unitId, options.scope) && options.scope !== milestoneId)
@@ -502,6 +618,34 @@ export async function runGSDDoctor(basePath, options) {
                 }
                 continue;
             }
+            // ── Duplicate task IDs ───────────────────────────────────────────────
+            const taskIdCounts = new Map();
+            for (const task of plan.tasks)
+                taskIdCounts.set(task.id, (taskIdCounts.get(task.id) ?? 0) + 1);
+            for (const [taskId, count] of taskIdCounts) {
+                if (count > 1) {
+                    issues.push({ severity: "error", code: "duplicate_task_id", scope: "slice", unitId,
+                        message: `Task ID "${taskId}" appears ${count} times in ${slice.id}-PLAN.md — duplicate IDs cause dispatch failures`,
+                        file: relSliceFile(basePath, milestoneId, slice.id, "PLAN"), fixable: false });
+                }
+            }
+            // ── Task files on disk not in plan ────────────────────────────────────
+            try {
+                if (tasksDir) {
+                    const planTaskIds = new Set(plan.tasks.map(t => t.id));
+                    for (const f of readdirSync(tasksDir)) {
+                        if (!f.endsWith("-SUMMARY.md"))
+                            continue;
+                        const diskTaskId = f.replace(/-SUMMARY\.md$/, "");
+                        if (!planTaskIds.has(diskTaskId)) {
+                            issues.push({ severity: "info", code: "task_file_not_in_plan", scope: "slice", unitId,
+                                message: `Task summary "${f}" exists on disk but "${diskTaskId}" is not in ${slice.id}-PLAN.md`,
+                                file: relTaskFile(basePath, milestoneId, slice.id, diskTaskId, "SUMMARY"), fixable: false });
+                        }
+                    }
+                }
+            }
+            catch { /* non-fatal */ }
             let allTasksDone = plan.tasks.length > 0;
             for (const task of plan.tasks) {
                 const taskUnitId = `${unitId}/${task.id}`;
@@ -517,6 +661,7 @@ export async function runGSDDoctor(basePath, options) {
                         file: relTaskFile(basePath, milestoneId, slice.id, task.id, "SUMMARY"),
                         fixable: true,
                     });
+                    dryRunCanFix("task_done_missing_summary", `create stub summary for ${taskUnitId}`);
                     if (shouldFix("task_done_missing_summary")) {
                         const stubPath = join(basePath, ".gsd", "milestones", milestoneId, "slices", slice.id, "tasks", `${task.id}-SUMMARY.md`);
                         const stubContent = [
@@ -575,6 +720,22 @@ export async function runGSDDoctor(basePath, options) {
                         }
                     }
                 }
+                // ── Future timestamp check ─────────────────────────────────────
+                if (task.done && hasSummary && summaryPath) {
+                    try {
+                        const rawSummary = await loadFile(summaryPath);
+                        const m = rawSummary?.match(/^completed_at:\s*(.+)$/m);
+                        if (m) {
+                            const ts = new Date(m[1].trim());
+                            if (!isNaN(ts.getTime()) && ts.getTime() > Date.now() + 24 * 60 * 60 * 1000) {
+                                issues.push({ severity: "warning", code: "future_timestamp", scope: "task", unitId: taskUnitId,
+                                    message: `Task ${task.id} has completed_at "${m[1].trim()}" which is more than 24h in the future`,
+                                    file: relTaskFile(basePath, milestoneId, slice.id, task.id, "SUMMARY"), fixable: false });
+                            }
+                        }
+                    }
+                    catch { /* non-fatal */ }
+                }
                 allTasksDone = allTasksDone && task.done;
             }
             // Blocker-without-replan detection
@@ -604,6 +765,12 @@ export async function runGSDDoctor(basePath, options) {
                     }
                 }
             }
+            // ── Stale REPLAN: exists but all tasks done ────────────────────────
+            if (replanPath && allTasksDone) {
+                issues.push({ severity: "info", code: "stale_replan_file", scope: "slice", unitId,
+                    message: `${slice.id} has a REPLAN.md but all tasks are done — REPLAN.md may be stale`,
+                    file: relSliceFile(basePath, milestoneId, slice.id, "REPLAN"), fixable: false });
+            }
             const sliceSummaryPath = resolveSliceFile(basePath, milestoneId, slice.id, "SUMMARY");
             const sliceUatPath = join(slicePath, `${slice.id}-UAT.md`);
             const hasSliceSummary = !!(sliceSummaryPath && await loadFile(sliceSummaryPath));
@@ -618,6 +785,7 @@ export async function runGSDDoctor(basePath, options) {
                     file: relSliceFile(basePath, milestoneId, slice.id, "SUMMARY"),
                     fixable: true,
                 });
+                dryRunCanFix("all_tasks_done_missing_slice_summary", `create placeholder summary for ${unitId}`);
                 if (shouldFix("all_tasks_done_missing_slice_summary"))
                     await ensureSliceSummaryStub(basePath, milestoneId, slice.id, fixesApplied);
             }
@@ -631,6 +799,7 @@ export async function runGSDDoctor(basePath, options) {
                     file: `${relSlicePath(basePath, milestoneId, slice.id)}/${slice.id}-UAT.md`,
                     fixable: true,
                 });
+                dryRunCanFix("all_tasks_done_missing_slice_uat", `create placeholder UAT for ${unitId}`);
                 if (shouldFix("all_tasks_done_missing_slice_uat"))
                     await ensureSliceUatStub(basePath, milestoneId, slice.id, fixesApplied);
             }
@@ -644,6 +813,7 @@ export async function runGSDDoctor(basePath, options) {
                     file: relMilestoneFile(basePath, milestoneId, "ROADMAP"),
                     fixable: true,
                 });
+                dryRunCanFix("all_tasks_done_roadmap_not_checked", `mark ${slice.id} done in roadmap`);
                 if (shouldFix("all_tasks_done_roadmap_not_checked") && (hasSliceSummary || issues.some(issue => issue.code === "all_tasks_done_missing_slice_summary" && issue.unitId === unitId))) {
                     await markSliceDoneInRoadmap(basePath, milestoneId, slice.id, fixesApplied);
                 }
@@ -696,13 +866,16 @@ export async function runGSDDoctor(basePath, options) {
             });
         }
     }
-    if (fix && fixesApplied.length > 0) {
+    if (fix && !dryRun && fixesApplied.length > 0) {
         await updateStateFile(basePath, fixesApplied);
     }
-    return {
+    const report = {
         ok: issues.every(issue => issue.severity !== "error"),
         basePath,
         issues,
         fixesApplied,
+        timing: { git: gitMs, runtime: runtimeMs, environment: envMs, gsdState: Math.max(0, Date.now() - t0env - envMs) },
     };
+    await appendDoctorHistory(basePath, report);
+    return report;
 }

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

@@ -5,7 +5,7 @@ import { join, basename } from "node:path";
 import { exec } from "node:child_process";
 import { getLedger, getProjectTotals, aggregateByPhase, aggregateBySlice, aggregateByModel, formatCost, formatTokenCount, loadLedgerFromDisk, } from "./metrics.js";
 import { gsdRoot } from "./paths.js";
-import { formatDuration, fileLink } from "../shared/mod.js";
+import { formatDuration, fileLink } from "../shared/format-utils.js";
 import { getErrorMessage } from "./error-utils.js";
 /**
  * Open a file in the user's default browser.

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

@@ -6,8 +6,8 @@ import { promises as fs } from 'node:fs';
 import { resolve } from 'node:path';
 import { atomicWriteAsync } from './atomic-write.js';
 import { resolveMilestoneFile, relMilestoneFile, resolveGsdRootFile } from './paths.js';
-import { findMilestoneIds } from './guided-flow.js';
-import { checkExistingEnvKeys } from '../get-secrets-from-user.js';
+import { findMilestoneIds } from './milestone-ids.js';
+import { checkExistingEnvKeys } from '../env-utils.js';
 import { parseRoadmapSlices } from './roadmap-slices.js';
 import { nativeParseRoadmap, nativeExtractSection, nativeParsePlanFile, nativeParseSummaryFile, NATIVE_UNAVAILABLE } from './native-parser-bridge.js';
 import { debugTime, debugCount } from './debug-logger.js';
@@ -629,6 +629,47 @@ export function countMustHavesMentionedInSummary(mustHaves, summaryContent) {
     }
     return count;
 }
+// ─── Task Plan IO Extractor ────────────────────────────────────────────────
+/**
+ * Extract input and output file paths from a task plan's `## Inputs` and
+ * `## Expected Output` sections. Looks for backtick-wrapped file paths on
+ * each line (e.g. `` `src/foo.ts` ``).
+ *
+ * Returns empty arrays for missing/empty sections — callers should treat
+ * tasks with no IO as ambiguous (sequential fallback trigger).
+ */
+export function parseTaskPlanIO(content) {
+    const backtickPathRegex = /`([^`]+)`/g;
+    function extractPaths(sectionText) {
+        if (!sectionText)
+            return [];
+        const paths = [];
+        for (const line of sectionText.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#"))
+                continue;
+            let match;
+            backtickPathRegex.lastIndex = 0;
+            while ((match = backtickPathRegex.exec(trimmed)) !== null) {
+                const candidate = match[1];
+                // Filter out things that look like code tokens rather than file paths
+                // (e.g. `true`, `false`, `npm run test`). A file path has at least one
+                // dot or slash.
+                if (candidate.includes("/") || candidate.includes(".")) {
+                    paths.push(candidate);
+                }
+            }
+        }
+        return paths;
+    }
+    const [, body] = splitFrontmatter(content);
+    const inputSection = extractSection(body, "Inputs");
+    const outputSection = extractSection(body, "Expected Output");
+    return {
+        inputFiles: extractPaths(inputSection),
+        outputFiles: extractPaths(outputSection),
+    };
+}
 /**
  * Extract the UAT type from a UAT file's raw content.
  *

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

@@ -21,7 +21,7 @@ import { deriveState } from "./state.js";
 import { isAutoActive } from "./auto.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { gsdRoot } from "./paths.js";
-import { formatDuration } from "../shared/mod.js";
+import { formatDuration } from "../shared/format-utils.js";
 import { getAutoWorktreePath } from "./auto-worktree.js";
 // ─── Entry Point ──────────────────────────────────────────────────────────────
 export async function handleForensics(args, ctx, pi) {

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

@@ -41,6 +41,7 @@ import { join } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { shortcutDesc } from "../shared/mod.js";
+const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
 import { Text } from "@gsd/pi-tui";
 import { pauseAutoForProviderError, classifyProviderError } from "./provider-error-pause.js";
 import { toPosixPath } from "../shared/mod.js";
@@ -52,7 +53,7 @@ import { markCmuxPromptShown, shouldPromptToEnableCmux } from "../cmux/index.js"
 // Pi core natively supports AGENTS.md (with CLAUDE.md fallback) per directory.
 function warnDeprecatedAgentInstructions() {
     const paths = [
-        join(homedir(), ".gsd", "agent-instructions.md"),
+        join(gsdHome, "agent-instructions.md"),
         join(process.cwd(), ".gsd", "agent-instructions.md"),
     ];
     for (const p of paths) {

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

@@ -2,7 +2,7 @@
 // Pure functions that take file content (string) and return typed data.
 // Zero Pi dependencies — uses only exported helpers from files.ts.
 import { splitFrontmatter, parseFrontmatterMap, extractBoldField } from '../files.js';
-import { normalizeStringArray } from '../../shared/mod.js';
+import { normalizeStringArray } from '../../shared/format-utils.js';
 // Re-export PlanningProjectMeta — not in types.ts yet, use string for project field
 // Actually PlanningProjectMeta isn't in types.ts — project is stored as string | null.
 // We'll keep parseOldProject returning a simple shape.

package/dist/resources/extensions/gsd/observability-validator.js

@@ -209,6 +209,30 @@ export function validateTaskPlanContent(file, content) {
             }
         }
     }
+    // Rule: Inputs and Expected Output should contain backtick-wrapped file paths
+    const inputsSection = getSection(content, "Inputs", 2);
+    const outputSection = getSection(content, "Expected Output", 2);
+    const backtickPathPattern = /`[^`]*[./][^`]*`/;
+    if (outputSection === null || !backtickPathPattern.test(outputSection)) {
+        issues.push({
+            severity: "warning",
+            scope: "task-plan",
+            file,
+            ruleId: "missing_output_file_paths",
+            message: "Task plan `## Expected Output` is missing or has no backtick-wrapped file paths.",
+            suggestion: "List concrete output file paths in backticks (e.g. `src/types.ts`). These are machine-parsed to derive task dependencies.",
+        });
+    }
+    if (inputsSection !== null && inputsSection.trim().length > 0 && !backtickPathPattern.test(inputsSection)) {
+        issues.push({
+            severity: "info",
+            scope: "task-plan",
+            file,
+            ruleId: "missing_input_file_paths",
+            message: "Task plan `## Inputs` has content but no backtick-wrapped file paths.",
+            suggestion: "List input file paths in backticks (e.g. `src/config.json`). These are machine-parsed to derive task dependencies.",
+        });
+    }
     // ── Observability rules (gated by runtime relevance) ──
     const relevant = textSuggestsObservabilityRelevant(content);
     if (!relevant)

package/dist/resources/extensions/gsd/package.json

@@ -5,7 +5,7 @@
   "type": "module",
   "pi": {
     "extensions": [
-      "./index.ts"
+      "./index.js"
     ]
   }
 }

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

@@ -260,18 +260,6 @@ export function resolveInlineLevel() {
         case "quality": return "full";
     }
 }
-/**
- * Resolve the compression strategy from the active token profile.
- * budget/balanced -> "compress", quality -> "truncate".
- * Explicit preference always wins.
- */
-export function resolveCompressionStrategy() {
-    const prefs = loadEffectiveGSDPreferences();
-    if (prefs?.preferences.compression_strategy)
-        return prefs.preferences.compression_strategy;
-    const profile = resolveEffectiveProfile();
-    return profile === "quality" ? "truncate" : "compress";
-}
 /**
  * Resolve the context selection mode from the active token profile.
  * budget -> "smart", balanced/quality -> "full".

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

@@ -62,14 +62,14 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "verification_auto_fix",
     "verification_max_retries",
     "search_provider",
-    "compression_strategy",
     "context_selection",
     "widget_mode",
+    "reactive_execution",
 ]);
 /** Canonical list of all dispatch unit types. */
 export const KNOWN_UNIT_TYPES = [
     "research-milestone", "plan-milestone", "research-slice", "plan-slice",
-    "execute-task", "complete-slice", "replan-slice", "reassess-roadmap",
+    "execute-task", "reactive-execute", "complete-slice", "replan-slice", "reassess-roadmap",
     "run-uat", "complete-milestone",
 ];
 export const SKILL_ACTIONS = new Set(["use", "prefer", "avoid"]);

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

@@ -6,7 +6,7 @@
  * together with any errors and warnings.
  */
 import { VALID_BRANCH_NAME } from "./git-service.js";
-import { normalizeStringArray } from "../shared/mod.js";
+import { normalizeStringArray } from "../shared/format-utils.js";
 import { KNOWN_PREFERENCE_KEYS, KNOWN_UNIT_TYPES, SKILL_ACTIONS, } from "./preferences-types.js";
 const VALID_TOKEN_PROFILES = new Set(["budget", "balanced", "quality"]);
 export function validatePreferences(preferences) {
@@ -500,6 +500,48 @@ export function validatePreferences(preferences) {
             validated.parallel = parallel;
         }
     }
+    // ─── Reactive Execution ─────────────────────────────────────────────────
+    if (preferences.reactive_execution !== undefined) {
+        if (typeof preferences.reactive_execution === "object" && preferences.reactive_execution !== null) {
+            const re = preferences.reactive_execution;
+            const validRe = {};
+            if (re.enabled !== undefined) {
+                if (typeof re.enabled === "boolean")
+                    validRe.enabled = re.enabled;
+                else
+                    errors.push("reactive_execution.enabled must be a boolean");
+            }
+            if (re.max_parallel !== undefined) {
+                const mp = typeof re.max_parallel === "number" ? re.max_parallel : Number(re.max_parallel);
+                if (Number.isFinite(mp) && mp >= 1 && mp <= 8) {
+                    validRe.max_parallel = Math.floor(mp);
+                }
+                else {
+                    errors.push("reactive_execution.max_parallel must be a number between 1 and 8");
+                }
+            }
+            if (re.isolation_mode !== undefined) {
+                if (re.isolation_mode === "same-tree") {
+                    validRe.isolation_mode = "same-tree";
+                }
+                else {
+                    errors.push('reactive_execution.isolation_mode must be "same-tree"');
+                }
+            }
+            const knownReKeys = new Set(["enabled", "max_parallel", "isolation_mode"]);
+            for (const key of Object.keys(re)) {
+                if (!knownReKeys.has(key)) {
+                    warnings.push(`unknown reactive_execution key "${key}" — ignored`);
+                }
+            }
+            if (Object.keys(validRe).length > 0) {
+                validated.reactive_execution = validRe;
+            }
+        }
+        else {
+            errors.push("reactive_execution must be an object");
+        }
+    }
     // ─── Verification Preferences ───────────────────────────────────────────
     if (preferences.verification_commands !== undefined) {
         if (Array.isArray(preferences.verification_commands)) {
@@ -665,16 +707,6 @@ export function validatePreferences(preferences) {
             errors.push("auto_report must be a boolean");
         }
     }
-    // ─── Compression Strategy ───────────────────────────────────────────
-    if (preferences.compression_strategy !== undefined) {
-        const validStrategies = new Set(["truncate", "compress"]);
-        if (typeof preferences.compression_strategy === "string" && validStrategies.has(preferences.compression_strategy)) {
-            validated.compression_strategy = preferences.compression_strategy;
-        }
-        else {
-            errors.push(`compression_strategy must be one of: truncate, compress`);
-        }
-    }
     // ─── Context Selection ──────────────────────────────────────────────
     if (preferences.context_selection !== undefined) {
         const validModes = new Set(["full", "smart"]);

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

@@ -12,9 +12,10 @@
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
 import { gsdRoot } from "./paths.js";
 import { parse as parseYaml } from "yaml";
-import { normalizeStringArray } from "../shared/mod.js";
+import { normalizeStringArray } from "../shared/format-utils.js";
 import { resolveProfileDefaults as _resolveProfileDefaults } from "./preferences-models.js";
 import { MODE_DEFAULTS, } from "./preferences-types.js";
 import { validatePreferences } from "./preferences-validation.js";
@@ -24,16 +25,16 @@ export { validatePreferences } from "./preferences-validation.js";
 // ─── Re-exports: skills ─────────────────────────────────────────────────────
 export { resolveAllSkillReferences, resolveSkillDiscoveryMode, resolveSkillStalenessDays, } from "./preferences-skills.js";
 // ─── Re-exports: models ─────────────────────────────────────────────────────
-export { resolveModelForUnit, resolveModelWithFallbacksForUnit, getNextFallbackModel, isTransientNetworkError, validateModelId, updatePreferencesModels, resolveDynamicRoutingConfig, resolveAutoSupervisorConfig, resolveProfileDefaults, resolveEffectiveProfile, resolveInlineLevel, resolveCompressionStrategy, resolveContextSelection, resolveSearchProviderFromPreferences, } from "./preferences-models.js";
+export { resolveModelForUnit, resolveModelWithFallbacksForUnit, getNextFallbackModel, isTransientNetworkError, validateModelId, updatePreferencesModels, resolveDynamicRoutingConfig, resolveAutoSupervisorConfig, resolveProfileDefaults, resolveEffectiveProfile, resolveInlineLevel, resolveContextSelection, resolveSearchProviderFromPreferences, } from "./preferences-models.js";
 // ─── Path Constants & Getters ───────────────────────────────────────────────
-const GLOBAL_PREFERENCES_PATH = join(homedir(), ".gsd", "preferences.md");
+const GLOBAL_PREFERENCES_PATH = join(gsdHome, "preferences.md");
 const LEGACY_GLOBAL_PREFERENCES_PATH = join(homedir(), ".pi", "agent", "gsd-preferences.md");
 function projectPreferencesPath() {
     return join(gsdRoot(process.cwd()), "preferences.md");
 }
 // Bootstrap in gitignore.ts historically created PREFERENCES.md (uppercase) by mistake.
 // Check uppercase as a fallback so those files aren't silently ignored.
-const GLOBAL_PREFERENCES_PATH_UPPERCASE = join(homedir(), ".gsd", "PREFERENCES.md");
+const GLOBAL_PREFERENCES_PATH_UPPERCASE = join(gsdHome, "PREFERENCES.md");
 function projectPreferencesPathUppercase() {
     return join(gsdRoot(process.cwd()), "PREFERENCES.md");
 }
@@ -199,7 +200,6 @@ function mergePreferences(base, override) {
         verification_auto_fix: override.verification_auto_fix ?? base.verification_auto_fix,
         verification_max_retries: override.verification_max_retries ?? base.verification_max_retries,
         search_provider: override.search_provider ?? base.search_provider,
-        compression_strategy: override.compression_strategy ?? base.compression_strategy,
         context_selection: override.context_selection ?? base.context_selection,
         auto_visualize: override.auto_visualize ?? base.auto_visualize,
         auto_report: override.auto_report ?? base.auto_report,