@opengsd/gsd-pi 1.5.0-dev.553dc518 → 1.5.0-dev.c4c8885f

package/src/resources/extensions/gsd/preferences.ts

@@ -1033,6 +1033,26 @@ export function renderPreferencesForSystemPrompt(
   return lines.join("\n");
 }
 
+/**
+ * Render a compact response-language directive for injection into dispatched
+ * prompt *content* (discuss/QA and auto-execution unit prompts).
+ *
+ * The main session's system prompt already carries the full GSD Skill
+ * Preferences block (including language) via `before_agent_start`, but
+ * discuss/QA turns and auto-execution units are dispatched as separate
+ * turns/sessions whose prompts are assembled here — without that block — so the
+ * configured language never reaches them (#1210). Injecting this directive into
+ * the dispatched prompt content makes the `language` preference effective across
+ * both guided and auto workflows.
+ *
+ * Returns "" when no language is configured.
+ */
+export function renderLanguageDirectiveForPrompt(preferences: GSDPreferences | undefined): string {
+  if (!preferences?.language) return "";
+  const safeLang = preferences.language.replace(/[\r\n]/g, " ").slice(0, 50);
+  return `## Response Language\n\nAlways respond in ${safeLang} — questions, explanations, and summaries.`;
+}
+
 // ─── Hook Resolution ──────────────────────────────────────────────────────────
 
 /**

package/src/resources/extensions/gsd/rule-registry.ts

@@ -22,8 +22,9 @@ import type {
 } from "./types.js";
 import { resolvePostUnitHooks, resolvePreDispatchHooks } from "./preferences.js";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { parseUnitId } from "./unit-id.js";
+import { resolveMilestonePath } from "./paths.js";
 import { queryJournal, type JournalEntry } from "./journal.js";
 import { readUnitRuntimeRecord, type UnitRuntimePhase } from "./unit-runtime.js";
 import { extractFrontmatterVerdict } from "./verdict-parser.js";
@@ -32,13 +33,45 @@ import { extractFrontmatterVerdict } from "./verdict-parser.js";
 
 export function resolveHookArtifactPath(basePath: string, unitId: string, artifactName: string): string {
   const { milestone, slice, task } = parseUnitId(unitId);
-  if (task !== undefined && slice !== undefined) {
-    return join(basePath, ".gsd", "milestones", milestone, "slices", slice, "tasks", `${task}-${artifactName}`);
+
+  // Prefer the active phase directory (flat-phase layout: .gsd/phases/<NN>-.../).
+  // Configured gate artifacts are canonical phase-level files (e.g.
+  // BROWSER-RUNTIME-EVIDENCE.md), so resolve the exact declared name first,
+  // then a task-prefixed variant for retry sentinels / rework briefs.
+  const candidates: string[] = [];
+  const phaseDir = resolveMilestonePath(basePath, milestone);
+  const isFlatPhaseDir = phaseDir !== null
+    && !(dirname(phaseDir).endsWith("/milestones") || dirname(phaseDir).endsWith("\\milestones"));
+  if (isFlatPhaseDir) {
+    candidates.push(join(phaseDir, artifactName));
+    if (task !== undefined) {
+      candidates.push(join(phaseDir, `${task}-${artifactName}`));
+    }
   }
-  if (slice !== undefined) {
-    return join(basePath, ".gsd", "milestones", milestone, "slices", slice, artifactName);
+
+  // Legacy nested layout fallbacks (.gsd/milestones/<M>/slices/<S>/tasks/...).
+  const legacyBase = join(basePath, ".gsd", "milestones", milestone);
+  let legacyDefault: string;
+  if (task !== undefined && slice !== undefined) {
+    legacyDefault = join(legacyBase, "slices", slice, "tasks", `${task}-${artifactName}`);
+    candidates.push(legacyDefault);
+    candidates.push(join(legacyBase, "slices", slice, "tasks", artifactName));
+    candidates.push(join(legacyBase, "slices", slice, artifactName));
+  } else if (slice !== undefined) {
+    legacyDefault = join(legacyBase, "slices", slice, artifactName);
+    candidates.push(legacyDefault);
+  } else {
+    legacyDefault = join(legacyBase, artifactName);
   }
-  return join(basePath, ".gsd", "milestones", milestone, artifactName);
+  candidates.push(join(legacyBase, artifactName));
+
+  const existing = candidates.find((candidate) => existsSync(candidate));
+  if (existing) return existing;
+
+  // Nothing on disk yet: prefer the active phase path when the phase dir is
+  // known, otherwise fall back to the legacy default (preserves pre-flat-phase
+  // behavior for missing-artifact diagnostics).
+  return isFlatPhaseDir ? join(phaseDir!, artifactName) : legacyDefault;
 }
 
 // ─── Dispatch Rule Conversion ──────────────────────────────────────────────
@@ -126,6 +159,13 @@ export class RuleRegistry {
     forceRun?: boolean;
   }> = [];
   cycleCounts: Map<string, number> = new Map();
+  /**
+   * Cycle keys that have already been granted a one-shot re-dispatch after a
+   * lost/interrupted dispatch (hook charged a cycle but never produced its own
+   * unit-end). Bounds the dispatch-cycle refund to exactly one per gate so a
+   * hook that repeatedly fails to complete cannot loop forever.
+   */
+  redispatchedGateKeys: Set<string> = new Set();
   retryPending: boolean = false;
   retryTrigger: { unitType: string; unitId: string; retryArtifact?: string } | null = null;
   hookFailure: HookFailureState | null = null;
