gsd-pi 2.75.0 → 2.76.0

package/dist/resources/extensions/gsd/notification-overlay.js

@@ -1,7 +1,7 @@
 // GSD Extension — Notification History Overlay
 // Scrollable panel showing all persisted notifications with severity filtering.
 // Toggled with Ctrl+Alt+N (⌃⌥N on macOS), Ctrl+Shift+N fallback, or /gsd notifications.
-import { truncateToWidth, visibleWidth, matchesKey, Key } from "@gsd/pi-tui";
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi, matchesKey, Key } from "@gsd/pi-tui";
 import { readNotifications, markAllRead, clearNotifications, onNotificationStoreChange, } from "./notification-store.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
 import { padRight, joinColumns } from "../shared/mod.js";
@@ -15,29 +15,14 @@ function severityIcon(severity) {
         default: return "●";
     }
 }
-/** Word-wrap plain text to fit within maxWidth columns. */
+/** Column-aware word wrap using pi-tui's native wrapper (handles unicode/ANSI). */
 function wrapText(text, maxWidth) {
-    if (text.length <= maxWidth)
+    if (maxWidth <= 0)
         return [text];
-    const words = text.split(/\s+/);
-    const lines = [];
-    let current = "";
-    for (const word of words) {
-        if (current.length === 0) {
-            current = word;
-        }
-        else if (current.length + 1 + word.length <= maxWidth) {
-            current += " " + word;
-        }
-        else {
-            lines.push(current);
-            current = word;
-        }
-    }
-    if (current.length > 0)
-        lines.push(current);
-    // If a single word exceeds maxWidth, truncate it
-    return lines.map((l) => l.length > maxWidth ? l.slice(0, maxWidth - 1) + "…" : l);
+    const lines = wrapTextWithAnsi(text, maxWidth);
+    // Safety clamp: if any line still exceeds maxWidth (e.g. unbreakable long token),
+    // truncate it with an ellipsis so it cannot bleed past the box border.
+    return lines.map((l) => visibleWidth(l) > maxWidth ? truncateToWidth(l, maxWidth, "…") : l);
 }
 function formatTimestamp(ts) {
     try {

package/dist/resources/extensions/gsd/notification-widget.js

@@ -1,49 +1,34 @@
-// GSD Extension — Notification Widget
-// Always-on ambient widget rendered belowEditor showing unread count and
-// the most recent notification message. Refreshes every 30 seconds.
-// Widget key: "gsd-notifications", placement: "belowEditor"
+// GSD Extension — Notification Status
+// Always-on ambient notification chip surfaced as an extension status on the
+// footer pwd row. Refreshes on store change + on a 30s timer. Hidden when
+// unread=0. Key sorts late so the chip renders to the right of other
+// extension statuses.
 import { getUnreadCount, onNotificationStoreChange } from "./notification-store.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
-// ─── Pure rendering ──���────────────────────────���─────────────────────────
-export function buildNotificationWidgetLines() {
+// Key chosen to sort after alphabetic extension keys so the chip lands on the
+// far right of the extension-status block.
+const STATUS_KEY = "zz-notifications";
+export function buildNotificationChip() {
     const unread = getUnreadCount();
     if (unread === 0)
-        return [];
-    return [`  🔔 Notifications: ${unread} unread  (${formattedShortcutPair("notifications")})`];
+        return "";
+    return `🔔 ${unread} unread (${formattedShortcutPair("notifications")})`;
+}
+// Retained for backwards compatibility with tests and the RPC fallback path
+// that still expected a line-array widget. Returns empty when no unread.
+export function buildNotificationWidgetLines() {
+    const chip = buildNotificationChip();
+    return chip ? [`  ${chip}`] : [];
 }
-// ─── Widget init ────────────────────────────────────────────────────────
 const REFRESH_INTERVAL_MS = 30_000;
-/**
- * Initialize the always-on notification widget (belowEditor).
- * Call once from session_start after the notification store is initialized.
- */
 export function initNotificationWidget(ctx) {
     if (!ctx.hasUI)
         return;
-    // String-array fallback for RPC mode
-    ctx.ui.setWidget("gsd-notifications", buildNotificationWidgetLines(), { placement: "belowEditor" });
-    // Factory-based widget for TUI mode
-    ctx.ui.setWidget("gsd-notifications", (_tui, _theme) => {
-        let cachedLines;
-        const refresh = () => {
-            cachedLines = undefined;
-            _tui.requestRender();
-        };
-        const unsubscribe = onNotificationStoreChange(refresh);
-        const refreshTimer = setInterval(refresh, REFRESH_INTERVAL_MS);
-        return {
-            render(_width) {
-                if (!cachedLines)
-                    cachedLines = buildNotificationWidgetLines();
-                return cachedLines;
-            },
-            invalidate() {
-                cachedLines = undefined;
-            },
-            dispose() {
-                unsubscribe();
-                clearInterval(refreshTimer);
-            },
-        };
-    }, { placement: "belowEditor" });
+    const push = () => {
+        const chip = buildNotificationChip();
+        ctx.ui.setStatus(STATUS_KEY, chip.length > 0 ? chip : undefined);
+    };
+    push();
+    onNotificationStoreChange(push);
+    setInterval(push, REFRESH_INTERVAL_MS).unref?.();
 }

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

@@ -3,6 +3,7 @@
 import { execFileSync } from "node:child_process";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { CmuxClient, emitOsc777Notification, resolveCmuxConfig } from "../cmux/index.js";
+import { sendRemoteNotification } from "../remote-questions/notify.js";
 /**
  * Send a native desktop notification. Non-blocking, non-fatal.
  * macOS: osascript, Linux: notify-send, Windows: skipped.
@@ -14,6 +15,9 @@ export function sendDesktopNotification(title, message, level = "info", kind = "
         title = formatNotificationTitle(projectName);
     }
     const loaded = loadEffectiveGSDPreferences()?.preferences;
+    // Remote notifications fire independently of desktop preferences.
+    // sendRemoteNotification handles "not configured" gracefully (early return).
+    void sendRemoteNotification(title, message).catch(() => { });
     if (!shouldSendDesktopNotification(kind, loaded?.notifications))
         return;
     const cmux = resolveCmuxConfig(loaded);

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

@@ -0,0 +1,133 @@
+// GSD — Onboarding completion record (~/.gsd/agent/onboarding.json)
+//
+// First-class state for the onboarding wizard so re-entry, resume, and the
+// 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";
+/**
+ * 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"
+ * by isOnboardingComplete().
+ */
+export const FLOW_VERSION = 1;
+const RECORD_VERSION = 1;
+// Inline agentDir computation (mirrors src/app-paths.ts) — keep this module
+// 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");
+const FILE = join(AGENT_DIR, "onboarding.json");
+const DEFAULT = {
+    version: RECORD_VERSION,
+    flowVersion: FLOW_VERSION,
+    completedAt: null,
+    completedSteps: [],
+    skippedSteps: [],
+    lastResumePoint: null,
+};
+export function readOnboardingRecord() {
+    if (!existsSync(FILE))
+        return { ...DEFAULT };
+    try {
+        const raw = JSON.parse(readFileSync(FILE, "utf-8"));
+        return {
+            version: typeof raw.version === "number" ? raw.version : RECORD_VERSION,
+            flowVersion: typeof raw.flowVersion === "number" ? raw.flowVersion : 0,
+            completedAt: typeof raw.completedAt === "string" ? raw.completedAt : null,
+            completedSteps: Array.isArray(raw.completedSteps) ? raw.completedSteps.filter(s => typeof s === "string") : [],
+            skippedSteps: Array.isArray(raw.skippedSteps) ? raw.skippedSteps.filter(s => typeof s === "string") : [],
+            lastResumePoint: typeof raw.lastResumePoint === "string" ? raw.lastResumePoint : null,
+        };
+    }
+    catch {
+        // Corrupt/unreadable — fall back to defaults rather than crashing onboarding flow
+        return { ...DEFAULT };
+    }
+}
+function atomicWrite(record) {
+    mkdirSync(dirname(FILE), { recursive: true });
+    const tmp = `${FILE}.tmp.${process.pid}.${Date.now()}`;
+    try {
+        writeFileSync(tmp, JSON.stringify(record, null, 2), "utf-8");
+        renameSync(tmp, FILE);
+    }
+    catch (err) {
+        // Best-effort: drop the tmp file if the rename failed (don't leak stale tmps)
+        try {
+            if (existsSync(tmp))
+                unlinkSync(tmp);
+        }
+        catch { /* swallow secondary error */ }
+        throw err;
+    }
+}
+export function writeOnboardingRecord(patch) {
+    const current = readOnboardingRecord();
+    const next = {
+        ...current,
+        ...patch,
+        version: RECORD_VERSION,
+        // flowVersion is sticky on writes unless explicitly patched
+        flowVersion: typeof patch.flowVersion === "number" ? patch.flowVersion : current.flowVersion,
+    };
+    try {
+        atomicWrite(next);
+    }
+    catch (err) {
+        // Non-fatal for the wizard, but make the failure diagnosable. The next boot
+        // will re-prompt for onboarding because the record didn't persist; the
+        // logWarning entry tells the user why.
+        logWarning("state", `Failed to persist onboarding record: ${err instanceof Error ? err.message : String(err)}`, {
+            file: FILE,
+        });
+    }
+    return next;
+}
+/**
+ * Onboarding is "complete" when there's a completedAt timestamp AND the
+ * flowVersion matches the current FLOW_VERSION. A flowVersion bump means
+ * a new required step exists and the user should re-enter to configure it.
+ */
+export function isOnboardingComplete() {
+    const r = readOnboardingRecord();
+    return r.completedAt !== null && r.flowVersion === FLOW_VERSION;
+}
+export function markStepCompleted(stepId) {
+    const r = readOnboardingRecord();
+    if (r.completedSteps.includes(stepId)) {
+        writeOnboardingRecord({ lastResumePoint: stepId });
+        return;
+    }
+    writeOnboardingRecord({
+        completedSteps: [...r.completedSteps, stepId],
+        skippedSteps: r.skippedSteps.filter(s => s !== stepId),
+        lastResumePoint: stepId,
+    });
+}
+export function markStepSkipped(stepId) {
+    const r = readOnboardingRecord();
+    if (r.skippedSteps.includes(stepId) || r.completedSteps.includes(stepId))
+        return;
+    writeOnboardingRecord({
+        skippedSteps: [...r.skippedSteps, stepId],
+        lastResumePoint: stepId,
+    });
+}
+export function markOnboardingComplete(completedSteps) {
+    writeOnboardingRecord({
+        completedAt: new Date().toISOString(),
+        flowVersion: FLOW_VERSION,
+        completedSteps,
+    });
+}
+export function resetOnboarding() {
+    writeOnboardingRecord({
+        completedAt: null,
+        completedSteps: [],
+        skippedSteps: [],
+        lastResumePoint: null,
+    });
+}

package/dist/resources/extensions/gsd/post-execution-checks.js

@@ -75,12 +75,36 @@ export function extractRelativeImports(source) {
 }
 /**
  * Check if a relative import resolves to an existing file.
- * Handles .ts, .tsx, .js, .jsx extensions and index files.
- * Also handles TypeScript ESM convention where imports use .js but resolve to .ts.
+ * Resolution order:
+ *   1. Imports carrying an explicit extension are checked as-is (handles assets
+ *      like .css/.scss/images/fonts and .json, not just code extensions).
+ *   2. TypeScript ESM convention where .js imports resolve to .ts files.
+ *   3. Extensionless imports resolved against .ts/.tsx/.js/.jsx/.mjs/.cjs.
+ *   4. Directory imports resolved against index.{ts,tsx,js,jsx,mjs,cjs}.
  */
 export function resolveImportPath(importPath, sourceFile, basePath) {
     const sourceDir = dirname(resolve(basePath, sourceFile));
     const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+    // If the import already has an explicit extension, check it as-is first.
+    // This correctly resolves asset imports like .css, .scss, images, fonts
+    // without requiring each extension to be enumerated (issue #4411). We only
+    // do this when the import carries an extension so that extensionless module
+    // imports still flow through the TS ESM convention and index-file resolvers.
+    const explicitExt = extname(importPath);
+    if (explicitExt !== "") {
+        const directPath = resolve(sourceDir, importPath);
+        if (existsSync(directPath)) {
+            return { exists: true, resolvedPath: directPath };
+        }
+        // Only .js/.jsx/.mjs/.cjs imports legitimately fall through for the TS
+        // ESM convention (.js → .ts). Any other explicit extension (.css, .json,
+        // .svg, images, fonts, .ts, .tsx, …) must stay unresolved when the direct
+        // path is missing — otherwise a stray `./missing.css.ts` could shadow a
+        // genuinely missing `./missing.css` import.
+        if (![".js", ".jsx", ".mjs", ".cjs"].includes(explicitExt)) {
+            return { exists: false, resolvedPath: null };
+        }
+    }
     // Handle TypeScript ESM convention: .js imports resolve to .ts files
     // e.g., import './types.js' -> ./types.ts
     let normalizedPath = importPath;
@@ -96,7 +120,7 @@ export function resolveImportPath(importPath, sourceFile, basePath) {
     else if (importPath.endsWith(".cjs")) {
         normalizedPath = importPath.slice(0, -4);
     }
-    // Try the normalized path with common extensions first
+    // Try the normalized path with common extensions
     for (const ext of extensions) {
         const fullPath = resolve(sourceDir, normalizedPath + ext);
         if (existsSync(fullPath)) {
@@ -110,14 +134,6 @@ export function resolveImportPath(importPath, sourceFile, basePath) {
             return { exists: true, resolvedPath: indexPath };
         }
     }
-    // Check if path already has extension (for .json, etc.)
-    const hasExt = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json"].some((ext) => importPath.endsWith(ext));
-    if (hasExt) {
-        const fullPath = resolve(sourceDir, importPath);
-        if (existsSync(fullPath)) {
-            return { exists: true, resolvedPath: fullPath };
-        }
-    }
     return { exists: false, resolvedPath: null };
 }
 /**

package/dist/resources/extensions/gsd/pre-execution-checks.js

@@ -15,6 +15,7 @@
  */
 import { existsSync } from "node:fs";
 import { spawn } from "node:child_process";
+import { homedir } from "node:os";
 import { resolve } from "node:path";
 const NPM_COMMAND = process.platform === "win32" ? "npm.cmd" : "npm";
 // ─── Package Existence Check ─────────────────────────────────────────────────
@@ -202,6 +203,16 @@ export function normalizeFilePath(filePath) {
     let normalized = extractPathFromAnnotation(filePath);
     // Normalize path separators to forward slashes
     normalized = normalized.replace(/\\/g, "/");
+    // Expand a leading ~ or ~/ so downstream resolve()/set lookups hit the real
+    // home directory instead of treating the tilde as a literal path segment.
+    if (normalized === "~") {
+        normalized = homedir();
+    }
+    else if (normalized.startsWith("~/")) {
+        normalized = resolve(homedir(), normalized.slice(2));
+    }
+    // homedir()/resolve() can emit platform separators (e.g. "\" on Windows).
+    normalized = normalized.replace(/\\/g, "/");
     // Remove leading ./
     while (normalized.startsWith("./")) {
         normalized = normalized.slice(2);
@@ -214,6 +225,49 @@ export function normalizeFilePath(filePath) {
     }
     return normalized;
 }
+/**
+ * Planning units sometimes pass a directory reference as task.inputs
+ * (e.g. `artifacts/M009-S03/`). The trailing slash is meaningful — the task
+ * reads whatever lands inside — but normalizeFilePath strips it, so call this
+ * helper against the raw input before normalization.
+ */
+function isDirectoryReference(raw) {
+    const candidate = extractPathFromAnnotation(raw.trim());
+    if (!candidate)
+        return false;
+    if (containsGlobPattern(candidate))
+        return false;
+    return candidate.endsWith("/");
+}
+/**
+ * True when any of `knownOutputs` lives under `normalizedDir` (i.e. the task
+ * directory input is the parent of something a prior/same task produces).
+ */
+function anyOutputUnderDirectory(normalizedDir, knownOutputs) {
+    const prefix = normalizedDir + "/";
+    for (const output of knownOutputs) {
+        if (output === normalizedDir)
+            return true;
+        if (output.startsWith(prefix))
+            return true;
+    }
+    return false;
+}
+const URL_SCHEME_PATTERN = /^(https?|ftp|file|ssh|git):\/\//i;
+const SCP_PATTERN = /^[\w.-]+@[\w.-]+:[^/]/;
+function looksLikePathOrUrl(token) {
+    if (URL_SCHEME_PATTERN.test(token))
+        return true;
+    if (SCP_PATTERN.test(token))
+        return true;
+    if (/^[./~]/.test(token))
+        return true;
+    if (/[\\/]/.test(token))
+        return true;
+    if (/\.[A-Za-z0-9]{1,8}$/.test(token))
+        return true;
+    return false;
+}
 function extractPathFromAnnotation(raw) {
     const trimmed = raw.trim();
     if (!trimmed)
@@ -226,6 +280,19 @@ function extractPathFromAnnotation(raw) {
     if (annotatedMatch) {
         return annotatedMatch[1].trim();
     }
+    // Fallback: scan all backticked tokens and return the first one that looks
+    // like a path or URL. Handles prose-annotated bullets such as:
+    //   `path/` directory listing (...)
+    //   Prefix prose `https://...` suffix prose
+    //   Citing `.gsd/REQUIREMENTS.md` mid-sentence
+    // Skips non-path backticked tokens like `note` or `npm test`.
+    const backtickTokens = trimmed.matchAll(/`([^`]+)`/g);
+    for (const match of backtickTokens) {
+        const token = match[1].trim();
+        if (looksLikePathOrUrl(token)) {
+            return token;
+        }
+    }
     // Fall back to the original behavior for already-plain paths.
     return trimmed.replace(/`/g, "");
 }
@@ -240,12 +307,17 @@ function shouldValidateInputAsPath(raw) {
     const trimmed = raw.trim();
     if (!trimmed)
         return false;
-    if (/^`+[^`]+`+/.test(trimmed)) {
-        return true;
-    }
     const candidate = extractPathFromAnnotation(trimmed);
     if (!candidate)
         return false;
+    // URLs and remote repo refs are not filesystem paths.
+    if (URL_SCHEME_PATTERN.test(candidate))
+        return false;
+    if (SCP_PATTERN.test(candidate))
+        return false;
+    if (/^`+[^`]+`+/.test(trimmed)) {
+        return true;
+    }
     if (!/\s/.test(candidate)) {
         return true;
     }
@@ -256,6 +328,9 @@ function shouldValidateInputAsPath(raw) {
         /[\\/]/.test(candidate) ||
         /[*?[\]{}]/.test(candidate));
 }
+function containsGlobPattern(candidate) {
+    return ["*", "?", "[", "]", "{", "}"].some((char) => candidate.includes(char));
+}
 /**
  * Build a set of files that will be created by tasks up to (but not including) taskIndex.
  * All paths are normalized for consistent comparison.
@@ -272,10 +347,13 @@ function getExpectedOutputsUpTo(tasks, taskIndex) {
 /**
  * Check that all files referenced in task.inputs either:
  *   1. Exist on disk, OR
- *   2. Are in a prior task's expected_output
+ *   2. Are in a prior task's expected_output, OR
+ *   3. Are in the current task's own expected_output — the task produces them,
+ *      so they don't need to pre-exist (#4459, mirroring the exemption #3626
+ *      introduced for task.files).
  *
- * task.files ("files likely touched") is excluded — it intentionally includes
- * files the task will create, so they don't need to pre-exist (#3626).
+ * task.files ("files likely touched") is excluded entirely from this check —
+ * it intentionally includes files the task will create (#3626).
  *
  * All paths are normalized before comparison to ensure ./src/a.ts matches src/a.ts.
  */
@@ -284,6 +362,7 @@ export function checkFilePathConsistency(tasks, basePath) {
     for (let i = 0; i < tasks.length; i++) {
         const task = tasks[i];
         const priorOutputs = getExpectedOutputsUpTo(tasks, i);
+        const ownOutputs = new Set(task.expected_output.map(normalizeFilePath));
         const filesToCheck = [...task.inputs];
         for (const file of filesToCheck) {
             // Skip empty strings
@@ -293,17 +372,28 @@ export function checkFilePathConsistency(tasks, basePath) {
                 continue;
             // Normalize path for consistent comparison
             const normalizedFile = normalizeFilePath(file);
+            if (containsGlobPattern(normalizedFile))
+                continue;
             // Check if file exists on disk
             const absolutePath = resolve(basePath, normalizedFile);
             const existsOnDisk = existsSync(absolutePath);
             // Check if file is in prior expected outputs (priorOutputs already normalized)
             const inPriorOutputs = priorOutputs.has(normalizedFile);
-            if (!existsOnDisk && !inPriorOutputs) {
+            const inOwnOutputs = ownOutputs.has(normalizedFile);
+            // Directory inputs are satisfied when something produces a file beneath
+            // them — either a prior task or the current task itself.
+            let directorySatisfied = false;
+            if (!existsOnDisk && !inPriorOutputs && !inOwnOutputs && isDirectoryReference(file)) {
+                directorySatisfied =
+                    anyOutputUnderDirectory(normalizedFile, priorOutputs) ||
+                        anyOutputUnderDirectory(normalizedFile, ownOutputs);
+            }
+            if (!existsOnDisk && !inPriorOutputs && !inOwnOutputs && !directorySatisfied) {
                 results.push({
                     category: "file",
                     target: file,
                     passed: false,
-                    message: `Task ${task.id} references '${file}' which doesn't exist and isn't created by prior tasks`,
+                    message: `Task ${task.id} references '${file}' which doesn't exist and isn't created by prior or same-task outputs`,
                     blocking: true,
                 });
             }
@@ -341,6 +431,13 @@ export function checkTaskOrdering(tasks, basePath) {
             if (!shouldValidateInputAsPath(file))
                 continue;
             const normalizedFile = normalizeFilePath(file);
+            if (containsGlobPattern(normalizedFile))
+                continue;
+            // A directory reference like `artifacts/M009-S03/` is never a concrete
+            // read-before-create dependency: the fileCreators map is keyed by leaf
+            // files, and a same-task output under the directory satisfies it.
+            if (isDirectoryReference(file))
+                continue;
             const creator = fileCreators.get(normalizedFile);
             const absolutePath = resolve(basePath, normalizedFile);
             const existsOnDisk = existsSync(absolutePath);

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

@@ -39,6 +39,7 @@ export function resolveModelWithFallbacksForUnit(unitType) {
             break;
         case "plan-milestone":
         case "plan-slice":
+        case "refine-slice":
         case "replan-slice":
             phaseConfig = m.planning;
             break;

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

@@ -86,10 +86,11 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "discuss_depth",
     "flat_rate_providers",
     "language",
+    "context_window_override",
 ]);
 /** Canonical list of all dispatch unit types. */
 export const KNOWN_UNIT_TYPES = [
-    "research-milestone", "plan-milestone", "research-slice", "plan-slice",
+    "research-milestone", "plan-milestone", "research-slice", "plan-slice", "refine-slice",
     "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",

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

@@ -288,20 +288,48 @@ export function validatePreferences(preferences) {
         if (typeof preferences.phases === "object" && preferences.phases !== null) {
             const validatedPhases = {};
             const p = preferences.phases;
+            // Strict boolean parsing — YAML usually delivers real booleans, but
+            // hand-edits like `progressive_planning: "false"` otherwise coerce to
+            // truthy via `!!`. Accept only real booleans or the literal strings
+            // "true"/"false"; anything else becomes a warning + ignored.
+            const parseStrictBoolean = (key, raw) => {
+                if (typeof raw === "boolean")
+                    return raw;
+                if (typeof raw === "string") {
+                    if (raw === "true")
+                        return true;
+                    if (raw === "false")
+                        return false;
+                }
+                warnings.push(`phases.${key} must be a boolean (got ${typeof raw}: ${JSON.stringify(raw)}) — ignored`);
+                return undefined;
+            };
+            const assignBool = (key, raw) => {
+                const v = parseStrictBoolean(String(key), raw);
+                if (v !== undefined)
+                    validatedPhases[key] = v;
+            };
             if (p.skip_research !== undefined)
-                validatedPhases.skip_research = !!p.skip_research;
+                assignBool("skip_research", p.skip_research);
             if (p.skip_reassess !== undefined)
-                validatedPhases.skip_reassess = !!p.skip_reassess;
+                assignBool("skip_reassess", p.skip_reassess);
             if (p.skip_slice_research !== undefined)
-                validatedPhases.skip_slice_research = !!p.skip_slice_research;
+                assignBool("skip_slice_research", p.skip_slice_research);
             if (p.skip_milestone_validation !== undefined)
-                validatedPhases.skip_milestone_validation = !!p.skip_milestone_validation;
+                assignBool("skip_milestone_validation", p.skip_milestone_validation);
             if (p.reassess_after_slice !== undefined)
-                validatedPhases.reassess_after_slice = !!p.reassess_after_slice;
-            if (p.require_slice_discussion !== undefined)
-                validatedPhases.require_slice_discussion = !!p.require_slice_discussion;
+                assignBool("reassess_after_slice", p.reassess_after_slice);
+            if (p.require_slice_discussion !== undefined) {
+                const v = parseStrictBoolean("require_slice_discussion", p.require_slice_discussion);
+                if (v !== undefined)
+                    validatedPhases.require_slice_discussion = v;
+            }
+            if (p.mid_execution_escalation !== undefined)
+                assignBool("mid_execution_escalation", p.mid_execution_escalation);
+            if (p.progressive_planning !== undefined)
+                assignBool("progressive_planning", p.progressive_planning);
             // Warn on unknown phase keys
-            const knownPhaseKeys = new Set(["skip_research", "skip_reassess", "skip_slice_research", "skip_milestone_validation", "reassess_after_slice", "require_slice_discussion"]);
+            const knownPhaseKeys = new Set(["skip_research", "skip_reassess", "skip_slice_research", "skip_milestone_validation", "reassess_after_slice", "require_slice_discussion", "mid_execution_escalation", "progressive_planning"]);
             for (const key of Object.keys(p)) {
                 if (!knownPhaseKeys.has(key)) {
                     warnings.push(`unknown phases key "${key}" — ignored`);
@@ -559,6 +587,12 @@ export function validatePreferences(preferences) {
                 else
                     errors.push("dynamic_routing.capability_routing must be a boolean");
             }
+            if (dr.allow_flat_rate_providers !== undefined) {
+                if (typeof dr.allow_flat_rate_providers === "boolean")
+                    validDr.allow_flat_rate_providers = dr.allow_flat_rate_providers;
+                else
+                    errors.push("dynamic_routing.allow_flat_rate_providers must be a boolean");
+            }
             if (dr.tier_models !== undefined) {
                 if (typeof dr.tier_models === "object" && dr.tier_models !== null) {
                     const tm = dr.tier_models;