@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.c18009cd

package/dist/resources/extensions/gsd/milestone-implementation-evidence.js

@@ -10,6 +10,8 @@ import { logWarning } from "./workflow-logger.js";
 import { resolveTasksDir } from "./paths.js";
 /** Large enough for unbounded milestone-history git log scans in big repos. */
 const GIT_LOG_MAX_BUFFER = 16 * 1024 * 1024;
+const LOG_FIELD_SEPARATOR = "\x1f";
+const LOG_RECORD_SEPARATOR = "\x1e";
 /**
  * Check whether a milestone produced implementation artifacts (non-`.gsd/`
  * files) in git history. The primary signal is the branch diff against the
@@ -179,7 +181,7 @@ function getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId) {
     // Primary: path-scoped log against .gsd/milestones/<id>. Fast and unbounded
     // by depth when .gsd/ is tracked in git.
     const scoped = scanGsdTaggedCommits(basePath, milestoneId, [
-        "log", "--format=%H%x1f%B%x1e", "HEAD", "--", `.gsd/milestones/${milestoneId}`,
+        "log", "--full-diff", "--name-only", "--format=%x1e%H%x1f%B%x1f", "HEAD", "--", `.gsd/milestones/${milestoneId}`,
     ]);
     if (!scoped.ok)
         return scoped;
@@ -195,7 +197,7 @@ function getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId) {
     // reintroducing the rolling-depth failure class removed in #4699 where
     // milestone evidence aged out behind unrelated activity.
     const unscoped = scanGsdTaggedCommits(basePath, milestoneId, [
-        "log", "--format=%H%x1f%B%x1e", "HEAD",
+        "log", "--name-only", "--format=%x1e%H%x1f%B%x1f", "HEAD",
     ]);
     if (!unscoped.ok)
         return scoped.matched ? scoped : unscoped;
@@ -280,8 +282,7 @@ function backfillChangedFilesFromUntaggedMilestoneCommits(basePath, milestoneId)
                 continue;
             if (commitMessageHasGsdTrailer(record.message))
                 continue;
-            const commitFiles = getChangedFilesForCommit(basePath, record.hash);
-            const implementationFiles = commitFiles.map(normalizeRepoPath).filter(isImplementationPath);
+            const implementationFiles = record.files.map(normalizeRepoPath).filter(isImplementationPath);
             if (implementationFiles.length === 0)
                 continue;
             if (!implementationFiles.some((file) => hintSet.has(file)))
@@ -306,24 +307,28 @@ function backfillChangedFilesFromUntaggedMilestoneCommits(basePath, milestoneId)
     }
 }
 function getCommitRecords(basePath) {
-    const logOutput = execFileSync("git", ["log", "--format=%H%x1f%P%x1f%cI%x1f%B%x1e", "HEAD"], {
+    const logOutput = execFileSync("git", ["log", "--name-only", "--format=%x1e%H%x1f%P%x1f%cI%x1f%B%x1f", "HEAD"], {
         cwd: basePath,
         stdio: ["ignore", "pipe", "pipe"],
         encoding: "utf-8",
         maxBuffer: GIT_LOG_MAX_BUFFER,
     });
     return logOutput
-        .split("\x1e")
-        .map((record) => record.trim())
+        .split(LOG_RECORD_SEPARATOR)
         .filter(Boolean)
         .flatMap((record) => {
-        const parts = record.split("\x1f");
-        if (parts.length < 4)
+        const parts = record.split(LOG_FIELD_SEPARATOR);
+        if (parts.length < 5)
             return [];
-        const [hash, parents, committedAt, ...messageParts] = parts;
-        return [{ hash: hash.trim(), parents: parents.trim(), committedAt: committedAt.trim(), message: messageParts.join("\x1f") }];
+        const [hash, parents, committedAt] = parts;
+        const files = parseNameOnlyFiles(parts.at(-1) ?? "");
+        const message = parts.slice(3, -1).join(LOG_FIELD_SEPARATOR);
+        return [{ hash: hash.trim(), parents: parents.trim(), committedAt: committedAt.trim(), message, files }];
     });
 }
+function parseNameOnlyFiles(rawFiles) {
+    return rawFiles.split(/\r?\n/).map((file) => file.trim()).filter(Boolean);
+}
 function isFullCommitSha(value) {
     return /^[0-9a-f]{40}$/i.test(value);
 }
@@ -336,23 +341,24 @@ function scanGsdTaggedCommits(basePath, milestoneId, gitArgs) {
             maxBuffer: GIT_LOG_MAX_BUFFER,
         });
         const records = logOutput
-            .split("\x1e")
-            .map((record) => record.trim())
+            .split(LOG_RECORD_SEPARATOR)
             .filter(Boolean)
             .flatMap((record) => {
-            const sep = record.indexOf("\x1f");
-            if (sep === -1)
+            const parts = record.split(LOG_FIELD_SEPARATOR);
+            if (parts.length < 3)
+                return [];
+            const hash = parts[0].trim();
+            if (!hash)
                 return [];
-            const hash = record.slice(0, sep).trim();
-            const message = record.slice(sep + 1);
-            return [{ hash, message }];
+            const files = parseNameOnlyFiles(parts.at(-1) ?? "");
+            const message = parts.slice(1, -1).join(LOG_FIELD_SEPARATOR);
+            return [{ message, files }];
         });
         const files = new Set();
         let matched = false;
-        for (const { hash, message } of records) {
+        for (const { message, files: commitFiles } of records) {
             if (!commitMessageHasGsdTrailer(message))
                 continue;
-            const commitFiles = getChangedFilesForCommit(basePath, hash);
             if (!commitMatchesMilestone(basePath, message, milestoneId, commitFiles))
                 continue;
             matched = true;

package/dist/resources/extensions/gsd/milestone-merge-transaction.js

@@ -1,10 +1,10 @@
 // Project/App: gsd-pi
 // File Purpose: Process-level transaction wrapper for milestone merge closeout.
 export function runMilestoneMergeTransaction(deps, input) {
-    return deps.mergeMilestoneToMain(input.basePath, input.milestoneId, input.roadmapContent);
+    return deps.mergeMilestone(input.basePath, input.milestoneId, input.roadmapContent);
 }
-export function createMilestoneMergeTransaction(mergeMilestoneToMain) {
+export function createMilestoneMergeTransaction(mergeMilestone) {
     return function mergeMilestoneTransaction(basePath, milestoneId, roadmapContent) {
-        return runMilestoneMergeTransaction({ mergeMilestoneToMain }, { basePath, milestoneId, roadmapContent });
+        return runMilestoneMergeTransaction({ mergeMilestone }, { basePath, milestoneId, roadmapContent });
     };
 }

package/dist/resources/extensions/gsd/milestone-planning-persistence.js

@@ -99,6 +99,14 @@ function writePlanRows(params) {
 async function renderPlanArtifacts(basePath, params) {
     try {
         const renderResult = await renderRoadmapFromDb(basePath, params.milestoneId);
+        // renderRoadmapFromDb only skips for unplanned milestones (zero slices +
+        // empty vision); persistMilestonePlan always populates both via writePlanRows
+        // before this render, so the skipped branch is unreachable here. Fall back to
+        // resolving the projected path so a future invariant still surfaces a clear
+        // render failure rather than an undefined dereference.
+        if ("skipped" in renderResult) {
+            return { error: `render skipped: milestone ${params.milestoneId} has no planned slices` };
+        }
         return renderResult.roadmapPath;
     }
     catch (renderErr) {

package/dist/resources/extensions/gsd/milestone-validation-verdict.js

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { resolveExpectedArtifactPath } from "./auto-artifact-paths.js";
 import { loadFile } from "./files.js";
 import { getLatestAssessmentByScope, isDbAvailable } from "./gsd-db.js";
-import { gsdProjectionRoot } from "./paths.js";
+import { relMilestoneFile } from "./paths.js";
 import { extractVerdict, isValidMilestoneVerdict, } from "./verdict-parser.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
 import { resolveWorktreeProjectRoot } from "./worktree-root.js";
@@ -50,8 +50,11 @@ export async function resolveMilestoneValidationVerdict(basePath, milestoneId) {
         if (projectVerdict)
             return projectVerdict;
     }
-    // Last resort: direct canonical projection path even when resolveDir helpers
-    // have not materialized the milestone directory yet.
-    const directPath = join(gsdProjectionRoot(canonicalBase), "milestones", milestoneId, `${milestoneId}-VALIDATION.md`);
+    // Last resort: layout-aware fallback path when resolveDir helpers
+    // haven't materialized the milestone directory yet. relMilestoneFile()
+    // builds the canonical NN-VALIDATION.md path for flat-phase and the
+    // legacy MID-VALIDATION.md path for projects that haven't migrated.
+    // See open-gsd/gsd-pi#876.
+    const directPath = join(canonicalBase, relMilestoneFile(canonicalBase, milestoneId, "VALIDATION"));
     return verdictFromValidationPath(directPath);
 }

package/dist/resources/extensions/gsd/model-router.js

@@ -223,10 +223,12 @@ export function scoreEligibleModels(eligibleModelIds, requirements, capabilityOv
 }
 /**
  * Return all models eligible for a given tier, sorted cheapest first.
+ * A runtime preferred model (the user's selected/session model) is returned
+ * first when it is available and satisfies the requested tier.
  * If routingConfig.tier_models[tier] is set and available, returns only that
  * model. Otherwise filters availableModelIds by tier from MODEL_CAPABILITY_TIER.
  */
