@opengsd/gsd-pi 1.5.0 → 1.6.0

package/README.md

@@ -28,16 +28,16 @@ See [CHANGELOG.md](./CHANGELOG.md) for release-by-release fixes and [Legacy Rele
 ## Latest Release Highlights
 
 <!-- release-highlights:start -->
-Latest release: **v1.5.0**
-
-- **hermes:** Add /gsd new-milestone command for chat-driven milestone creation (#1162).
-- **gsd:** Make CODEBASE.md workspace-aware in parent mode.
-- **gsd:** Doctor probe + validation for parent-workspace repos.
-- **gsd:** Surface per-repo git health in /gsd status + document limits.
-- **gsd:** Wire repository assignment into slice/task planning.
-- **gsd:** Add parent-workspace discovery UX + document nested-only layout.
-- **provider:** Add Cursor Agent provider.
-- **gsd:** Make workspace.mode parent behavioral (mode contract).
+Latest release: **v1.6.0**
+
+- **skills:** Load .claude/skills into the catalog (mirror Claude Code).
+- **gsd:** Extract uat dispatch discovery.
+- **daemon:** Split orchestrator agent loop.
+- **daemon:** Extract orchestrator tool execution.
+- **uok:** Scope audit degradation to kernel workspace.
+- **browser-tools:** Abort pending daemon starts on close.
+- **browser-tools:** Guard managed daemon connection lifecycle.
+- **worktree:** Centralize changed scan.
 
 <!-- release-highlights:end -->
 

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-f30abebf080db301
+d89940a8e727f2ea

package/dist/resources/extensions/ask-user-questions.js

@@ -209,7 +209,7 @@ export default function AskUserQuestions(pi) {
             "For single-select: each question must have 2-3 options. Put the recommended option first with '(Recommended)' suffix. Do not include an 'Other' or 'None of the above' option - the client adds one automatically.",
             "For multi-select: set allowMultiple: true. The user can pick any number of options. No 'None of the above' is added.",
             "When options involve code patterns, config choices, or architecture decisions, add a 'preview' field with markdown content (code blocks, lists, headers, etc.). The preview renders in a side-by-side panel when the option is highlighted.",
-            "Preview content is rendered in a fixed-height panel (max ~20 lines visible). Keep previews concise — show the most relevant snippet, not exhaustive examples. Longer content is truncated with a '+N lines hidden' indicator.",
+            "Preview content is rendered in a fixed-height panel (max ~20 lines visible). Keep previews concise — show the most relevant snippet, not exhaustive examples. Longer content stays fully accessible: the user scrolls it with PgUp/PgDn, with '▲/▼ N more' indicators marking hidden rows.",
         ],
         parameters: AskUserQuestionsParams,
         async execute(_toolCallId, params, signal, _onUpdate, ctx) {

package/dist/resources/extensions/browser-tools/engine/managed-gsd-browser.js

@@ -4,8 +4,6 @@ import { Type } from "@sinclair/typebox";
 import { BROWSER_CONTRACT_TOOL_NAMES } from "../../shared/browser-contract.js";
 import { resolveGsdBrowserMcpLaunchConfig } from "../../shared/gsd-browser-cli.js";
 import { buildMcpChildEnv } from "../../mcp-client/manager.js";
-const connections = new Map();
-const pendingConnections = new Map();
 const DEFAULT_MAX_LINES = 2_000;
 const DEFAULT_MAX_BYTES = 50 * 1024;
 const MCP_CALL_TIMEOUT_MS = 60_000;
@@ -297,6 +295,103 @@ function buildConnectionKey(launch) {
         env: launch.env ?? {},
     });
 }
+function combineAbortSignals(poolSignal, callerSignal) {
+    if (!callerSignal)
+        return poolSignal;
+    if (typeof AbortSignal.any === "function") {
+        return AbortSignal.any([poolSignal, callerSignal]);
+    }
+    const controller = new AbortController();
+    const abort = () => {
+        if (!controller.signal.aborted)
+            controller.abort();
+    };
+    if (poolSignal.aborted || callerSignal.aborted) {
+        abort();
+    }
+    else {
+        poolSignal.addEventListener("abort", abort, { once: true });
+        callerSignal.addEventListener("abort", abort, { once: true });
+    }
+    return controller.signal;
+}
+export class ManagedGsdBrowserConnectionPool {
+    connections = new Map();
+    pendingConnections = new Map();
+    connect;
+    closeConnection;
+    generation = 0;
+    closing = false;
+    constructor(connect, closeConnection) {
+        this.connect = connect;
+        this.closeConnection = closeConnection;
+    }
+    get activeCount() {
+        return this.connections.size;
+    }
+    get pendingCount() {
+        return this.pendingConnections.size;
+    }
+    getOrConnect(launch, signal) {
+        if (this.closing) {
+            return Promise.reject(new Error("gsd-browser connection pool is closing"));
+        }
+        const key = buildConnectionKey(launch);
+        const existing = this.connections.get(key);
+        if (existing)
+            return Promise.resolve(existing);
+        const pending = this.pendingConnections.get(key);
+        if (pending)
+            return pending.promise;
+        const generation = this.generation;
+        const abortController = new AbortController();
+        const connectionSignal = combineAbortSignals(abortController.signal, signal);
+        const connectionPromise = this.connect(launch, connectionSignal)
+            .then(async (connection) => {
+            if (this.closing || this.generation !== generation) {
+                await this.closeConnection(connection);
+                throw new Error("gsd-browser connection closed during startup");
+            }
+            this.connections.set(key, connection);
+            return connection;
+        })
+            .finally(() => {
+            if (this.pendingConnections.get(key)?.promise === connectionPromise) {
+                this.pendingConnections.delete(key);
+            }
+        });
+        this.pendingConnections.set(key, { promise: connectionPromise, abortController });
+        return connectionPromise;
+    }
+    async closeAll() {
+        this.closing = true;
+        this.generation += 1;
+        const activeConnections = Array.from(this.connections.values());
+        const pendingConnections = Array.from(this.pendingConnections.values());
+        this.connections.clear();
+        this.pendingConnections.clear();
+        for (const pending of pendingConnections) {
+            pending.abortController.abort();
+        }
+        const closingActive = activeConnections.map((connection) => this.closeConnection(connection));
+        const closingPending = pendingConnections.map(async (pending) => {
+            try {
+                const connection = await pending.promise;
+                await this.closeConnection(connection);
+            }
+            catch {
+                // Failed or invalidated connection attempts have already cleaned up.
+            }
+        });
+        try {
+            await Promise.allSettled([...closingActive, ...closingPending]);
+        }
+        finally {
+            this.closing = false;
+            this.generation += 1;
+        }
+    }
+}
 async function connectManagedGsdBrowser(launch, signal) {
     const client = new Client({ name: "gsd-pi-browser-tools", version: "1.0.0" });
     const transport = new StdioClientTransport({
@@ -326,27 +421,26 @@ async function connectManagedGsdBrowser(launch, signal) {
         throw error;
     }
 }
+async function closeManagedGsdBrowserConnection(connection) {
+    try {
+        await connection.client.close();
+    }
+    catch {
+        // Best-effort cleanup.
+    }
+    try {
+        await connection.transport.close();
+    }
+    catch {
+        // Best-effort cleanup.
+    }
+}
+const connectionPool = new ManagedGsdBrowserConnectionPool(connectManagedGsdBrowser, closeManagedGsdBrowserConnection);
 async function getOrConnectManagedGsdBrowser(ctx, signal) {
     const launch = resolveGsdBrowserMcpLaunchConfig(resolveProjectRoot(ctx), process.env, {
         sessionSuffix: resolveManagedSessionSuffix(ctx),
     });
-    const key = buildConnectionKey(launch);
-    const existing = connections.get(key);
-    if (existing)
-        return existing;
-    const pending = pendingConnections.get(key);
-    if (pending)
-        return pending;
-    const connectionPromise = connectManagedGsdBrowser(launch, signal);
-    pendingConnections.set(key, connectionPromise);
-    try {
-        const connection = await connectionPromise;
-        connections.set(key, connection);
-        return connection;
-    }
-    finally {
-        pendingConnections.delete(key);
-    }
+    return connectionPool.getOrConnect(launch, signal);
 }
 function isUnknownMcpToolError(error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -609,23 +703,7 @@ export function registerManagedGsdBrowserTools(pi) {
     }
 }
 export async function closeManagedGsdBrowser() {
-    const closing = Array.from(connections.entries()).map(async ([key, connection]) => {
-        try {
-            await connection.client.close();
-        }
-        catch {
-            // Best-effort cleanup.
-        }
-        try {
-            await connection.transport.close();
-        }
-        catch {
-            // Best-effort cleanup.
-        }
-        connections.delete(key);
-    });
-    await Promise.allSettled(closing);
-    pendingConnections.clear();
+    await connectionPool.closeAll();
 }
 export async function _resetManagedGsdBrowserForTest() {
     await closeManagedGsdBrowser();

package/dist/resources/extensions/gsd/activity-log.js

@@ -115,7 +115,7 @@ export function saveActivityLog(ctx, basePath, unitType, unitId) {
         }
         state.nextSeq += 1;
         state.lastSnapshotKeyByUnit.set(unitKey, key);
-        if (isUnifiedAuditEnabled()) {
+        if (isUnifiedAuditEnabled(basePath)) {
             emitUokAuditEvent(basePath, buildAuditEnvelope({
                 traceId: `activity:${unitType}:${unitId}`,
                 turnId: unitId,

package/dist/resources/extensions/gsd/auto/closeout.js

@@ -1,12 +1,17 @@
 // Project/App: gsd-pi
 // File Purpose: Auto-loop closeout, milestone report, and merge helpers.
 import { importExtensionModule } from "@gsd/pi-coding-agent";
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { join, basename } from "node:path";
+import { readFileSync } from "node:fs";
 import { MergeConflictError } from "../git-service.js";
 import { findUnmergedCompletedMilestones } from "../unmerged-milestone-guard.js";
 import { getIsolationMode } from "../preferences.js";
 import { isDbAvailable, getMilestone } from "../gsd-db.js";
 import { refreshWorkflowDatabaseFromDisk } from "../db-workspace.js";
 import { isClosedStatus } from "../status-guards.js";
+import { PLANNING_ARTIFACT_SUFFIXES } from "../paths.js";
 import { logWarning, logError } from "../workflow-logger.js";
 import { debugLog } from "../debug-logger.js";
 import { _resolveReportBasePath } from "./phase-helpers.js";
@@ -51,7 +56,15 @@ export async function restorePreflightStashOrStop(ic, preflight, milestoneId) {
  */
 export async function _runMilestoneMergeWithStashRestore(ic, milestoneId, options = {}) {
     const { ctx, pi, s, deps } = ic;
-    const projectRoot = s.originalBasePath || s.basePath;
+    // Resolve the project root once, before the merge can flip session path
+    // pointers (worktree teardown mutates s.basePath / s.scope). The guarded
+    // merge's preflight/postflight stash restore, the pre-merge ignored-markdown
+    // snapshot, the dirty-projection check, and the rebuild must all target this
+    // same tree; otherwise `.gsd` markdown restored on one tree can be silently
+    // overwritten by a rebuild on another. canonicalProjectRoot is the
+    // authoritative `.gsd`/DB writer path (see AutoSession.canonicalProjectRoot).
+    const projectRoot = s.originalBasePath || s.canonicalProjectRoot || s.basePath;
+    const ignoredProjectionSnapshot = snapshotIgnoredGsdMarkdownProjections(projectRoot);
     const mergeResult = deps.lifecycle.exitMilestone(milestoneId, {
         merge: true,
         guardedMerge: {
@@ -61,11 +74,11 @@ export async function _runMilestoneMergeWithStashRestore(ic, milestoneId, option
         },
     }, ctx.ui);
     if (mergeResult.ok) {
-        await markMilestoneMergedAndRebuild(s);
+        await markMilestoneMergedAndRebuild(s, projectRoot, ignoredProjectionSnapshot);
         return null;
     }
     if (mergeResult.reason === "postflight-stash-restore-failed") {
-        await markMilestoneMergedAndRebuild(s);
+        await markMilestoneMergedAndRebuild(s, projectRoot, ignoredProjectionSnapshot);
     }
     if (mergeResult.reason === "preflight-dirty-overlap" || mergeResult.reason === "preflight-unmerged-conflicts") {
         const reason = mergeResult.reason === "preflight-unmerged-conflicts"
@@ -122,10 +135,13 @@ export async function _runMilestoneMergeWithStashRestore(ic, milestoneId, option
     }
     return null;
 }
-async function markMilestoneMergedAndRebuild(s) {
+async function markMilestoneMergedAndRebuild(s, rebuildBasePath, ignoredProjectionSnapshot) {
     s.milestoneMergedInPhases = true;
+    if (hasDirtyGsdMarkdownProjections(rebuildBasePath, ignoredProjectionSnapshot)) {
+        logWarning("engine", "skipping markdown projection rebuild after milestone merge because restored .gsd edits are dirty");
+        return;
+    }
     try {
-        const rebuildBasePath = s.originalBasePath || s.canonicalProjectRoot || s.basePath;
         const { rebuildMarkdownProjectionsFromDb } = await import("../commands-maintenance.js");
         await rebuildMarkdownProjectionsFromDb(rebuildBasePath);
     }
@@ -133,6 +149,82 @@ async function markMilestoneMergedAndRebuild(s) {
         logWarning("engine", `markdown projection rebuild after milestone merge failed: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
+function hasDirtyGsdMarkdownProjections(basePath, ignoredProjectionSnapshot) {
+    try {
+        const output = execFileSync("git", ["status", "--porcelain", "-z", "--untracked-files=all", "--", ".gsd"], { cwd: basePath, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        const entries = output.split("\0").filter(Boolean);
+        for (let i = 0; i < entries.length; i++) {
+            const entry = entries[i];
+            if (entry.length <= 3)
+                continue;
+            const status = entry.slice(0, 2);
+            const path = entry.slice(3);
+            if (isGeneratedGsdMarkdownProjection(path))
+                return true;
+            if ((status === "R " || status === "C ") && i + 1 < entries.length) {
+                const dest = entries[++i];
+                if (isGeneratedGsdMarkdownProjection(dest))
+                    return true;
+            }
+        }
+    }
+    catch (err) {
+        void err;
+        // Fall through to ignored-file snapshot comparison below.
+    }
+    return ignoredGsdMarkdownProjectionSnapshotChanged(basePath, ignoredProjectionSnapshot);
+}
+function isGeneratedGsdMarkdownProjection(path) {
+    const normalized = path.replace(/\\/g, "/");
+    if (normalized === ".gsd/DECISIONS.md")
+        return true;
+    if (!normalized.startsWith(".gsd/milestones/") && !normalized.startsWith(".gsd/phases/")) {
+        return false;
+    }
+    return isGeneratedPlanningArtifactFileName(basename(normalized));
+}
+function isGeneratedPlanningArtifactFileName(fileName) {
+    if (!fileName.endsWith(".md"))
+        return false;
+    const stem = fileName.slice(0, -".md".length).toUpperCase();
+    for (const suffix of PLANNING_ARTIFACT_SUFFIXES) {
+        if (!stem.endsWith(`-${suffix}`))
+            continue;
+        const idPrefix = stem.slice(0, -suffix.length - 1);
+        return /^(?:[MST]\d+|\d{2,})(?:-[A-Z0-9]+)*$/.test(idPrefix);
+    }
+    return false;
+}
+function snapshotIgnoredGsdMarkdownProjections(basePath) {
+    try {
+        const output = execFileSync("git", ["ls-files", "--others", "--ignored", "--exclude-standard", "-z", "--", ".gsd"], { cwd: basePath, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        const snapshot = new Map();
+        for (const path of output.split("\0")) {
+            if (!isGeneratedGsdMarkdownProjection(path))
+                continue;
+            snapshot.set(path, hashFile(join(basePath, path)));
+        }
+        return snapshot;
+    }
+    catch {
+        return null;
+    }
+}
+function hashFile(path) {
+    return createHash("sha256").update(readFileSync(path)).digest("hex");
+}
+function ignoredGsdMarkdownProjectionSnapshotChanged(basePath, before) {
+    if (!before)
+        return true;
+    const after = snapshotIgnoredGsdMarkdownProjections(basePath);
+    if (!after || after.size !== before.size)
+        return true;
+    for (const [path, hash] of before) {
+        if (after.get(path) !== hash)
+            return true;
+    }
+    return false;
+}
 export async function _runMilestoneMergeOnceWithStashRestore(ic, milestoneId, options = {}) {
     if (ic.s.milestoneMergedInPhases) {
         debugLog("autoLoop", {

package/dist/resources/extensions/gsd/auto/orchestrator.js

@@ -21,7 +21,8 @@ import { createWorktreeSafetyModule } from "../worktree-safety.js";
 import { repairAutoWorktreeSafetyFailure } from "../auto-worktree-repair.js";
 import { resolveManifest } from "../unit-context-manifest.js";
 import { preDispatchHealthGate, recordHealthSnapshot, } from "../doctor-proactive.js";
-import { checkResourcesStale, autoWorktreeBranch, mergeMilestoneToMain } from "../auto-worktree.js";
+import { autoWorktreeBranch } from "../auto-worktree-branch-lifecycle.js";
+import { checkResourcesStale } from "../auto-worktree-resource-version.js";
 import { getSessionLockStatus } from "../session-lock.js";
 import { resolveUokFlags } from "../uok/flags.js";
 import { emitJournalEvent as _emitJournalEvent } from "../journal.js";
@@ -31,7 +32,7 @@ import { getPriorSliceCompletionBlocker } from "../dispatch-guard.js";
 import { GitServiceImpl } from "../git-service.js";
 import { WorktreeStateProjection } from "../worktree-state-projection.js";
 import { WorktreeLifecycle } from "../worktree-lifecycle.js";
-import { createMilestoneMergeTransaction } from "../milestone-merge-transaction.js";
+import { createDefaultMilestoneMergeTransaction } from "../milestone-merge-transaction.js";
 import { createWorkspace, scopeMilestone } from "../workspace.js";
 import { supportsStructuredQuestions } from "../workflow-mcp.js";
 import { getRegisteredToolSnapshot, getToolBaselineSnapshot } from "../auto-model-selection.js";
@@ -560,7 +561,7 @@ export class AutoOrchestrator {
                 return new GitServiceImpl(basePath, gitConfig);
             },
             worktreeProjection: new WorktreeStateProjection(),
-            mergeMilestone: createMilestoneMergeTransaction(mergeMilestoneToMain),
+            mergeMilestone: createDefaultMilestoneMergeTransaction(),
         });
     }
     rebuildScope(rawPath, milestoneId) {
@@ -998,16 +999,22 @@ export class AutoOrchestrator {
                 this.postAdvanceRecord(skipped);
                 return skipped;
             }
-            // Stuck-loop detection: when the window is saturated with copies of
-            // `nextKey` (count >= STUCK_WINDOW_SIZE), consult the Dispatch History
-            // module's full detect-stuck rule set for the verdict instead of the old
-            // bare saturation count. This keeps the saturation threshold (the window
-            // deliberately records benign idempotent repeats, so earlier-firing
-            // rules would false-positive on pause/resume re-advances) while gaining
-            // retry-budget suppression and diagnosable rule reasons. A saturated
-            // window with no verdict means the dispatch ledger says we are inside
-            // the unit's retry-backoff budget — let the retry proceed.
-            const stuckVerdict = matchingCount >= STUCK_WINDOW_SIZE ? this.dispatchHistory.detectStuck() : null;
+            // Stuck-loop detection: consult the Dispatch History module's full
+            // detect-stuck rule set once the window is *full* — not only when a
+            // single key saturates it. Gating on a single key's saturation count
+            // (matchingCount >= STUCK_WINDOW_SIZE) let two-unit oscillations slip
+            // through forever: an execute-task ↔ complete-slice loop (a slice gate
+            // that keeps reopening the same task, #1225) fills the window with two
+            // alternating keys, so neither key ever reaches the saturation count and
+            // detect-stuck's oscillation/repeat rules were never even invoked. Firing
+            // on window saturation instead covers both shapes. Consecutive same-key
+            // re-advances (the benign pause/resume churn the old count gate guarded
+            // against) are already short-circuited above by the idempotency skip, and
+            // legitimate retry backoff is still suppressed inside detect-stuck via the
+            // dispatch ledger — a saturated window with no verdict means we are inside
+            // the unit's retry-backoff budget, so let the retry proceed.
+            const windowSaturated = this.dispatchHistory.getRecentWindow().length >= STUCK_WINDOW_SIZE;
+            const stuckVerdict = windowSaturated ? this.dispatchHistory.detectStuck() : null;
             if (stuckVerdict) {
                 // #442: before declaring a stuck loop, verify the unit didn't actually
                 // complete on disk (stale DB) and recover if so — legacy graduated

package/dist/resources/extensions/gsd/auto/pre-dispatch.js

@@ -345,7 +345,8 @@ export async function runPreDispatch(ic, loopState) {
             if (stop)
                 return stop;
         }
-        // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
+        // PR creation (auto_pr) is handled by the publication handoff in
+        // the milestone merge transaction (#2302).
         deps.invalidateAllCaches();
         state = await deps.deriveState(s.canonicalProjectRoot);
         mid = state.activeMilestone?.id;
@@ -430,7 +431,8 @@ export async function runPreDispatch(ic, loopState) {
                 const stop = await _runMilestoneMergeOnceWithStashRestore(ic, s.currentMilestoneId);
                 if (stop)
                     return stop;
-                // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
+                // PR creation (auto_pr) is handled by the publication handoff in
+                // the milestone merge transaction (#2302).
             }
             const unmappedActive = countUnmappedActiveRequirements();
             const completionStopReason = formatCompletePhaseNextAction(unmappedActive);
@@ -506,7 +508,8 @@ export async function runPreDispatch(ic, loopState) {
             const stop = await _runMilestoneMergeOnceWithStashRestore(ic, s.currentMilestoneId);
             if (stop)
                 return stop;
-            // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
+            // PR creation (auto_pr) is handled by the publication handoff in
+            // the milestone merge transaction (#2302).
         }
         deps.sendDesktopNotification("GSD", `Milestone ${mid} complete!`, "success", "milestone", basename(s.originalBasePath || s.basePath));
         deps.logCmuxEvent(prefs, `Milestone ${mid} complete.`, "success");

package/dist/resources/extensions/gsd/auto/unit-phase.js

@@ -17,7 +17,7 @@ import { isDbAvailable, getTask } from "../gsd-db.js";
 import { parseUnitId } from "../unit-id.js";
 import { createCheckpoint, cleanupCheckpoint, rollbackToCheckpoint } from "../safety/git-checkpoint.js";
 import { resolveSafetyHarnessConfig } from "../safety/safety-harness.js";
-import { getUnitWorkflowDispatchReadinessError } from "../tool-contract.js";
+import { getUnitWorkflowDispatchReadinessErrorForModel } from "../tool-contract.js";
 import { prepareWorkflowMcpForProject } from "../workflow-mcp-auto-prep.js";
 import { applyThinkingLevelForModel, floorThinkingLevelForUnit, } from "../auto-model-selection.js";
 import { isSuspiciousGhostCompletion } from "../auto-unit-closeout.js";
@@ -246,17 +246,13 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     s.currentDispatchedModelId = s.currentUnitModel
         ? `${s.currentUnitModel.provider ?? ""}/${s.currentUnitModel.id ?? ""}`
         : null;
-    const compatibilityError = getUnitWorkflowDispatchReadinessError({
-        provider: s.currentUnitModel?.provider ?? ctx.model?.provider,
+    const compatibilityError = getUnitWorkflowDispatchReadinessErrorForModel({
+        model: s.currentUnitModel,
+        fallbackModel: ctx.model,
+        getProviderAuthMode: (provider) => ctx.modelRegistry.getProviderAuthMode(provider),
         projectRoot: s.basePath,
         surface: "auto-mode",
         unitType,
-        authMode: s.currentUnitModel?.provider
-            ? ctx.modelRegistry.getProviderAuthMode(s.currentUnitModel.provider)
-            : ctx.model?.provider
-                ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider)
-                : undefined,
-        baseUrl: s.currentUnitModel?.baseUrl ?? ctx.model?.baseUrl,
         activeTools: typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [],
     });
     const workflowMcpPrepModel = s.currentUnitModel;

package/dist/resources/extensions/gsd/auto-artifact-paths.js

@@ -5,10 +5,10 @@
 // resolveExpectedArtifactPath and diagnoseExpectedArtifact moved here from
 // auto-recovery.ts (Phase 5 dead-code cleanup). The artifact verification
 // function was removed entirely — callers now query WorkflowEngine directly.
-import { gsdRoot, resolveDir, resolveFile, resolveMilestonePath, resolveMilestoneFile, resolveSliceFile, relMilestoneFile, relSliceFile, buildTaskFileName, resolveSlicePath, resolveTasksDir, dirIsMetaOnlyLegacyMilestone, } from "./paths.js";
+import { gsdRoot, resolveDir, resolveFile, resolveMilestonePath, resolveMilestoneFile, resolveSliceFile, relMilestoneFile, relSliceFile, buildTaskFileName, resolveSlicePath, resolveTasksDir, dirIsMetaOnlyLegacyMilestone, normalizeRealPath, } from "./paths.js";
 import { milestoneIdToPhaseNum } from "./layout-policy.js";
 import { parseUnitId } from "./unit-id.js";
-import { dirname, join, relative } from "node:path";
+import { basename, dirname, join, relative } from "node:path";
 import { existsSync } from "node:fs";
 function resolveMilestoneArtifactPath(base, mid, suffix) {
     const existing = resolveProjectedMilestoneFile(base, mid, suffix) ?? resolveProjectMilestoneFile(base, mid, suffix);
@@ -193,8 +193,17 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
                 ?? resolveSlicePath(base, mid, sid);
             if (!slicePath || !tid)
                 return null;
-            const tasksDir = resolveTasksDir(base, mid, sid) ?? slicePath;
-            return join(tasksDir, buildTaskFileName(tid, "SUMMARY"));
+            // Legacy layout: slice dirs live under slices/<SID>/ and task summaries
+            // live in a tasks/ subdir. Flat-phase layout: slicePath IS the phase dir
+            // and task summaries live beside the plan files at the phase root. A
+            // tasks/ subdir may still exist in flat-phase for auxiliary task-scoped
+            // artifacts (e.g. T01-VERIFY.json gate outputs) — its mere existence must
+            // NOT redirect summary resolution into tasks/ (#1208).
+            const isLegacySlice = basename(dirname(slicePath)) === "slices";
+            const summaryDir = isLegacySlice
+                ? (resolveTasksDir(base, mid, sid) ?? slicePath)
+                : slicePath;
+            return join(summaryDir, buildTaskFileName(tid, "SUMMARY"));
         }
         case "complete-slice": {
             return resolveSliceArtifactPath(base, mid, sid, "SUMMARY");
@@ -299,7 +308,7 @@ export function resolveSliceResearchLocation(basePath, mid, sid) {
     if (canonicalPath && existsSync(canonicalPath)) {
         return {
             absolutePath: canonicalPath,
-            relativePath: relative(basePath, canonicalPath),
+            relativePath: relative(normalizeRealPath(basePath), canonicalPath),
         };
     }
     return { absolutePath: null, relativePath: null };

package/dist/resources/extensions/gsd/auto-direct-dispatch.js

@@ -7,10 +7,10 @@ import { loadFile } from "./files.js";
 import { isDbAvailable, getClosedSliceIds } from "./gsd-db.js";
 import { resolveSliceFile, relSliceFile, } from "./paths.js";
 import { buildResearchSlicePrompt, buildResearchMilestonePrompt, buildPlanSlicePrompt, buildPlanMilestonePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReassessRoadmapPrompt, buildRunUatPrompt, buildReplanSlicePrompt, } from "./auto-prompts.js";
-import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { loadEffectiveGSDPreferences, renderLanguageDirectiveForPrompt } from "./preferences.js";
 import { pauseAuto } from "./auto.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
-import { getUnitWorkflowDispatchReadinessError } from "./tool-contract.js";
+import { getUnitWorkflowDispatchReadinessErrorForModel } from "./tool-contract.js";
 export function parseDirectDispatchPhase(raw) {
     const tokens = raw.trim().split(/\s+/).filter(Boolean);
     if (tokens.length === 0)
@@ -213,13 +213,12 @@ export async function dispatchDirectPhase(ctx, pi, phase, base, opts = {}) {
             ctx.ui.notify(`Unknown phase "${phase}". Valid phases: research, plan, execute, complete, validate, reassess, uat, replan.`, "warning");
             return;
     }
-    const compatibilityError = getUnitWorkflowDispatchReadinessError({
-        provider: ctx.model?.provider,
+    const compatibilityError = getUnitWorkflowDispatchReadinessErrorForModel({
+        model: ctx.model,
+        getProviderAuthMode: (provider) => ctx.modelRegistry.getProviderAuthMode(provider),
         projectRoot,
         surface: "direct phase dispatch",
         unitType,
-        authMode: ctx.model?.provider ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider) : undefined,
-        baseUrl: ctx.model?.baseUrl,
         activeTools: typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [],
     });
     if (compatibilityError) {
@@ -232,5 +231,10 @@ export async function dispatchDirectPhase(ctx, pi, phase, base, opts = {}) {
         ctx.ui.notify("Session creation cancelled.", "warning");
         return;
     }
-    pi.sendMessage({ customType: "gsd-dispatch", content: prompt, display: false }, { triggerTurn: true });
+    // Inject the configured response language into the dispatched prompt content
+    // — the new session's system prompt does not carry the preferences block, so
+    // the language setting would otherwise never reach the unit (#1210).
+    const languageDirective = renderLanguageDirectiveForPrompt(loadEffectiveGSDPreferences(dispatchBase)?.preferences);
+    const dispatchContent = languageDirective ? `${languageDirective}\n\n${prompt}` : prompt;
+    pi.sendMessage({ customType: "gsd-dispatch", content: dispatchContent, display: false }, { triggerTurn: true });
 }