@@ -364,6 +404,14 @@ export class RuleRegistry {
       pendingRetry: false,
     };
 
+    return this._buildHookDispatch(config, triggerUnitId);
+  }
+
+  /** Construct the sidecar dispatch for a hook without mutating registry state. */
+  private _buildHookDispatch(
+    config: PostUnitHookConfig,
+    triggerUnitId: string,
+  ): HookDispatchResult {
     const { milestone: mid, slice: sid, task: tid } = parseUnitId(triggerUnitId);
     let prompt = config.prompt
       .replace(/\{milestoneId\}/g, mid ?? "")
@@ -375,12 +423,29 @@ export class RuleRegistry {
     return {
       hookName: config.name,
       prompt,
-      model: config.model,
+      // Model selection (including fallbacks[]) is handled by
+      // resolveModelWithFallbacksForUnit for the `hook/<name>` unit type (#1229).
       unitType: `hook/${config.name}`,
       unitId: triggerUnitId,
     };
   }
 
+  /**
+   * Reconstruct the in-flight hook's dispatch from the restored `activeHook`
+   * state, without mutating the registry. Used to reconcile a persisted
+   * `activeHook` whose session-local dispatch was lost across a pause/resume
+   * or crash-recovery, so the hook actually runs instead of being charged
+   * against the next unrelated unit's close-out (#1246).
+   */
+  getPendingHookDispatch(basePath: string): HookDispatchResult | null {
+    if (!this.activeHook) return null;
+    const config = resolvePostUnitHooks(basePath).find(
+      h => h.name === this.activeHook!.hookName,
+    );
+    if (!config) return null;
+    return this._buildHookDispatch(config, this.activeHook.triggerUnitId);
+  }
+
   private _assessHookCompletion(
     basePath: string,
     hook: HookExecutionState,
@@ -503,6 +568,30 @@ export class RuleRegistry {
     observedCleanExecution: boolean,
   ): HookDispatchResult | null {
     if (!observedCleanExecution) {
+      // The hook was charged a cycle at dispatch but never produced its own
+      // unit-end — its dispatch was lost/interrupted (pause/resume, crash
+      // recovery). Refund that dispatch-consumed cycle exactly once so the gate
+      // is re-dispatched at least once instead of hard-blocking on a hook that
+      // never actually ran.
+      //
+      // This refund is intentionally UNCONDITIONAL on the first lost dispatch —
+      // it must NOT be gated on `currentCycle >= max_cycles`. A lost dispatch is
+      // a non-run: charging its cycle at dispatch time must not consume the
+      // hook's real-run budget. Gating the refund on "budget already exhausted"
+      // lets a lost dispatch below max_cycles silently eat a genuine cycle, so
+      // the hook gets one fewer real run than configured — reintroducing #1244
+      // for max_cycles >= 2 (see the "does not steal a real-run cycle" test).
+      // The redispatchedGateKeys flag bounds this to a single refund per gate,
+      // so repeated lost dispatches still terminate (total dispatches never
+      // exceed max_cycles + 1) and a hook that keeps failing blocks normally.
+      const cycleKey = hookCycleKey(config, hook);
+      if (!this.redispatchedGateKeys.has(cycleKey)) {
+        this.redispatchedGateKeys.add(cycleKey);
+        const currentCycle = this.cycleCounts.get(cycleKey);
+        if (typeof currentCycle === "number" && currentCycle > 0) {
+          this.cycleCounts.set(cycleKey, currentCycle - 1);
+        }
+      }
       return this._rerunGateOrBlock(config, hook, basePath, {
         reason: `hook/${config.name} did not complete cleanly before the trigger unit resumed`,
       });
@@ -839,6 +928,7 @@ export class RuleRegistry {
     this.activeHook = null;
     this.hookQueue = [];
     this.cycleCounts.clear();
+    this.redispatchedGateKeys.clear();
     this.retryPending = false;
     this.retryTrigger = null;
     this.hookFailure = null;
@@ -855,6 +945,7 @@ export class RuleRegistry {
   persistState(basePath: string): void {
     const state: PersistedHookState = {
       cycleCounts: Object.fromEntries(this.cycleCounts),
+      redispatchedGateKeys: Array.from(this.redispatchedGateKeys),
       activeHook: this.activeHook ? { ...this.activeHook } : null,
       hookQueue: this.hookQueue.map(entry => ({
         hookName: entry.config.name,
@@ -888,6 +979,14 @@ export class RuleRegistry {
           }
         }
       }
+      this.redispatchedGateKeys.clear();
+      if (Array.isArray(state.redispatchedGateKeys)) {
+        for (const key of state.redispatchedGateKeys) {
+          if (typeof key === "string") {
+            this.redispatchedGateKeys.add(key);
+          }
+        }
+      }
       this.activeHook = state.activeHook && typeof state.activeHook === "object"
         ? { ...state.activeHook }
         : null;
@@ -918,7 +1017,7 @@ export class RuleRegistry {
       if (existsSync(filePath)) {
         writeFileSync(
           filePath,
-          JSON.stringify({ cycleCounts: {}, activeHook: null, hookQueue: [], savedAt: new Date().toISOString() }, null, 2),
+          JSON.stringify({ cycleCounts: {}, redispatchedGateKeys: [], activeHook: null, hookQueue: [], savedAt: new Date().toISOString() }, null, 2),
           "utf-8",
         );
       }
@@ -1014,7 +1113,10 @@ export class RuleRegistry {
     return {
       hookName: hook.name,
       prompt,
-      model: hook.model,
+      // Model selection (including fallbacks[]) is resolved by dispatchHookUnit
+      // via resolveModelWithFallbacksForUnit for the `hook/<name>` unit type,
+      // matching the auto-mode path. Emitting the primary-only model here would
+      // discard the configured fallback chain (#1229).
       unitType: `hook/${hook.name}`,
       unitId,
     };

package/src/resources/extensions/gsd/skill-discovery.ts

@@ -9,8 +9,8 @@
  */
 
 import { existsSync, readdirSync, readFileSync, type Dirent } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
+import { getSkillDirectories } from "@gsd/pi-coding-agent";
 import { gsdHome } from "./gsd-home.js";
 import { getInstalledSkills, normalizeSkillName } from "./skills.js";
 
@@ -20,28 +20,47 @@ export interface DiscoveredSkill {
   location: string;
 }
 
-/** Snapshot of normalized skill names at auto-mode start */
-let baselineSkills: Set<string> | null = null;
+/**
+ * Snapshot state. `searchDirs` is captured at snapshot time so every detection
+ * pass during the session scans the same project + user dirs (the bug fix:
+ * previously only user dirs were scanned, so skills installed into the project
+ * mid-session were silently missed).
+ */
+interface SkillSnapshotState {
+  baselineNames: Set<string>;
+  searchDirs: string[];
+}
+
+let snapshot: SkillSnapshotState | null = null;
 
 /**
  * Snapshot the current installed skill catalog. Call at auto-mode start.
+ * `cwd` is the project base path; skills dropped into `<cwd>/.agents/skills/`,
+ * `<cwd>/.claude/skills/`, or `<cwd>/.gsd/skills/` mid-session are detected.
  */
-export function snapshotSkills(): void {
-  baselineSkills = snapshotCurrentSkillNames();
+export function snapshotSkills(options?: { cwd?: string }): void {
+  const searchDirs = getSkillDirectories({
+    cwd: options?.cwd ?? process.cwd(),
+    gsdHome: gsdHome(),
+  }).map((entry) => entry.path);
+  snapshot = {
+    baselineNames: snapshotCurrentSkillNames(searchDirs),
+    searchDirs,
+  };
 }
 
 /**
  * Clear the snapshot. Call when auto-mode stops.
  */
 export function clearSkillSnapshot(): void {
-  baselineSkills = null;
+  snapshot = null;
 }
 
 /**
  * Check if a snapshot is active (auto-mode is running with discovery).
  */
 export function hasSkillSnapshot(): boolean {
-  return baselineSkills !== null;
+  return snapshot !== null;
 }
 
 /**
@@ -49,12 +68,12 @@ export function hasSkillSnapshot(): boolean {
  * Returns skill metadata for any new skills found in the loader catalog or on disk.
  */
 export function detectNewSkills(): DiscoveredSkill[] {
-  if (!baselineSkills) return [];
+  if (!snapshot) return [];
 
   const newSkills: DiscoveredSkill[] = [];
-  for (const skill of getCurrentSkillsForDiscovery()) {
+  for (const skill of getCurrentSkillsForDiscovery(snapshot.searchDirs)) {
     const normalized = normalizeSkillName(skill.name);
-    if (baselineSkills.has(normalized)) continue;
+    if (snapshot.baselineNames.has(normalized)) continue;
     newSkills.push(skill);
   }
 
@@ -84,7 +103,13 @@ export async function refreshCatalogForNewSkills(options?: {
     }
   }
 
-  snapshotSkills();
+  // Re-snapshot, preserving the search dirs captured at auto-mode start.
+  if (snapshot) {
+    snapshot = {
+      baselineNames: snapshotCurrentSkillNames(),
+      searchDirs: snapshot.searchDirs,
+    };
+  }
   const names = newSkills.map((skill) => skill.name).join(", ");
   options?.notify?.(`GSD: loaded new skills: ${names}`, "info");
   return newSkills;
@@ -132,19 +157,18 @@ function escapeXml(value: string): string {
   });
 }
 
-function skillSearchDirs(): string[] {
-  return [
-    join(gsdHome(), "agent", "skills"),
-    join(homedir(), ".agents", "skills"),
-    join(homedir(), ".claude", "skills"),
-  ];
+function snapshotCurrentSkillNames(searchDirsOverride?: string[]): Set<string> {
+  // Uses explicit dirs, the snapshot's search dirs when active, or user-only dirs
+  // (no project context) when called before a snapshot is taken.
+  const searchDirs = searchDirsOverride ?? snapshot?.searchDirs ?? defaultSearchDirs();
+  return new Set(getCurrentSkillsForDiscovery(searchDirs).map(skill => normalizeSkillName(skill.name)));
 }
 
-function snapshotCurrentSkillNames(): Set<string> {
-  return new Set(getCurrentSkillsForDiscovery().map(skill => normalizeSkillName(skill.name)));
+function defaultSearchDirs(): string[] {
+  return getSkillDirectories({ cwd: process.cwd(), gsdHome: gsdHome() }).map((entry) => entry.path);
 }
 
-function getCurrentSkillsForDiscovery(): DiscoveredSkill[] {
+function getCurrentSkillsForDiscovery(searchDirs: string[]): DiscoveredSkill[] {
   const skills = new Map<string, DiscoveredSkill>();
   for (const skill of getInstalledSkills()) {
     const normalized = normalizeSkillName(skill.name);
@@ -155,7 +179,7 @@ function getCurrentSkillsForDiscovery(): DiscoveredSkill[] {
     });
   }
 
-  for (const skill of getDiskSkills()) {
+  for (const skill of getDiskSkills(searchDirs)) {
     const normalized = normalizeSkillName(skill.name);
     if (!skills.has(normalized)) skills.set(normalized, skill);
   }
@@ -163,9 +187,9 @@ function getCurrentSkillsForDiscovery(): DiscoveredSkill[] {
   return [...skills.values()];
 }
 
-function getDiskSkills(): DiscoveredSkill[] {
+function getDiskSkills(searchDirs: string[]): DiscoveredSkill[] {
   const skills = new Map<string, DiscoveredSkill>();
-  for (const dir of skillSearchDirs()) {
+  for (const dir of searchDirs) {
     if (!existsSync(dir)) continue;
     let entries: Dirent[];
     try {

package/src/resources/extensions/gsd/state-reconciliation/drift/artifact-db.ts

@@ -213,21 +213,13 @@ function detectArtifactDbStatusDriftForMilestone(
 
     for (const task of tasks) {
       if (isClosedStatus(task.status)) continue;
-      // Flat-phase: task summaries live in the phase dir as TID-SUMMARY.md
-      let diskTaskSummary = resolveTaskFile(
+      const diskTaskSummary = resolveTaskFile(
         basePath,
         milestoneId,
         slice.id,
         task.id,
         "SUMMARY",
       );
-      if (!diskTaskSummary) {
-        const phaseDir = resolveMilestonePath(basePath, milestoneId);
-        if (phaseDir) {
-          const flatSummary = join(phaseDir, `${task.id}-SUMMARY.md`);
-          if (existsSync(flatSummary)) diskTaskSummary = flatSummary;
-        }
-      }
       if (!diskTaskSummary || !existsSync(diskTaskSummary)) continue;
       addUniqueDrift(drifts, seen, {
         kind: "artifact-db-status-divergence",

package/src/resources/extensions/gsd/state-reconciliation/drift/completion.ts

@@ -20,11 +20,9 @@ import {
 } from "../../gsd-db.js";
 import {
   resolveMilestoneFile,
-  resolveMilestonePath,
   resolveSliceFile,
   resolveTaskFile,
 } from "../../paths.js";
-import { join } from "node:path";
 import type { GSDState } from "../../types.js";
 import type { DriftContext, DriftHandler, DriftRecord } from "../types.js";
 
@@ -105,23 +103,13 @@ function collectMilestoneCompletionDrift(
     for (const task of getSliceTasks(mid, slice.id)) {
       if (!COMPLETE_STATUSES.has(task.status)) continue;
       if (task.completed_at !== null) continue;
-      // Flat-phase: task summaries live in the phase dir as TID-SUMMARY.md.
-      // Legacy: resolveTaskFile returns the tasks/TID/TID-SUMMARY.md path.
-      let taskSummary = resolveTaskFile(
+      const taskSummary = resolveTaskFile(
         ctx.basePath,
         mid,
         slice.id,
         task.id,
         "SUMMARY",
       );
-      // Flat-phase fallback: check the phase dir directly
-      if (!taskSummary) {
-        const phaseDir = resolveMilestonePath(ctx.basePath, mid);
-        if (phaseDir) {
-          const flatSummary = join(phaseDir, `${task.id}-SUMMARY.md`);
-          if (existsSync(flatSummary)) taskSummary = flatSummary;
-        }
-      }
       if (taskSummary && existsSync(taskSummary)) {
         drifts.push({
           kind: "missing-completion-timestamp",
@@ -182,15 +170,7 @@ export function repairMissingCompletionTimestamp(
       task.completed_at !== null ||
       !COMPLETE_STATUSES.has(task.status)
     ) return;
-    // Flat-phase: task summaries live in the phase dir as TID-SUMMARY.md
-    let summary = resolveTaskFile(ctx.basePath, mid, sid, tid, "SUMMARY");
-    if (!summary) {
-      const phaseDir = resolveMilestonePath(ctx.basePath, mid);
-      if (phaseDir) {
-        const flatSummary = join(phaseDir, `${tid}-SUMMARY.md`);
-        if (existsSync(flatSummary)) summary = flatSummary;
-      }
-    }
+    const summary = resolveTaskFile(ctx.basePath, mid, sid, tid, "SUMMARY");
     const ts = summary ? summaryMtimeIso(summary) : null;
     if (!ts) return;
     updateTaskStatus(mid, sid, tid, task.status, ts);

package/src/resources/extensions/gsd/state-reconciliation/index.ts

@@ -73,6 +73,20 @@ export async function reconcileBeforeDispatch(
   if (!deps.dryRun) {
     const { capturePlanningCompatIfNeeded } = await import("../compat/planning-compat.js");
     await capturePlanningCompatIfNeeded(basePath);
+
+    // Self-heal phantom projection entries (#1257): a renamed/removed phase
+    // directory leaves stale `.compat.json` projection paths that no detector
+    // ever prunes (they all skip missing files), so the marker drifts from disk
+    // reality permanently. Drop entries whose backing file is gone before the
+    // detect passes run. Gated on !dryRun to keep detection read-only.
+    const { pruneOrphanedProjectionEntries } = await import("../compat/compat-marker.js");
+    const prunedCount = pruneOrphanedProjectionEntries(basePath);
+    if (prunedCount > 0) {
+      logWarning(
+        "reconcile",
+        `pruned ${prunedCount} orphaned projection entr${prunedCount === 1 ? "y" : "ies"} from .compat.json (backing file no longer on disk)`,
+      );
+    }
   }
 
   for (let pass = 0; pass < MAX_PASSES; pass++) {

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

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync, utimesSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -360,6 +360,174 @@ test("canonical worktree + project-root legacy dir produces legacy filename (#bu
   }
 });
 
+// ── cursor[bot] 3523932401: bare milestone id must not match a team-suffix ────
+//
+// A bare milestone id (M001, no team-mode suffix) resolves its phase dir by
+// scanning phases/NN-*. Before the guard (commit 8f45bf3),
+// phaseDirMatchesMilestoneId returned true for ANY same-number dir, so a
+// leftover team-mode projection (phases/01-<6char>-.../, from a prior
+// team-suffixed run) matched the bare id too. When that stale dir carried a
+// newer mtime, pickPreferredPhaseDir selected it over the real title dir and
+// resolved the ROADMAP into a directory that has no ROADMAP — the file-not-found
+// retry loop. The guard (slugLooksLikeTeamSuffixProjection) rejects
+// team-suffix-looking slugs for bare ids in the primary pass; the suffixed
+// projection stays available only as a fallback when the primary pass finds
+// nothing (#1195, guarded by the second test below).
+
+test("bare milestone id prefers the real title dir over a newer team-suffix projection (cursor 3523932401)", () => {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-bare-teamsuffix-")));
+  try {
+    const phasesDir = join(root, ".gsd", "phases");
+    // Intended flat-phase dir for the bare id: 01-<title-slug>/ with the ROADMAP.
+    const intendedDir = join(phasesDir, "01-clean-continuation");
+    mkdirSync(intendedDir, { recursive: true });
+    writeFileSync(join(intendedDir, "01-ROADMAP.md"), "# roadmap\n");
+
+    // Leftover team-mode projection: 01-<6char>-.../ with NO ROADMAP, made
+    // NEWER so an mtime tiebreak would wrongly prefer it without the guard.
+    const staleDir = join(phasesDir, "01-re4q3k-old-team-projection");
+    mkdirSync(staleDir, { recursive: true });
+    const newer = new Date(Date.now() + 60_000);
+    const older = new Date(Date.now() - 60_000);
+    utimesSync(staleDir, newer, newer);
+    utimesSync(intendedDir, older, older);
+
+    _clearGsdRootCache();
+    clearPathCache();
+
+    const resolved = resolveExpectedArtifactPath("plan-milestone", "M001", root);
+    assert.equal(
+      resolved,
+      join(intendedDir, "01-ROADMAP.md"),
+      "bare id must resolve to the real title dir, not the newer team-suffix projection",
+    );
+    assert.notEqual(
+      resolved,
+      join(staleDir, "01-ROADMAP.md"),
+      "must NOT resolve into the team-suffix projection dir that has no ROADMAP",
+    );
+  } finally {
+    _clearGsdRootCache();
+    clearPathCache();
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("bare milestone id still falls back to a lone team-suffix projection (#1195)", () => {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-bare-teamsuffix-only-")));
+  try {
+    const phasesDir = join(root, ".gsd", "phases");
+    // The only on-disk dir for the bare id is a team-mode projection. With no
+    // non-suffixed candidate, the fallback pass must still resolve to it.
+    const onlyDir = join(phasesDir, "01-re4q3k-clean-continuation");
+    mkdirSync(onlyDir, { recursive: true });
+    writeFileSync(join(onlyDir, "01-ROADMAP.md"), "# roadmap\n");
+
+    _clearGsdRootCache();
+    clearPathCache();
+
+    const resolved = resolveExpectedArtifactPath("plan-milestone", "M001", root);
+    assert.equal(
+      resolved,
+      join(onlyDir, "01-ROADMAP.md"),
+      "with no non-suffixed dir, the team-suffix projection is the correct fallback",
+    );
+  } finally {
+    _clearGsdRootCache();
+    clearPathCache();
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+// ── #1208: flat-phase execute-task summaries resolve at the phase root ────────
+//
+// In flat-phase layout task summaries are written beside the plan files
+// (phases/<phase>/T##-SUMMARY.md), NOT under a tasks/ subdir. A tasks/ dir may
+// still exist to hold auxiliary task-scoped gate artifacts (e.g. T01-VERIFY.json).
+// Before the fix, the mere existence of that tasks/ dir redirected summary
+// verification into tasks/T##-SUMMARY.md — which never exists — trapping auto-mode
+// in a false verification retry that eventually paused after a successful task.
+
+test("flat-phase execute-task summary resolves at phase root when no tasks/ dir exists (#1208)", () => {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-flat-task-summary-")));
+  try {
+    const gsd = join(root, ".gsd");
+    const phaseDir = join(gsd, "phases", "49-end-to-end-mandates");
+    mkdirSync(phaseDir, { recursive: true });
+    writeFileSync(join(phaseDir, "49-03-PLAN.md"), "# plan\n- [x] T02\n");
+
+    _clearGsdRootCache();
+    clearPathCache();
+
+    assert.equal(
+      resolveExpectedArtifactPath("execute-task", "M049/S03/T02", root),
+      join(phaseDir, "T02-SUMMARY.md"),
+    );
+  } finally {
+    _clearGsdRootCache();
+    clearPathCache();
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("flat-phase execute-task summary resolves at phase root even when tasks/ dir holds gate artifacts (#1208)", () => {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-flat-task-tasksdir-")));
+  try {
+    const gsd = join(root, ".gsd");
+    const phaseDir = join(gsd, "phases", "49-end-to-end-mandates");
+    mkdirSync(phaseDir, { recursive: true });
+    writeFileSync(join(phaseDir, "49-03-PLAN.md"), "# plan\n- [x] T02\n");
+    // Auxiliary task-scoped gate artifact — creates the tasks/ dir but must not
+    // redirect the T02 summary into tasks/.
+    const tasksDir = join(phaseDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(join(tasksDir, "T01-VERIFY.json"), '{"ok":true}');
+
+    _clearGsdRootCache();
+    clearPathCache();
+
+    const resolved = resolveExpectedArtifactPath("execute-task", "M049/S03/T02", root);
+    assert.equal(
+      resolved,
+      join(phaseDir, "T02-SUMMARY.md"),
+      "flat-phase task summary must resolve at the phase root, not tasks/",
+    );
+    assert.notEqual(
+      resolved,
+      join(tasksDir, "T02-SUMMARY.md"),
+      "a tasks/ dir with gate artifacts must NOT redirect summary resolution into tasks/",
+    );
+  } finally {
+    _clearGsdRootCache();
+    clearPathCache();
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("legacy execute-task summary still resolves under slices/<SID>/tasks/ (#1208 regression guard)", () => {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-legacy-task-summary-")));
+  try {
+    const milestoneDir = join(root, ".gsd", "milestones", "M001");
+    const sliceDir = join(milestoneDir, "slices", "S01");
+    const tasksDir = join(sliceDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(join(milestoneDir, "M001-CONTEXT.md"), "# context\n");
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), "# plan\n");
+
+    _clearGsdRootCache();
+    clearPathCache();
+
+    assert.equal(
+      resolveExpectedArtifactPath("execute-task", "M001/S01/T02", root),
+      join(tasksDir, "T02-SUMMARY.md"),
+    );
+  } finally {
+    _clearGsdRootCache();
+    clearPathCache();
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 // ── resolveSliceResearchLocation / resolveExistingSliceResearchPath ───────────
 //
 // Added in the code-quality consolidation PR as the shared dual-path resolver