-export function getEligibleModels(tier, availableModelIds, routingConfig) {
+export function getEligibleModels(tier, availableModelIds, routingConfig, preferredModelId) {
     // 1. Check explicit tier_models config
     const explicitModel = routingConfig.tier_models?.[tier];
     if (explicitModel) {
@@ -240,13 +242,17 @@ export function getEligibleModels(tier, availableModelIds, routingConfig) {
             return [match];
     }
     // 2. Auto-detect: filter by tier, sort cheapest first
-    return availableModelIds
+    const tierMatches = availableModelIds
         .filter(id => getModelTier(id) === tier)
         .sort((a, b) => {
         const costA = getModelCost(a);
         const costB = getModelCost(b);
         return costA - costB;
     });
+    const preferred = findPreferredModelForTier(tier, availableModelIds, preferredModelId);
+    if (!preferred)
+        return tierMatches;
+    return [preferred, ...tierMatches.filter(id => id !== preferred)];
 }
 /**
  * Build a fallback chain for a selected model: [selectedModel, ...configuredFallbacks, configuredPrimary]
@@ -294,7 +300,7 @@ export function loadCapabilityOverrides(prefs) {
  * @param taskMetadata        Task metadata for refined requirement vectors (optional)
  * @param capabilityOverrides User-provided capability overrides (deep-merged with built-in profiles, optional)
  */
-export function resolveModelForComplexity(classification, phaseConfig, routingConfig, availableModelIds, unitType, taskMetadata, capabilityOverrides) {
+export function resolveModelForComplexity(classification, phaseConfig, routingConfig, availableModelIds, unitType, taskMetadata, capabilityOverrides, preferredModelId) {
     // If no phase config or routing disabled, pass through
     if (!phaseConfig || !routingConfig.enabled) {
         return {
@@ -340,7 +346,7 @@ export function resolveModelForComplexity(classification, phaseConfig, routingCo
         // Configured primary is unavailable (e.g. Anthropic model configured but
         // running on a non-Anthropic provider). Find the best available model at
         // the same capability tier so routing still works cross-provider.
-        const crossProviderEquivalent = findModelForTier(configuredTier, routingConfig, availableModelIds, routingConfig.cross_provider !== false);
+        const crossProviderEquivalent = findModelForTier(configuredTier, routingConfig, availableModelIds, routingConfig.cross_provider !== false, preferredModelId);
         return {
             modelId: crossProviderEquivalent ?? configuredPrimary,
             fallbacks: crossProviderEquivalent
@@ -355,7 +361,7 @@ export function resolveModelForComplexity(classification, phaseConfig, routingCo
         };
     }
     // STEP 1: Get all eligible models for the requested tier
-    const eligible = getEligibleModels(requestedTier, availableModelIds, routingConfig);
+    const eligible = getEligibleModels(requestedTier, availableModelIds, routingConfig, preferredModelId);
     if (eligible.length === 0) {
         // No suitable model found — use configured primary
         return {
@@ -367,6 +373,18 @@ export function resolveModelForComplexity(classification, phaseConfig, routingCo
             selectionMethod: "tier-only",
         };
     }
+    const preferred = findPreferredModelForTier(requestedTier, availableModelIds, preferredModelId);
+    if (preferred && eligible.includes(preferred)) {
+        const fallbacks = buildFallbackChain(preferred, phaseConfig);
+        return {
+            modelId: preferred,
+            fallbacks,
+            tier: requestedTier,
+            wasDowngraded: !isModelAvailable(configuredPrimary, [preferred]),
+            reason: `preferred session model ${preferred} satisfies ${requestedTier} tier`,
+            selectionMethod: "tier-only",
+        };
+    }
     // STEP 2: Capability scoring (when enabled and multiple eligible models exist)
     if (routingConfig.capability_routing !== false && eligible.length > 1 && unitType) {
         const requirements = computeTaskRequirements(unitType, taskMetadata);
@@ -428,15 +446,15 @@ export function defaultRoutingConfig() {
 }
 // ─── Tier-Based Model Resolution (for profile defaults) ─────────────────────
 /**
- * Fallback-only canonical model IDs per tier. Returned when the
+ * Fallback-only canonical model IDs per tier. Returned only when the
  * available-model list is empty (e.g., preferences are loaded before the
- * model registry is populated at bootstrap), or when a non-empty registry has
- * no model at the requested tier.
+ * model registry is populated at bootstrap).
  *
  * Precedence (resolveModelForTier):
  *   1. configured `tier_models[tier]` (via getEligibleModels) — exact/bare match
- *   2. cheapest available model whose tier matches `tier`
- *   3. CANONICAL_TIER_MODELS[tier] as last-resort fallback
+ *   2. preferred/session model when it is available and satisfies `tier`
+ *   3. cheapest available model whose tier matches `tier`
+ *   4. CANONICAL_TIER_MODELS[tier] when the registry is empty
  */
 const CANONICAL_TIER_MODELS = {
     light: "claude-haiku-4-5",
@@ -448,16 +466,17 @@ export function canonicalModelForTier(tier) {
 }
 /**
  * Single source of truth for tier-based model selection.
- * Returns the cheapest available model whose capability tier matches `tier`,
- * honoring `routingConfig.tier_models[tier]` when set. Returns undefined when
- * no available model matches the tier.
+ * Returns the preferred/session model when it satisfies `tier`, otherwise the
+ * cheapest available model whose capability tier matches `tier`, honoring
+ * `routingConfig.tier_models[tier]` when set. Returns undefined when no
+ * available model satisfies the tier.
  *
  * `crossProvider`: when false, restricts the search to models that share the
  * canonical (Anthropic) provider for the tier. When true, any provider is
  * eligible.
  */
-function findModelForTier(tier, routingConfig, availableModelIds, crossProvider) {
-    const eligible = getEligibleModels(tier, availableModelIds, routingConfig);
+function findModelForTier(tier, routingConfig, availableModelIds, crossProvider, preferredModelId) {
+    const eligible = getEligibleModels(tier, availableModelIds, routingConfig, preferredModelId);
     if (eligible.length === 0)
         return undefined;
     if (crossProvider) {
@@ -469,29 +488,69 @@ function findModelForTier(tier, routingConfig, availableModelIds, crossProvider)
         const bare = bareModelId(id);
         return MODEL_CAPABILITY_TIER[bare] === tier && bare.startsWith("claude-");
     });
+    // Honor the preferred/session model only when it is itself a same-provider
+    // (Anthropic/Claude) model. A non-Anthropic session model must not bypass
+    // the cross_provider:false restriction.
+    const preferred = findPreferredModelForTier(tier, availableModelIds, preferredModelId);
+    if (preferred && sameProvider.includes(preferred))
+        return preferred;
     return sameProvider[0];
 }
-export function resolveModelForTier(tier, availableModelIds, routingConfigOrCrossProvider = defaultRoutingConfig(), crossProvider) {
+export function resolveModelForTier(tier, availableModelIds, routingConfigOrCrossProvider = defaultRoutingConfig(), crossProvider, preferredModelId) {
     const routingConfig = typeof routingConfigOrCrossProvider === "boolean"
         ? defaultRoutingConfig()
         : { ...defaultRoutingConfig(), ...routingConfigOrCrossProvider };
     const allowCrossProvider = typeof routingConfigOrCrossProvider === "boolean"
         ? routingConfigOrCrossProvider
         : crossProvider ?? routingConfig.cross_provider !== false;
-    // No available models known — return canonical fallback
+    // No available models known — prefer the session model when provided, else canonical
     if (availableModelIds.length === 0) {
+        if (preferredModelId) {
+            return normalizeResolvedTierModelId(preferredModelId, tier, routingConfig);
+        }
         incrementLegacyTelemetry("legacy.providerDefaultUsed");
         return canonicalModelForTier(tier);
     }
     // Cross-provider tier search
-    const resolved = findModelForTier(tier, routingConfig, availableModelIds, allowCrossProvider);
+    const resolved = findModelForTier(tier, routingConfig, availableModelIds, allowCrossProvider, preferredModelId);
     if (resolved) {
         return normalizeResolvedTierModelId(resolved, tier, routingConfig);
     }
-    incrementLegacyTelemetry("legacy.providerDefaultUsed");
-    return canonicalModelForTier(tier);
+    const providerLocalFallback = findAvailableModelId(preferredModelId, availableModelIds)
+        ?? availableModelIds[0]
+        ?? canonicalModelForTier(tier);
+    return normalizeResolvedTierModelId(providerLocalFallback, tier, routingConfig);
 }
 // ─── Internal ────────────────────────────────────────────────────────────────
+function modelProvider(modelId) {
+    const slash = modelId.indexOf("/");
+    return slash > 0 ? modelId.slice(0, slash) : undefined;
+}
+function findAvailableModelId(preferredModelId, availableModelIds) {
+    if (!preferredModelId)
+        return undefined;
+    if (availableModelIds.includes(preferredModelId))
+        return preferredModelId;
+    const preferredBare = bareModelId(preferredModelId);
+    if (!preferredBare)
+        return undefined;
+    const preferredProvider = modelProvider(preferredModelId)?.toLowerCase();
+    if (preferredProvider) {
+        const providerMatch = availableModelIds.find(id => modelProvider(id)?.toLowerCase() === preferredProvider && bareModelId(id) === preferredBare);
+        if (providerMatch)
+            return providerMatch;
+    }
+    return availableModelIds.find(id => bareModelId(id) === preferredBare);
+}
+function modelSatisfiesTier(modelId, tier) {
+    return tierOrdinal(getModelTier(modelId)) >= tierOrdinal(tier);
+}
+function findPreferredModelForTier(tier, availableModelIds, preferredModelId) {
+    const preferred = findAvailableModelId(preferredModelId, availableModelIds);
+    if (!preferred)
+        return undefined;
+    return modelSatisfiesTier(preferred, tier) ? preferred : undefined;
+}
 /**
  * Check whether a model ID is present in the available models list.
  * Handles bare IDs ("claude-opus-4-6") and provider-prefixed IDs ("anthropic/claude-opus-4-6").

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

@@ -270,43 +270,36 @@ function _atomicWrite(basePath, content) {
 /**
  * Acquire an exclusive lockfile for rewrite operations.
  * Uses O_CREAT|O_EXCL for atomic creation — if the file exists, another
- * process holds the lock. Retries briefly, then proceeds anyway (best-effort)
- * to avoid deadlocking the UI on a stale lock.
+ * process holds the lock. Clears stale locks, then proceeds anyway
+ * (best-effort) to avoid blocking the UI.
  */
 function _withLock(basePath, fn) {
     const lockPath = join(basePath, ".gsd", LOCKFILE);
     let fd = null;
-    const maxAttempts = 5;
-    const retryMs = 20;
-    for (let i = 0; i < maxAttempts; i++) {
-        try {
-            mkdirSync(join(basePath, ".gsd"), { recursive: true });
-            fd = openSync(lockPath, "wx");
-            break;
-        }
-        catch (err) {
-            if (err?.code === "EEXIST") {
-                // Check if lock is stale (older than 5s)
-                try {
-                    const stat = readFileSync(lockPath, "utf-8");
-                    const lockTime = parseInt(stat, 10);
-                    if (Date.now() - lockTime > 5000) {
-                        try {
-                            unlinkSync(lockPath);
-                        }
-                        catch { /* race ok */ }
-                        continue;
+    try {
+        mkdirSync(join(basePath, ".gsd"), { recursive: true });
+        fd = openSync(lockPath, "wx");
+    }
+    catch (err) {
+        if (err?.code === "EEXIST") {
+            // Check if lock is stale (older than 5s)
+            try {
+                const stat = readFileSync(lockPath, "utf-8");
+                const lockTime = parseInt(stat, 10);
+                if (Date.now() - lockTime > 5000) {
+                    try {
+                        unlinkSync(lockPath);
+                    }
+                    catch { /* race ok */ }
+                    try {
+                        fd = openSync(lockPath, "wx");
                     }
+                    catch { /* race ok */ }
                 }
-                catch { /* can't read lock, retry */ }
-                // Wait and retry
-                const start = Date.now();
-                while (Date.now() - start < retryMs) { /* spin */ }
-                continue;
             }
-            // Other error — proceed without lock
-            break;
+            catch { /* proceed without lock */ }
         }
+        // Any lock acquisition error leaves fd null; proceed without lock.
     }
     // Best-effort: mutation runs regardless of lock status (idempotent overwrites).
     // createdLock gates cleanup only — never skip fn() on lock failure.

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

@@ -1,12 +1,15 @@
 // GSD Extension — Desktop Notification Helper
 // Cross-platform desktop notifications for auto-mode events.
-import { execFileSync } from "node:child_process";
+import childProcess from "node:child_process";
+import { accessSync, constants } from "node:fs";
+import { delimiter, resolve } from "node:path";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { sendRemoteNotification as _sendRemoteNotification } from "../remote-questions/notify.js";
 /** Swappable dispatcher for remote notifications — exported so tests can mock it. */
 export const remoteNotificationDispatcher = {
     send: _sendRemoteNotification,
 };
+const executablePathCache = new Map();
 /**
  * Send a native desktop notification. Non-blocking, non-fatal.
  * macOS: osascript, Linux: notify-send, Windows: skipped.
@@ -49,13 +52,26 @@ export function sendDesktopNotification(title, message, level = "info", kind = "
             const command = buildDesktopNotificationCommand(process.platform, title, message, level);
             if (!command)
                 return;
-            execFileSync(command.file, command.args, { timeout: 3000, stdio: "ignore" });
+            launchDesktopNotification(command);
         }
         catch {
             // Non-fatal — desktop notifications are best-effort
         }
     }).catch(() => { });
 }
+export function launchDesktopNotification(command) {
+    try {
+        const child = childProcess.spawn(command.file, command.args, {
+            detached: true,
+            stdio: "ignore",
+        });
+        child.on("error", () => { });
+        child.unref();
+    }
+    catch {
+        // Non-fatal — desktop notifications are best-effort
+    }
+}
 export function shouldSendDesktopNotification(kind, preferences = loadEffectiveGSDPreferences()?.preferences.notifications) {
     if (preferences?.enabled === false)
         return false;
@@ -149,12 +165,25 @@ function escapeAppleScript(s) {
  * Non-fatal — returns null on any error.
  */
 function findExecutable(name) {
-    try {
-        return execFileSync("which", [name], { timeout: 2000, stdio: ["ignore", "pipe", "ignore"] }).toString().trim() || null;
-    }
-    catch {
-        return null;
+    if (executablePathCache.has(name))
+        return executablePathCache.get(name) ?? null;
+    let resolved = null;
+    const path = process.env.PATH;
+    if (path) {
+        for (const dir of path.split(delimiter)) {
+            const candidate = resolve(dir || ".", name);
+            try {
+                accessSync(candidate, constants.X_OK);
+                resolved = candidate;
+                break;
+            }
+            catch {
+                // keep searching PATH
+            }
+        }
     }
+    executablePathCache.set(name, resolved);
+    return resolved;
 }
 function resolveBellStream() {
     if (process.stderr?.isTTY)

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

@@ -361,12 +361,16 @@ export async function validatePlanBoundary(basePath, milestoneId, sliceId) {
     }
     const tasksDir = resolveTasksDir(basePath, milestoneId, sliceId);
     const taskPlans = tasksDir ? resolveTaskFiles(tasksDir, "PLAN") : [];
-    for (const file of taskPlans) {
+    const taskPlanPaths = taskPlans.flatMap(file => {
         const taskId = file.split("-")[0];
         const taskPlan = resolveTaskFile(basePath, milestoneId, sliceId, taskId, "PLAN");
+        return taskPlan ? [taskPlan] : [];
+    });
+    const taskPlanContents = await Promise.all(taskPlanPaths.map(loadFile));
+    for (const [index, content] of taskPlanContents.entries()) {
+        const taskPlan = taskPlanPaths[index];
         if (!taskPlan)
             continue;
-        const content = await loadFile(taskPlan);
         if (content)
             issues.push(...validateTaskPlanContent(taskPlan, content));
     }
@@ -392,12 +396,16 @@ export async function validateCompleteBoundary(basePath, milestoneId, sliceId) {
     const issues = [];
     const tasksDir = resolveTasksDir(basePath, milestoneId, sliceId);
     const taskSummaries = tasksDir ? resolveTaskFiles(tasksDir, "SUMMARY") : [];
-    for (const file of taskSummaries) {
+    const taskSummaryPaths = taskSummaries.flatMap(file => {
         const taskId = file.split("-")[0];
         const taskSummary = resolveTaskFile(basePath, milestoneId, sliceId, taskId, "SUMMARY");
+        return taskSummary ? [taskSummary] : [];
+    });
+    const taskSummaryContents = await Promise.all(taskSummaryPaths.map(loadFile));
+    for (const [index, content] of taskSummaryContents.entries()) {
+        const taskSummary = taskSummaryPaths[index];
         if (!taskSummary)
             continue;
-        const content = await loadFile(taskSummary);
         if (content)
             issues.push(...validateTaskSummaryContent(taskSummary, content));
     }