@opengsd/gsd-pi 1.3.0-dev.eed73bea → 1.4.0-dev.5fc22c6f

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

@@ -114,7 +114,7 @@ import { detectWorktreeName } from "./worktree.js";
 import { probeGitConflictState } from "./git-conflict-state.js";
 import { runTurnGitAction } from "./git-service.js";
 import { parseUnitId } from "./unit-id.js";
-import { resolveExpectedArtifactPath } from "./auto-artifact-paths.js";
+import { resolveExpectedArtifactPath, resolveExistingSliceResearchPath } from "./auto-artifact-paths.js";
 import {
   formatCloseoutProofBlock,
   proveMilestoneCloseout,
@@ -838,7 +838,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
     },
   },
   {
-    name: "uat-verdict-gate (non-PASS blocks progression)",
+    name: "uat-verdict-gate (non-PASS observed; closeout enforces)",
     match: async ({ mid, basePath, prefs }) => {
       // Only applies when UAT dispatch is enabled
       if (!prefs?.uat_dispatch) return null;
@@ -852,9 +852,9 @@ export const DISPATCH_RULES: DispatchRule[] = [
         const { verdict, uatType } = result;
 
         if (!isAcceptableUatVerdict(verdict, uatType)) {
-          // Do not hard-stop auto-mode on non-PASS verdicts. Allow progression
-          // so follow-up slices can remediate, while complete-milestone still
-          // enforces manual UAT PASS sign-off before closure.
+          // Observe non-PASS verdicts without hard-stopping auto-mode. Allow
+          // progression so follow-up slices can remediate, while
+          // complete-milestone still enforces manual UAT PASS sign-off before closure.
           continue;
         }
       }
@@ -1130,9 +1130,21 @@ export const DISPATCH_RULES: DispatchRule[] = [
       // call site.
       const sliceContextFile = resolveSliceFile(basePath, mid, state.activeSlice.id, "CONTEXT");
       if (sliceContextFile && existsSync(sliceContextFile)) return null; // discussion already done, proceed
+
+      const closedSliceIds = getClosedSliceIds(mid);
+      const justClosedSliceId = closedSliceIds[closedSliceIds.length - 1];
+      let priorVerdictWarning = "";
+      if (justClosedSliceId) {
+        const prior = await readUatGateVerdict(basePath, mid, justClosedSliceId);
+        if (prior && !isAcceptableUatVerdict(prior.verdict, prior.uatType)) {
+          priorVerdictWarning =
+            ` Note: the slice just closed (${justClosedSliceId}) recorded a non-PASS UAT verdict (${prior.verdict.toUpperCase()}); review before continuing.`;
+        }
+      }
+
       return {
         action: "stop" as const,
-        reason: `Slice ${state.activeSlice.id} requires discussion before planning (require_slice_discussion is enabled). Run /gsd discuss to discuss this slice, then /gsd auto to resume.`,
+        reason: `Slice ${state.activeSlice.id} requires discussion before planning (require_slice_discussion is enabled). Run /gsd discuss to discuss this slice, then /gsd auto to resume.${priorVerdictWarning}`,
         level: "warning" as const,
       };
     },
@@ -1164,7 +1176,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
       for (const slice of dbSlices) {
         if (slice.done) continue;
         // Skip if already has research
-        if (resolveExistingExpectedArtifact("research-slice", `${mid}/${slice.id}`, basePath)) continue;
+        if (resolveExistingSliceResearchPath(basePath, mid, slice.id)) continue;
         // Skip if dependencies aren't done (check for SUMMARY files)
         const depsComplete = slice.depends.every((depId) =>
           !!resolveExistingExpectedArtifact("complete-slice", `${mid}/${depId}`, basePath),
@@ -1212,10 +1224,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
       if (!state.activeSlice) return missingSliceStop(mid, state.phase);
       const sid = state.activeSlice!.id;
       const sTitle = state.activeSlice!.title;
-      const researchFile =
-        resolveExistingExpectedArtifact("research-slice", `${mid}/${sid}`, basePath) ??
-        resolveSliceFile(basePath, mid, sid, "RESEARCH");
-      if (researchFile) return null; // has research, fall through
+      if (resolveExistingSliceResearchPath(basePath, mid, sid)) return null; // has research, fall through
       return {
         action: "dispatch",
         unitType: "research-slice",
@@ -1526,6 +1535,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
       const sid = state.activeSlice!.id;
       const sTitle = state.activeSlice!.title;
       const tid = state.activeTask.id;
+      const unitId = `${mid}/${sid}`;
       const artifactBasePath = resolveArtifactBasePath(basePath, mid, session);
 
       // Guard: if the slice plan exists but the individual task plan files are
@@ -1565,6 +1575,17 @@ export const DISPATCH_RULES: DispatchRule[] = [
         !existsSync(projectionTaskPlanPath) &&
         !tasksEmbeddedInSlicePlan
       ) {
+        const MAX_MISSING_TASK_PLAN_RETRIES = 2;
+        const retryCount = session?.missingTaskPlanRetryCount?.get(unitId) ?? 0;
+        if (retryCount >= MAX_MISSING_TASK_PLAN_RETRIES) {
+          session?.missingTaskPlanRetryCount?.delete(unitId);
+          return {
+            action: "stop",
+            reason: `Missing task-plan recovery failed ${retryCount} times for ${unitId} - manual intervention required. Task plan ${tid} is still missing after regenerating the slice plan. Fix the task-plan files manually, then run /gsd auto to resume.`,
+            level: "error",
+          };
+        }
+        session?.missingTaskPlanRetryCount?.set(unitId, retryCount + 1);
         if (isDebugEnabled()) {
           const expectedTaskPlanPath = join(artifactBasePath, relTaskFile(artifactBasePath, mid, sid, tid, "PLAN"));
           const originalProjectRoot = session?.originalBasePath || basePath;
@@ -1588,7 +1609,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
         return {
           action: "dispatch",
           unitType: "plan-slice",
-          unitId: `${mid}/${sid}`,
+          unitId,
           prompt: await buildPlanSlicePrompt(
             mid,
             midTitle,
@@ -1601,6 +1622,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
         };
       }
 
+      session?.missingTaskPlanRetryCount?.delete(unitId);
       return null;
     },
   },

package/src/resources/extensions/gsd/auto-model-selection.ts

@@ -409,7 +409,13 @@ export function resolvePreferredModelConfig(
   availableModelIds?: string[],
   preferredModelId?: string,
 ): PreferredModelConfig | undefined {
-  const explicitConfig = resolveModelWithFallbacksForUnit(unitType, basePath, availableModelIds, preferredModelId);
+  const explicitConfig = resolveModelWithFallbacksForUnit(
+    unitType,
+    basePath,
+    availableModelIds,
+    preferredModelId,
+    true,
+  );
   if (explicitConfig) {
     return {
       ...explicitConfig,
@@ -422,26 +428,55 @@ export function resolvePreferredModelConfig(
   if (!isAutoMode) return undefined;
 
   const routingConfig = resolveDynamicRoutingConfig();
-  if (!routingConfig.enabled || !routingConfig.tier_models) return undefined;
+  if (!routingConfig.enabled) return undefined;
 
-  // Don't synthesize a routing config for flat-rate providers (#3453).
-  // Users can opt into routing for flat-rate subscriptions (e.g. claude-code)
-  // via dynamic_routing.allow_flat_rate_providers (#4386).
+  // Only an explicit flat-rate opt-out suppresses synthesized routing.
+  // `dynamic_routing.enabled: true` is user intent to run routing even when
+  // the start provider is a flat-rate subscription. Applied ahead of both the
+  // tier-pin and profile-derived synthesis paths so the opt-out is uniform.
   if (
-    !routingConfig.allow_flat_rate_providers &&
+    routingConfig.allow_flat_rate_providers === false &&
     autoModeStartModel &&
     isFlatRateProvider(autoModeStartModel.provider, autoModeStartModel.flatRateCtx)
   ) {
     return undefined;
   }
 
-  const ceilingModel = routingConfig.tier_models.heavy
-    ?? (autoModeStartModel ? `${autoModeStartModel.provider}/${autoModeStartModel.id}` : undefined);
-  if (!ceilingModel) return undefined;
+  // With explicit `tier_models` pins, synthesize a heavy-tier ceiling that
+  // dynamic routing downgrades from per unit.
+  if (routingConfig.tier_models) {
+    const ceilingModel = routingConfig.tier_models.heavy
+      ?? (autoModeStartModel ? `${autoModeStartModel.provider}/${autoModeStartModel.id}` : undefined);
+    if (!ceilingModel) return undefined;
+
+    return {
+      primary: ceilingModel,
+      fallbacks: [],
+      source: "synthesized",
+    };
+  }
+
+  // No `tier_models` pins: fall back to the token-profile's per-phase model so
+  // profile tier resolution survives. `skipProfileDefaults` is left false here
+  // (unlike the explicit-detection call above) precisely because we WANT the
+  // profile defaults this time — they are the routing ceiling, not a hard
+  // user selection. Labeling the result `synthesized` (not `explicit`) keeps
+  // dynamic routing and fallbacks enabled downstream. Without this branch,
+  // `resolvePreferredModelConfig` returns undefined for profile-only configs
+  // and auto dispatch bleeds the start model onto every unit, silently
+  // discarding the profile (#1115: routing/fallbacks disabled when a
+  // token_profile is set but no tier_models are pinned).
+  const profileConfig = resolveModelWithFallbacksForUnit(
+    unitType,
+    basePath,
+    availableModelIds,
+    preferredModelId,
+    false,
+  );
+  if (!profileConfig) return undefined;
 
   return {
-    primary: ceilingModel,
-    fallbacks: [],
+    ...profileConfig,
     source: "synthesized",
   };
 }
@@ -647,15 +682,11 @@ export async function selectAndApplyModel(
       }
     }
 
-    // Disable routing for flat-rate providers like GitHub Copilot (#3453).
-    // All models cost the same per request, so downgrading to a cheaper
-    // model provides no cost benefit — it only degrades quality.
+    // Disable routing for flat-rate providers only when the user explicitly
+    // opts out with dynamic_routing.allow_flat_rate_providers: false.
     // Fail-closed: if primary model can't be resolved, fall back to
     // provider-level signals rather than allowing unwanted downgrades.
-    // Opt-in: dynamic_routing.allow_flat_rate_providers skips the bypass so
-    // claude-code subscribers can still get intelligent per-task selection
-    // across their subscription (#4386).
-    if (routingConfig.enabled && !routingConfig.allow_flat_rate_providers) {
+    if (routingConfig.enabled && routingConfig.allow_flat_rate_providers === false) {
       const primaryModel = resolveModelId(modelConfig.primary, routingEligibleModels, ctx.model?.provider);
       if (primaryModel) {
         const primaryFlatRateCtx = buildFlatRateContext(primaryModel.provider, ctx, prefs);

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

@@ -2212,7 +2212,7 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
           saveCustomVerifyRetryCounts(s, { logFailure: err => debugLog("postUnit", { phase: "save-verify-retries-failed", error: err instanceof Error ? err.message : String(err) }) });
           s.pendingVerificationRetry = {
             unitId: s.currentUnit.id,
-            failureContext: `${failureDetails} (attempt ${attempt}/${MAX_ARTIFACT_VERIFICATION_RETRIES}).`,
+            failureContext: failureDetails,
             attempt,
           };
           debugLog("postUnit", { phase: "artifact-verify-retry", unitType: s.currentUnit.type, unitId: s.currentUnit.id, attempt });

package/src/resources/extensions/gsd/auto-prompts.ts

@@ -17,17 +17,18 @@ import {
   resolveMilestoneFile, resolveSliceFile, resolveSlicePath,
   resolveTasksDir, resolveTaskFiles, resolveTaskFile,
   relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath,
-  resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile,
+  relTaskFile, resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile,
 } from "./paths.js";
 import { resolveInlineLevel, loadEffectiveGSDPreferences } from "./preferences.js";
+import { createRepositoryRegistryFromPreferences } from "./repository-registry.js";
 import { isContextModeEnabled } from "./preferences-types.js";
 import { parseRoadmap } from "./parsers-legacy.js";
 import type { GSDState, InlineLevel } from "./types.js";
 import type { GSDPreferences } from "./preferences.js";
-import { join, basename, relative } from "node:path";
+import { join, basename, relative, sep } from "node:path";
 import { existsSync } from "node:fs";
 import { computeBudgets, resolveExecutorContextWindow, truncateAtSectionBoundary, type MinimalModelRegistry } from "./context-budget.js";
-import { getPendingGates, getPendingGatesForTurn } from "./gsd-db.js";
+import { getGateResults, getPendingGates, getPendingGatesForTurn } from "./gsd-db.js";
 import {
   GATE_REGISTRY,
   assertGateCoverage,
@@ -48,7 +49,7 @@ import {
   type ExcerptResolver,
 } from "./unit-context-composer.js";
 import { resolveManifest, type ArtifactKey } from "./unit-context-manifest.js";
-import { resolveExpectedArtifactPath } from "./auto-artifact-paths.js";
+import { resolveSliceResearchLocation } from "./auto-artifact-paths.js";
 import { compileUnitContextContract, type UnitPromptContextContract } from "./tool-contract.js";
 import { readCompactionSnapshot } from "./compaction-snapshot.js";
 import { logWarning } from "./workflow-logger.js";
@@ -343,31 +344,15 @@ function renderExecuteTaskOnDemandContext(
   if (!artifacts.includes("slice-research")) {
     return { text: "", skipReason: "not declared by contract" };
   }
-  // Mirror dispatch's dual-resolution logic: worktree projection path first,
-  // then the authoritative project-root path via resolveExpectedArtifactPath.
-  // In worktree layouts the RESEARCH file may live under the project-root .gsd
-  // and not have been copied into the worktree projection, so resolveSliceFile
-  // (which looks only at gsdProjectionRoot) would miss it while dispatch would
-  // still treat research as satisfied.
-  const projectedFile = resolveSliceFile(base, mid, sid, "RESEARCH");
-  const researchFile: string | null = projectedFile ?? (() => {
-    const p = resolveExpectedArtifactPath("research-slice", `${mid}/${sid}`, base);
-    return p && existsSync(p) ? p : null;
-  })();
-  if (!researchFile) {
+  const research = resolveSliceResearchLocation(base, mid, sid);
+  if (!research.absolutePath || !research.relativePath) {
     return { text: "", skipReason: "missing" };
   }
-  // Use the layout-aware relative path when the file is in the worktree
-  // projection (relSliceFile), or fall back to node:path relative() when the
-  // file was only found via the project-root resolution path.
-  const researchPath = projectedFile
-    ? relSliceFile(base, mid, sid, "RESEARCH")
-    : relative(base, researchFile);
   return {
     text: [
       "## On-demand Context",
       "",
-      `Slice research is available at \`${researchPath}\`. Read it only if the inlined task plan, slice plan excerpt, and carry-forward context do not explain a required implementation detail.`,
+      `Slice research is available at \`${research.relativePath}\`. Read it only if the inlined task plan, slice plan excerpt, and carry-forward context do not explain a required implementation detail.`,
     ].join("\n"),
     skipReason: null,
   };
@@ -409,6 +394,37 @@ function formatExecutorConstraints(
   ].join("\n");
 }
 
+/**
+ * Builds the Declared Repositories block for parent-workspace planners.
+ * Returns "" for single-repo projects so the common-case prompt is unchanged;
+ * only parent mode with declared child repos gets the registry list and the
+ * targetRepositories assignment instruction.
+ */
+export function buildRepoRegistryBlock(base: string): string {
+  let registry;
+  try {
+    registry = createRepositoryRegistryFromPreferences(base, loadEffectiveGSDPreferences(base)?.preferences);
+  } catch {
+    return "";
+  }
+  const hasChildRepo = registry.repositories.some((repo) => repo.id !== "project");
+  if (registry.mode !== "parent" || !hasChildRepo) return "";
+
+  const lines = registry.repositories.map((repo) => {
+    const relPath = relative(registry.projectRoot, repo.root).split(sep).join("/") || ".";
+    const role = repo.role ? ` — ${repo.role}` : "";
+    const root = repo.id === "project" ? " (root)" : ` (${relPath})`;
+    return `- \`${repo.id}\`${root}${role}`;
+  });
+  return [
+    "### Declared Repositories",
+    "",
+    ...lines,
+    "",
+    "This is a parent workspace. Assign each task's `targetRepositories` to the repository id(s) it touches (from the list above). Omit `targetRepositories` to inherit the slice-wide default from `gsd_plan_slice`; set it explicitly when a task differs (e.g. `[\"project\"]` for parent-root work).",
+  ].join("\n");
+}
+
 /**
  * Returns a markdown bullet list of known context file paths for the given
  * milestone (and optionally slice). Falls back to a generic tool-agnostic
@@ -2520,6 +2536,7 @@ async function renderSlicePrompt(options: {
     inlinedContext,
     dependencySummaries: depContent,
     sourceFilePaths: buildSourceFilePaths(base, mid, sid),
+    repoRegistry: buildRepoRegistryBlock(base),
     executorContextConstraints,
     commitInstruction,
     skillActivation: buildSkillActivationBlock({
@@ -2678,7 +2695,7 @@ export async function buildExecuteTaskPrompt(
 
   const taskPlanPath = resolveTaskFile(base, mid, sid, tid, "PLAN");
   const taskPlanContent = taskPlanPath ? await loadFile(taskPlanPath) : null;
-  const taskPlanRelPath = relSlicePath(base, mid, sid) + `/tasks/${tid}-PLAN.md`;
+  const taskPlanRelPath = relTaskFile(base, mid, sid, tid, "PLAN");
   const taskPlanContext = taskPlanContent
     ? [
       "## Inlined Task Plan (authoritative local execution contract)",
@@ -3378,6 +3395,44 @@ export async function buildValidateMilestonePrompt(
     trackPromptContext(contextTelemetry, "outstanding-items", "inline", outstandingBlock);
   }
 
+  const persistedGateFlags: string[] = [];
+  try {
+    const gateLabels = {
+      Q3: "Threat Surface",
+      Q4: "Requirement Impact",
+    } as const;
+    for (const sid of seenValSlices) {
+      for (const gate of getGateResults(mid, sid, "slice")) {
+        if (gate.gate_id !== "Q3" && gate.gate_id !== "Q4") continue;
+        const findings = gate.findings.trim();
+        const rationale = gate.rationale.trim();
+        const verdict = gate.verdict ?? "";
+        const hasNonPassVerdict = verdict !== "" && verdict !== "pass" && verdict !== "omitted";
+        if (!findings && !hasNonPassVerdict) continue;
+
+        const displayVerdict = verdict || gate.status;
+        const detail = findings || rationale || "_No findings text recorded; reconcile the persisted non-pass verdict._";
+        persistedGateFlags.push(`- **${sid} / ${gate.gate_id} (${gateLabels[gate.gate_id]}) / ${displayVerdict}:** ${detail}`);
+        if (findings && rationale) persistedGateFlags.push(`  - Rationale: ${rationale}`);
+      }
+    }
+  } catch (err) {
+    logWarning("prompt", `buildValidateMilestonePrompt persisted gate flags lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (persistedGateFlags.length > 0) {
+    const persistedGateFlagsBlock = [
+      "### Persisted Slice-Level Gate Flags (from quality_gates)",
+      "",
+      "These slice gates recorded findings or non-pass verdicts during execution. Reconcile each against the milestone-level evidence before returning MV03/MV04 verdicts.",
+      "",
+      ...persistedGateFlags,
+    ].join("\n");
+    inlined.push(persistedGateFlagsBlock);
+    trackPromptContext(contextTelemetry, "persisted-slice-gate-flags", "inline", persistedGateFlagsBlock);
+  } else {
+    trackPromptContext(contextTelemetry, "persisted-slice-gate-flags", "skipped", null, "none");
+  }
+
   // Inline existing VALIDATION file if this is a re-validation round
   const validationPath = resolveMilestoneFile(base, mid, "VALIDATION");
   const validationRel = relMilestoneFile(base, mid, "VALIDATION");
@@ -3917,7 +3972,7 @@ export async function buildReactiveExecutePrompt(
 
     const taskPlanPath = resolveTaskFile(base, mid, sid, tid, "PLAN");
     const taskPlanContent = taskPlanPath ? await loadFile(taskPlanPath) : null;
-    const taskPlanRelPath = `${relSlicePath(base, mid, sid)}/tasks/${tid}-PLAN.md`;
+    const taskPlanRelPath = relTaskFile(base, mid, sid, tid, "PLAN");
     const taskPlanInline = taskPlanContent
       ? [
           "## Inlined Task Plan (authoritative local execution contract)",