@opengsd/gsd-pi 1.4.0 → 1.5.0-dev.4fb2d460

package/src/resources/extensions/gsd/activity-log.ts

@@ -16,6 +16,7 @@ import { GSDError, GSD_IO_ERROR } from "./errors.js";
 const SEQ_PREFIX_RE = /^(\d+)-/;
 import type { ExtensionContext } from "@gsd/pi-coding-agent";
 import { gsdRoot } from "./paths.js";
+import { redactSecrets } from "./redact-secrets.js";
 import { buildAuditEnvelope, emitUokAuditEvent } from "./uok/audit.js";
 import { isUnifiedAuditEnabled } from "./uok/audit-toggle.js";
 
@@ -127,7 +128,9 @@ export function saveActivityLog(
     const fd = openSync(filePath, "w");
     try {
       for (const entry of entries) {
-        writeSync(fd, JSON.stringify(entry) + "\n");
+        // Redact secret-shaped substrings before persisting; .gsd/ is skipped by
+        // the secret scanner, so raw LLM/tool content could otherwise leak keys.
+        writeSync(fd, redactSecrets(JSON.stringify(entry)) + "\n");
       }
     } finally {
       closeSync(fd);

package/src/resources/extensions/gsd/artifact-verification.ts

@@ -45,7 +45,6 @@ import { resolveWorktreeProjectRoot } from "./worktree-root.js";
 import { hasImplementationArtifacts } from "./milestone-implementation-evidence.js";
 import { loadAllCaptures, loadPendingCaptures } from "./captures.js";
 import { proveMilestoneCloseout } from "./milestone-closeout-proof.js";
-
 /**
  * Optional override for the legacy roadmap parser used by verifyExpectedArtifact.
  * Production leaves this null so the real parseLegacyRoadmap runs; tests inject
@@ -72,6 +71,11 @@ function parseRoadmapForRecovery(content: string): ReturnType<NonNullable<typeof
   return parseLegacyRoadmap(content) as unknown as ReturnType<NonNullable<typeof _roadmapParserFn>>;
 }
 
+/** Slice count for plan-milestone verification; shared by scoped and legacy paths. */
+export function countPlanMilestoneRoadmapSlices(content: string): number {
+  return parseRoadmapForRecovery(content).slices.length;
+}
+
 export function diagnoseWorktreeIntegrityFailure(basePath: string): string | null {
   if (!isGsdWorktreePath(basePath)) return null;
   if (!existsSync(basePath)) {
@@ -336,8 +340,7 @@ export function verifyExpectedArtifact(
 
   if (unitType === "plan-milestone") {
     try {
-      const roadmap = parseRoadmapForRecovery(readFileSync(absPath, "utf-8"));
-      if (roadmap.slices.length === 0) {
+      if (countPlanMilestoneRoadmapSlices(readFileSync(absPath, "utf-8")) === 0) {
         logWarning("recovery", `verify-fail ${unitType} ${unitId}: roadmap has zero slices at ${absPath}`);
         return false;
       }
@@ -353,6 +356,19 @@ export function verifyExpectedArtifact(
       try {
         let taskIds: string[] | null = null;
         let dbPrimary = false;
+        const planContent = readFileSync(absPath, "utf-8");
+        let parsedTaskIds: string[] | null = null;
+        const getParsedTaskIds = (): string[] => {
+          if (parsedTaskIds) return parsedTaskIds;
+          parsedTaskIds = parseLegacyPlan(planContent).tasks.map((t: { id: string }) => t.id);
+          return parsedTaskIds;
+        };
+        const tasksBlockMatch = planContent.match(/<tasks>([\s\S]*?)<\/tasks>/i);
+        const tasksBlock = tasksBlockMatch?.[1] ?? "";
+        const hasEmbeddedTaskEntries =
+          tasksBlock.length > 0 &&
+          (/^\s*- \[[xX ]\] \*\*T\d+/m.test(tasksBlock) ||
+            /^\s*#{2,4}\s+T\d+\s*(?:--|—|:)/m.test(tasksBlock));
         if (isDbAvailable()) {
           const refreshed = refreshWorkflowDatabaseFromDisk();
           if (refreshed) {
@@ -365,24 +381,24 @@ export function verifyExpectedArtifact(
         }
 
         if (!taskIds) {
-          const planContent = readFileSync(absPath, "utf-8");
           const hasCheckboxTask = /^\s*- \[[xX ]\] \*\*T\d+/m.test(planContent);
           const hasHeadingTask = /^\s*#{2,4}\s+T\d+\s*(?:--|—|:)/m.test(planContent);
           if (!hasCheckboxTask && !hasHeadingTask) {
             logWarning("recovery", `verify-fail ${unitType} ${unitId}: plan has no task checkbox/heading (len=${planContent.length}) at ${absPath}`);
             return false;
           }
-          const plan = parseLegacyPlan(planContent);
-          if (plan.tasks.length > 0) taskIds = plan.tasks.map((t: { id: string }) => t.id);
+          const parsedIds = getParsedTaskIds();
+          if (parsedIds.length > 0) taskIds = parsedIds;
         }
 
-        if (taskIds && taskIds.length > 0) {
+        if (taskIds && taskIds.length > 0 && !hasEmbeddedTaskEntries) {
           const tasksDir = join(dirname(absPath), "tasks");
           if (existsSync(tasksDir)) {
             for (const tid of taskIds) {
               const taskPlanFile = join(tasksDir, `${tid}-PLAN.md`);
-              if (!existsSync(taskPlanFile)) {
-                logWarning("recovery", `verify-fail ${unitType} ${unitId}: task plan missing ${taskPlanFile}`);
+              const taskSummaryFile = join(tasksDir, `${tid}-SUMMARY.md`);
+              if (!existsSync(taskPlanFile) && !existsSync(taskSummaryFile)) {
+                logWarning("recovery", `verify-fail ${unitType} ${unitId}: task artifact missing for ${tid}`);
                 return false;
               }
             }

package/src/resources/extensions/gsd/auto/closeout.ts

@@ -3,8 +3,10 @@
 
 import { importExtensionModule, type ExtensionAPI, type ExtensionContext } from "@gsd/pi-coding-agent";
 
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
 import { join, basename } from "node:path";
-import { existsSync, cpSync } from "node:fs";
+import { existsSync, cpSync, readFileSync } from "node:fs";
 import type { AutoSession } from "./session.js";
 import type { LoopDeps } from "./loop-deps.js";
 import type { GSDState } from "../types.js";
@@ -16,7 +18,7 @@ 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 { gsdRoot } from "../paths.js";
+import { gsdRoot, PLANNING_ARTIFACT_SUFFIXES } from "../paths.js";
 import { atomicWriteSync } from "../atomic-write.js";
 import { logWarning, logError } from "../workflow-logger.js";
 import { debugLog } from "../debug-logger.js";
@@ -79,13 +81,14 @@ export async function restorePreflightStashOrStop(
 }
 
 /**
- * Run a milestone merge surrounded by preflight stash + always-on postflight
- * pop. The previous code popped the stash only after a successful merge, which
- * leaked `gsd-preflight-stash:M00x:*` entries whenever `mergeAndExit` threw —
- * leaving the user's pre-merge working tree silently stashed away after a
- * merge-conflict or other merge error. This helper restores the stash on
- * every exit path, then surfaces the merge or stash failure (in priority
- * order) as the loop's stop reason.
+ * Run a milestone merge through Worktree Lifecycle's guarded merge option,
+ * which surrounds the inner merge with preflight stash + always-on postflight
+ * pop. The previous closeout code popped the stash only after a successful
+ * merge, which leaked `gsd-preflight-stash:M00x:*` entries whenever
+ * `mergeAndExit` threw — leaving the user's pre-merge working tree silently
+ * stashed away after a merge-conflict or other merge error. Lifecycle now
+ * restores the stash on every attempted merge path, then this adapter surfaces
+ * the merge or stash failure (in priority order) as the loop's stop reason.
  *
  * Returns a `break` action when auto-mode must stop, or `null` when the merge
  * succeeded and the stash (if any) was restored cleanly.
@@ -97,66 +100,53 @@ export async function _runMilestoneMergeWithStashRestore(
 ): Promise<{ action: "break"; reason: string } | null> {
   const { ctx, pi, s, deps } = ic;
 
-  const preflight = deps.preflightCleanRoot(
-    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,
-    ctx.ui.notify.bind(ctx.ui),
+    {
+      merge: true,
+      guardedMerge: {
+        projectRoot,
+        preflightCleanRoot: deps.preflightCleanRoot,
+        postflightPopStash: deps.postflightPopStash,
+      },
+    },
+    ctx.ui,
   );
-  if (preflight.blocked) {
-    const reason = preflight.blockedReason === "unmerged-conflicts"
+
+  if (mergeResult.ok) {
+    await markMilestoneMergedAndRebuild(s, projectRoot, ignoredProjectionSnapshot);
+    return null;
+  }
+
+  if (mergeResult.reason === "postflight-stash-restore-failed") {
+    await markMilestoneMergedAndRebuild(s, projectRoot, ignoredProjectionSnapshot);
+  }
+
+  if (mergeResult.reason === "preflight-dirty-overlap" || mergeResult.reason === "preflight-unmerged-conflicts") {
+    const reason = mergeResult.reason === "preflight-unmerged-conflicts"
       ? `Pre-merge unresolved Git conflicts block milestone ${milestoneId}`
       : `Pre-merge dirty working tree overlaps milestone ${milestoneId}`;
     await deps.stopAuto(ctx, pi, reason, {
       preserveCompletedMilestoneBranch: true,
       preserveCloseoutTranscript: options.preserveCloseoutTranscript,
     });
-    return {
-      action: "break",
-      reason: preflight.blockedReason === "unmerged-conflicts"
-        ? "preflight-unmerged-conflicts"
-        : "preflight-dirty-overlap",
-    };
-  }
-
-  let mergeError: unknown = null;
-  const exitResult = deps.lifecycle.exitMilestone(
-    milestoneId,
-    { merge: true },
-    ctx.ui,
-  );
-  if (exitResult.ok) {
-    s.milestoneMergedInPhases = true;
-    try {
-      const projectRoot = s.originalBasePath || s.canonicalProjectRoot || s.basePath;
-      const { rebuildMarkdownProjectionsFromDb } = await import("../commands-maintenance.js");
-      await rebuildMarkdownProjectionsFromDb(projectRoot);
-    } catch (err) {
-      logWarning(
-        "engine",
-        `markdown projection rebuild after milestone merge failed: ${err instanceof Error ? err.message : String(err)}`,
-      );
-    }
-  } else {
-    mergeError = exitResult.cause ?? new Error(`exit ${exitResult.reason}`);
-  }
-
-  // Always attempt to restore the stashed working tree, even on merge error.
-  // postflightPopStash itself does not throw; failures surface via the
-  // PostflightResult.needsManualRecovery flag.
-  let stashResult: PostflightResult | null = null;
-  if (preflight.stashPushed) {
-    stashResult = deps.postflightPopStash(
-      s.originalBasePath || s.basePath,
-      milestoneId,
-      preflight.stashMarker,
-      ctx.ui.notify.bind(ctx.ui),
-    );
+    return { action: "break", reason: mergeResult.reason };
   }
 
   // Merge failure takes priority over stash recovery — the merge is the
   // authoritative gate. If the stash also needed manual recovery, the user
   // already saw the postflightPopStash notify above.
-  if (mergeError) {
+  if (mergeResult.reason === "merge-conflict") {
+    const mergeError = mergeResult.cause;
     if (mergeError instanceof MergeConflictError) {
       // A merge conflict is a recoverable human checkpoint, not an
       // infrastructure failure — the user resolves the conflict and runs
@@ -173,6 +163,10 @@ export async function _runMilestoneMergeWithStashRestore(
       });
       return { action: "break", reason: "merge-conflict" };
     }
+  }
+
+  if (mergeResult.reason === "merge-failed" || mergeResult.reason === "merge-conflict") {
+    const mergeError = mergeResult.cause;
     logError("engine", "Milestone merge failed with non-conflict error", {
       milestone: milestoneId,
       error: String(mergeError),
@@ -190,12 +184,123 @@ export async function _runMilestoneMergeWithStashRestore(
     return { action: "break", reason: "merge-failed" };
   }
 
-  if (stashResult) {
-    return stopOnPostflightRecoveryNeeded(ic, stashResult, milestoneId);
+  if (mergeResult.postflight) {
+    return stopOnPostflightRecoveryNeeded(ic, mergeResult.postflight, milestoneId);
   }
   return null;
 }
 
+type GsdMarkdownSnapshot = Map<string, string>;
+
+async function markMilestoneMergedAndRebuild(
+  s: AutoSession,
+  rebuildBasePath: string,
+  ignoredProjectionSnapshot: GsdMarkdownSnapshot | null,
+): Promise<void> {
+  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 { rebuildMarkdownProjectionsFromDb } = await import("../commands-maintenance.js");
+    await rebuildMarkdownProjectionsFromDb(rebuildBasePath);
+  } catch (err) {
+    logWarning(
+      "engine",
+      `markdown projection rebuild after milestone merge failed: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+}
+
+function hasDirtyGsdMarkdownProjections(
+  basePath: string,
+  ignoredProjectionSnapshot: GsdMarkdownSnapshot | null,
+): boolean {
+  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: string): boolean {
+  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: string): boolean {
+  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: string): GsdMarkdownSnapshot | null {
+  try {
+    const output = execFileSync(
+      "git",
+      ["ls-files", "--others", "--ignored", "--exclude-standard", "-z", "--", ".gsd"],
+      { cwd: basePath, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] },
+    );
+    const snapshot: GsdMarkdownSnapshot = 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: string): string {
+  return createHash("sha256").update(readFileSync(path)).digest("hex");
+}
+
+function ignoredGsdMarkdownProjectionSnapshotChanged(
+  basePath: string,
+  before: GsdMarkdownSnapshot | null,
+): boolean {
+  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: IterationContext,
   milestoneId: string,

package/src/resources/extensions/gsd/auto/finalize.ts

@@ -373,6 +373,14 @@ export async function runFinalize(
         files: leak.files.map((file) => ({ path: file.path, status: file.status })),
       });
       ctx.ui.notify(message, "error");
+      try {
+        deps.checkpointWorkflowDatabase?.();
+      } catch (err) {
+        debugLog("autoLoop", {
+          phase: "root-write-leak-checkpoint-failed",
+          error: err instanceof Error ? err.message : String(err),
+        });
+      }
       await deps.stopAuto(ctx, pi, "Root-write leak during isolated auto-mode", {
         preserveCompletedMilestoneBranch: true,
       });

package/src/resources/extensions/gsd/auto/loop-deps.ts

@@ -80,6 +80,7 @@ export interface LoopDeps {
   ) => Promise<void>;
   pauseAuto: PauseAutoFn;
   clearUnitTimeout: () => void;
+  checkpointWorkflowDatabase?: () => void;
   updateProgressWidget: (
     ctx: ExtensionContext,
     unitType: string,

package/src/resources/extensions/gsd/auto/orchestrator.ts

@@ -34,7 +34,8 @@ 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";
@@ -49,7 +50,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";
@@ -731,7 +732,7 @@ export class AutoOrchestrator implements AutoOrchestrationModule {
         return new GitServiceImpl(basePath, gitConfig);
       },
       worktreeProjection: new WorktreeStateProjection(),
-      mergeMilestoneToMain: createMilestoneMergeTransaction(mergeMilestoneToMain),
+      mergeMilestone: createDefaultMilestoneMergeTransaction(),
     });
   }
 

package/src/resources/extensions/gsd/auto/pre-dispatch.ts

@@ -440,7 +440,8 @@ export async function runPreDispatch(
       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();
 
@@ -551,7 +552,8 @@ export async function runPreDispatch(
         // #2909 / #5538-followup: preflight stash + always-on postflight pop.
         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);
@@ -654,7 +656,8 @@ export async function runPreDispatch(
       // #2909 / #5538-followup: preflight stash + always-on postflight pop.
       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",

package/src/resources/extensions/gsd/auto/run-unit.ts

@@ -26,7 +26,7 @@ import { debugLog } from "../debug-logger.js";
 import { logWarning, logError } from "../workflow-logger.js";
 import { resolveAutoSupervisorConfig } from "../preferences.js";
 import { readUnitRuntimeRecord, type AutoUnitRuntimeRecord } from "../unit-runtime.js";
-import { consumeAutoWakeup } from "./schedule-wakeup.js";
+import { clearAutoWakeup, consumeAutoWakeup } from "./schedule-wakeup.js";
 import { applyUnitSkillVisibility } from "../skill-scope.js";
 
 const UNIT_FAILSAFE_BUFFER_MS = 30_000;
@@ -248,7 +248,7 @@ export async function runUnit(
     ((supervisor.idle_timeout_minutes ?? 10) * 60 * 1000) + UNIT_FAILSAFE_BUFFER_MS,
   );
   let unitTimeoutHandle: ReturnType<typeof setTimeout> | undefined;
-  let result: UnitResult;
+  let result: UnitResult = { status: "cancelled" };
   try {
     const awaitAgentEndWithTimeout = (agentEndPromise: Promise<UnitResult>): Promise<UnitResult> => {
       const timeoutResult = new Promise<UnitResult>((resolve) => {
@@ -360,6 +360,9 @@ export async function runUnit(
     }
   } finally {
     if (unitTimeoutHandle) clearTimeout(unitTimeoutHandle);
+    if (result.status !== "completed") {
+      clearAutoWakeup(s.basePath, unitType, unitId);
+    }
     ctx.ui.setWorkingMessage?.(undefined);
     setVisibleSkills?.(undefined);
   }

package/src/resources/extensions/gsd/auto/schedule-wakeup.ts

@@ -35,6 +35,14 @@ export function consumeAutoWakeup(
   return wakeup;
 }
 
+export function clearAutoWakeup(
+  basePath: string,
+  unitType: string,
+  unitId: string,
+): void {
+  pendingWakeups.delete(wakeupKey(basePath, unitType, unitId));
+}
+
 export function _resetAutoWakeupsForTest(): void {
   pendingWakeups.clear();
 }

package/src/resources/extensions/gsd/auto/unit-phase.ts

@@ -29,7 +29,7 @@ import type { MinimalModelRegistry } from "../context-budget.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,
@@ -343,17 +343,13 @@ export async function runUnitPhase(
     ? `${(s.currentUnitModel as any).provider ?? ""}/${(s.currentUnitModel as any).id ?? ""}`
     : null;
 
-  const compatibilityError = getUnitWorkflowDispatchReadinessError({
-    provider: s.currentUnitModel?.provider ?? ctx.model?.provider,
+  const compatibilityError = getUnitWorkflowDispatchReadinessErrorForModel({
+    model: s.currentUnitModel as any,
+    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 as any)?.baseUrl ?? ctx.model?.baseUrl,
     activeTools: typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [],
   });
   const workflowMcpPrepModel = s.currentUnitModel;

package/src/resources/extensions/gsd/auto-artifact-paths.ts

@@ -22,7 +22,7 @@ import {
 } 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(
@@ -221,8 +221,17 @@ export function resolveExpectedArtifactPath(
         ?? resolveProjectSlicePath(base, mid, sid!)
         ?? 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");

package/src/resources/extensions/gsd/auto-direct-dispatch.ts

@@ -27,11 +27,11 @@ import {
   buildRunUatPrompt,
   buildReplanSlicePrompt,
 } from "./auto-prompts.js";
-import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { loadEffectiveGSDPreferences, renderLanguageDirectiveForPrompt } from "./preferences.js";
 import type { MinimalModelRegistry } from "./context-budget.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: string): { phase: string; milestoneId?: string } {
   const tokens = raw.trim().split(/\s+/).filter(Boolean);
@@ -266,13 +266,12 @@ export async function dispatchDirectPhase(
       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) {
@@ -287,8 +286,15 @@ export async function dispatchDirectPhase(
     ctx.ui.notify("Session creation cancelled.", "warning");
     return;
   }
+  // 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: prompt, display: false },
+    { customType: "gsd-dispatch", content: dispatchContent, display: false },
     { triggerTurn: true },
   );
 }