gsd-pi 2.74.0 → 2.75.0-dev.fd2382b9f

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

@@ -4,7 +4,9 @@
 //
 // Both READ and WRITE operations are native — push operations remain as
 // execSync calls because git2 credential handling is too complex.
-import { execSync, execFileSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { GSDError, GSD_GIT_ERROR } from "./errors.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { getErrorMessage } from "./error-utils.js";
@@ -206,7 +208,7 @@ export function nativeIsRepo(basePath) {
         return native.gitIsRepo(basePath);
     }
     try {
-        execSync("git rev-parse --git-dir", { cwd: basePath, stdio: "pipe" });
+        execFileSync("git", ["rev-parse", "--git-dir"], { cwd: basePath, stdio: "pipe" });
         return true;
     }
     catch {
@@ -534,6 +536,136 @@ export function nativeAddAll(basePath) {
 export function nativeAddTracked(basePath) {
     gitFileExec(basePath, ["add", "-u"]);
 }
+function isDotGsdIgnored(basePath) {
+    for (const path of [".gsd", ".gsd/"]) {
+        try {
+            execFileSync("git", ["check-ignore", "-q", path], {
+                cwd: basePath,
+                stdio: "pipe",
+                env: GIT_NO_PROMPT_ENV,
+            });
+            return true;
+        }
+        catch {
+            // exit 1 means this form is not ignored; try the next variant
+        }
+    }
+    return false;
+}
+/**
+ * Determine whether the project opts out of GSD-managed `.gitignore` via
+ * `git.manage_gitignore: false` in `.gsd/PREFERENCES.md`. Uses a minimal
+ * inline parser to avoid importing the full preferences module (which would
+ * introduce a circular dependency back into this low-level bridge).
+ *
+ * Returns true when management is disabled. Any parse failure or missing
+ * file returns false (default: GSD may manage `.gitignore`).
+ */
+function isGitignoreManagementDisabled(basePath) {
+    const prefsPath = join(basePath, ".gsd", "PREFERENCES.md");
+    if (!existsSync(prefsPath))
+        return false;
+    try {
+        const content = readFileSync(prefsPath, "utf-8");
+        // Look for `manage_gitignore: false` under a `git:` block. The preference
+        // is indented; a loose regex is sufficient since we only care about the
+        // explicit opt-out case.
+        return /^\s*manage_gitignore\s*:\s*false\s*$/m.test(content);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Self-heal path for the symlinked-`.gsd` staging failure: append `.gsd` to
+ * `.gitignore` so subsequent `git add -A` calls succeed without the symlink
+ * pathspec error. Honors the `git.manage_gitignore: false` opt-out.
+ *
+ * Returns true when `.gitignore` now contains an entry covering `.gsd`
+ * (either pre-existing or newly appended). Returns false when the opt-out
+ * is set or the write fails.
+ */
+function trySelfHealGsdGitignore(basePath) {
+    if (isGitignoreManagementDisabled(basePath))
+        return false;
+    const gitignorePath = join(basePath, ".gitignore");
+    try {
+        const existing = existsSync(gitignorePath) ? readFileSync(gitignorePath, "utf-8") : "";
+        const lines = new Set(existing.split("\n").map(l => l.trim()).filter(l => l && !l.startsWith("#")));
+        if (lines.has(".gsd") || lines.has(".gsd/"))
+            return true;
+        const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+        const block = `${prefix}\n# ── GSD self-heal: .gsd is a symlink to external state ──\n.gsd\n`;
+        writeFileSync(gitignorePath, existing + block, "utf-8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Stage untracked files individually while skipping anything under `.gsd`.
+ * Used as a last-resort when `.gsd` is a symlink, not gitignored, and
+ * `git.manage_gitignore: false` forbids the self-heal path. Protects user
+ * work by never silently dropping new real files.
+ */
+function stageUntrackedExcludingDotGsd(basePath) {
+    // Stage tracked modifications first. `git add -u` never fails on pathspec
+    // issues because it doesn't walk untracked trees.
+    gitFileExec(basePath, ["add", "-u"]);
+    // Enumerate untracked paths via porcelain output. `?? ` prefix marks
+    // untracked files (status respects `.gitignore`).
+    const status = gitFileExec(basePath, ["status", "--porcelain=v1", "-z"], true);
+    if (!status)
+        return;
+    const untracked = [];
+    for (const entry of status.split("\0")) {
+        if (!entry)
+            continue;
+        // Porcelain format: "XY path" where XY is the 2-char status code.
+        if (entry.length < 4)
+            continue;
+        const code = entry.slice(0, 2);
+        const path = entry.slice(3);
+        if (code !== "??")
+            continue;
+        // Skip GSD runtime artifacts. Under `manage_gitignore: false` the user
+        // may not have these in `.gitignore`, so we filter explicitly to avoid
+        // committing transient state (.gsd external link, migration lock,
+        // background shell scratch dir).
+        if (path === ".gsd" || path.startsWith(".gsd/"))
+            continue;
+        if (path === ".gsd-id" || path === ".gsd.migrating")
+            continue;
+        if (path === ".bg-shell" || path.startsWith(".bg-shell/"))
+            continue;
+        untracked.push(path);
+    }
+    if (untracked.length === 0)
+        return;
+    // Stage in chunks to avoid exceeding ARG_MAX on large change sets.
+    const CHUNK = 200;
+    for (let i = 0; i < untracked.length; i += CHUNK) {
+        gitFileExec(basePath, ["add", "--", ...untracked.slice(i, i + CHUNK)]);
+    }
+}
+/**
+ * Handle `nativeAddAllWithExclusions` failing with "beyond a symbolic link"
+ * when `.gsd` is a symlink. Self-heals by adding `.gsd` to `.gitignore`, or
+ * falls back to explicit per-file staging so user work is never dropped.
+ */
+function fallbackStageWithSymlinkedDotGsd(basePath) {
+    if (isDotGsdIgnored(basePath)) {
+        gitFileExec(basePath, ["add", "-A"]);
+        return;
+    }
+    if (trySelfHealGsdGitignore(basePath)) {
+        gitFileExec(basePath, ["add", "-A"]);
+        return;
+    }
+    // `manage_gitignore: false` — protect work by staging files explicitly.
+    stageUntrackedExcludingDotGsd(basePath);
+}
 /**
  * Stage all files with pathspec exclusions (git add -A -- ':!pattern' ...).
  * Excluded paths are never hashed by git, preventing hangs on large
@@ -569,12 +701,12 @@ export function nativeAddAllWithExclusions(basePath, exclusions) {
             return;
         }
         // When .gsd is a symlink, git rejects `:!.gsd/...` pathspecs with
-        // "beyond a symbolic link". Fall back to `git add -u` which only
-        // stages changes to already-tracked files — O(tracked) not O(filesystem).
-        // Using `git add -A` here would traverse the entire working tree,
-        // hanging indefinitely on repos with large untracked data dirs. (#1977)
+        // "beyond a symbolic link". Hand off to the self-heal fallback which
+        // either adds `.gsd` to `.gitignore` and retries `git add -A`, or stages
+        // real files explicitly when `git.manage_gitignore: false` forbids the
+        // self-heal path. Either way, user work is protected from silent drops.
         if (stderr.includes("beyond a symbolic link")) {
-            gitFileExec(basePath, ["add", "-u"]);
+            fallbackStageWithSymlinkedDotGsd(basePath);
             return;
         }
         throw new GSDError(GSD_GIT_ERROR, `git add -A with exclusions failed in ${basePath}: ${getErrorMessage(err)}`);
@@ -629,7 +761,10 @@ export function nativeCommit(basePath, message, options) {
     }
     // Fallback: use git commit with stdin pipe for safe multi-line messages
     try {
-        const result = execSync(`git commit --no-verify -F -${options?.allowEmpty ? " --allow-empty" : ""}`, {
+        const args = ["commit", "--no-verify", "-F", "-"];
+        if (options?.allowEmpty)
+            args.push("--allow-empty");
+        const result = execFileSync("git", args, {
             cwd: basePath,
             stdio: ["pipe", "pipe", "pipe"],
             encoding: "utf-8",
@@ -767,7 +902,7 @@ export function nativeResetHard(basePath) {
         native.gitResetHard(basePath);
         return;
     }
-    execSync("git reset --hard HEAD", { cwd: basePath, stdio: "pipe" });
+    execFileSync("git", ["reset", "--hard", "HEAD"], { cwd: basePath, stdio: "pipe" });
 }
 /**
  * Soft reset to a target ref (git reset --soft <ref>).

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/parallel-orchestrator.js

@@ -20,8 +20,13 @@ import { writeSessionStatus, readAllSessionStatuses, readSessionStatus, removeSe
 import { analyzeParallelEligibility, } from "./parallel-eligibility.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning } from "./workflow-logger.js";
+import { resolveUokFlags } from "./uok/flags.js";
+import { selectConflictFreeBatch } from "./uok/execution-graph.js";
 // ─── Module State ──────────────────────────────────────────────────────────
 let state = null;
+function overlapKey(a, b) {
+    return a < b ? `${a}::${b}` : `${b}::${a}`;
+}
 // ─── Persistence ──────────────────────────────────────────────────────────
 const ORCHESTRATOR_STATE_FILE = "orchestrator.json";
 const TMP_SUFFIX = ".tmp";
@@ -277,6 +282,7 @@ export async function startParallel(basePath, milestoneIds, prefs) {
         return { started: [], errors: [{ mid: "all", error: "Cannot start parallel from within a parallel worker" }] };
     }
     const config = resolveParallelConfig(prefs);
+    const uokFlags = resolveUokFlags(prefs);
     // Release any leftover state from a previous session before reassigning
     if (state) {
         for (const w of state.workers.values()) {
@@ -324,8 +330,34 @@ export async function startParallel(basePath, milestoneIds, prefs) {
     };
     const started = [];
     const errors = [];
+    let filteredMilestoneIds = milestoneIds;
+    if (uokFlags.executionGraph && milestoneIds.length > 1) {
+        try {
+            const requestedIds = new Set(milestoneIds);
+            const candidates = await analyzeParallelEligibility(basePath);
+            const overlapPairs = new Set();
+            for (const overlap of candidates.fileOverlaps) {
+                if (!requestedIds.has(overlap.mid1) || !requestedIds.has(overlap.mid2))
+                    continue;
+                overlapPairs.add(overlapKey(overlap.mid1, overlap.mid2));
+            }
+            filteredMilestoneIds = selectConflictFreeBatch({
+                orderedIds: milestoneIds,
+                maxParallel: milestoneIds.length,
+                hasConflict: (candidate, existing) => overlapPairs.has(overlapKey(candidate, existing)),
+            });
+            if (filteredMilestoneIds.length < milestoneIds.length) {
+                const skipped = milestoneIds.filter((mid) => !filteredMilestoneIds.includes(mid));
+                logWarning("parallel", `uok execution graph filtered ${skipped.length} conflicting milestone(s): ${skipped.join(", ")}`);
+            }
+        }
+        catch (e) {
+            logWarning("parallel", `uok execution graph overlap analysis failed; using legacy milestone selection: ${e.message}`);
+            filteredMilestoneIds = milestoneIds;
+        }
+    }
     // Cap to max_workers
-    const toStart = milestoneIds.slice(0, config.max_workers);
+    const toStart = filteredMilestoneIds.slice(0, config.max_workers);
     for (const mid of toStart) {
         // Check budget ceiling before each spawn
         if (isBudgetExceeded()) {

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.
@@ -293,12 +368,23 @@ 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) {
+            // 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 && isDirectoryReference(file)) {
+                const sameTaskOutputs = task.expected_output.map(normalizeFilePath);
+                directorySatisfied =
+                    anyOutputUnderDirectory(normalizedFile, priorOutputs) ||
+                        anyOutputUnderDirectory(normalizedFile, sameTaskOutputs);
+            }
+            if (!existsOnDisk && !inPriorOutputs && !directorySatisfied) {
                 results.push({
                     category: "file",
                     target: file,
@@ -341,6 +427,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;
@@ -321,7 +322,7 @@ export function resolveAutoSupervisorConfig() {
     };
 }
 // ─── Token Profile Resolution ─────────────────────────────────────────────
-const VALID_TOKEN_PROFILES = new Set(["budget", "balanced", "quality"]);
+const VALID_TOKEN_PROFILES = new Set(["budget", "balanced", "quality", "burn-max"]);
 /**
  * Resolve profile defaults for a given token profile tier.
  * Returns a partial GSDPreferences that is used as the base layer --
@@ -365,6 +366,22 @@ export function resolveProfileDefaults(profile) {
                     skip_reassess: true,
                 },
             };
+        case "burn-max":
+            return {
+                // Quality-first profile: keep user-selected models, disable downgrade routing.
+                // Policy constraints still apply at dispatch time.
+                dynamic_routing: {
+                    enabled: false,
+                },
+                context_selection: "full",
+                phases: {
+                    skip_research: false,
+                    skip_slice_research: false,
+                    skip_reassess: false,
+                    skip_milestone_validation: false,
+                    reassess_after_slice: true,
+                },
+            };
     }
 }
 /**
@@ -380,7 +397,7 @@ export function resolveEffectiveProfile() {
 }
 /**
  * Resolve the inline level from the active token profile.
- * budget -> minimal, balanced -> standard, quality -> full.
+ * budget -> minimal, balanced -> standard, quality/burn-max -> full.
  */
 export function resolveInlineLevel() {
     const profile = resolveEffectiveProfile();
@@ -388,11 +405,12 @@ export function resolveInlineLevel() {
         case "budget": return "minimal";
         case "balanced": return "standard";
         case "quality": return "full";
+        case "burn-max": return "full";
     }
 }
 /**
  * Resolve the context selection mode from the active token profile.
- * budget -> "smart", balanced/quality -> "full".
+ * budget -> "smart", balanced/quality/burn-max -> "full".
  * Explicit preference always wins.
  */
 export function resolveContextSelection() {

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

@@ -53,6 +53,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "post_unit_hooks",
     "pre_dispatch_hooks",
     "dynamic_routing",
+    "uok",
     "token_profile",
     "phases",
     "auto_visualize",
@@ -84,10 +85,12 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "discuss_web_research",
     "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",