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

package/dist/resources/extensions/gsd/auto-model-selection.js

@@ -326,7 +326,7 @@ export function floorThinkingLevelForUnit(unitType, level) {
     return EXECUTE_TASK_MIN_THINKING_LEVEL;
 }
 export function resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode = true, basePath, availableModelIds, preferredModelId) {
-    const explicitConfig = resolveModelWithFallbacksForUnit(unitType, basePath, availableModelIds, preferredModelId);
+    const explicitConfig = resolveModelWithFallbacksForUnit(unitType, basePath, availableModelIds, preferredModelId, true);
     if (explicitConfig) {
         return {
             ...explicitConfig,
@@ -338,23 +338,45 @@ export function resolvePreferredModelConfig(unitType, autoModeStartModel, isAuto
     if (!isAutoMode)
         return undefined;
     const routingConfig = resolveDynamicRoutingConfig();
-    if (!routingConfig.enabled || !routingConfig.tier_models)
+    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).
-    if (!routingConfig.allow_flat_rate_providers &&
+    // 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 === false &&
         autoModeStartModel &&
         isFlatRateProvider(autoModeStartModel.provider, autoModeStartModel.flatRateCtx)) {
         return undefined;
     }
-    const ceilingModel = routingConfig.tier_models.heavy
-        ?? (autoModeStartModel ? `${autoModeStartModel.provider}/${autoModeStartModel.id}` : undefined);
-    if (!ceilingModel)
+    // 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",
     };
 }
@@ -510,15 +532,11 @@ autoModeStartThinkingLevel) {
                 ]));
             }
         }
-        // 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/dist/resources/extensions/gsd/auto-post-unit.js

@@ -1834,7 +1834,7 @@ export async function postUnitPreVerification(pctx, opts) {
                     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/dist/resources/extensions/gsd/auto-prompts.js

@@ -10,20 +10,21 @@
 import { loadFile, parseContinue, parseSummary, loadActiveOverrides, formatOverridesSection } from "./files.js";
 import { hasVerdict, extractVerdict } from "./verdict-parser.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
-import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, resolveTaskFiles, resolveTaskFile, relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath, resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile, } from "./paths.js";
+import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, resolveTaskFiles, resolveTaskFile, relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath, 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 { join, relative } from "node:path";
+import { join, relative, sep } from "node:path";
 import { existsSync } from "node:fs";
 import { computeBudgets, resolveExecutorContextWindow, truncateAtSectionBoundary } from "./context-budget.js";
-import { getPendingGatesForTurn } from "./gsd-db.js";
+import { getGateResults, getPendingGatesForTurn } from "./gsd-db.js";
 import { assertGateCoverage, getGatesForTurn, } from "./gate-registry.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
 import { readPhaseAnchor, formatAnchorForPrompt } from "./phase-anchor.js";
 import { composeContextModeInstructions, composeContractedUnitContext, composeInlinedContext, composeToolSurfaceInstructions, composeUnitContext, } from "./unit-context-composer.js";
 import { resolveManifest } from "./unit-context-manifest.js";
-import { resolveExpectedArtifactPath } from "./auto-artifact-paths.js";
+import { resolveSliceResearchLocation } from "./auto-artifact-paths.js";
 import { compileUnitContextContract } from "./tool-contract.js";
 import { readCompactionSnapshot } from "./compaction-snapshot.js";
 import { logWarning } from "./workflow-logger.js";
@@ -251,31 +252,15 @@ function renderExecuteTaskOnDemandContext(base, mid, sid, artifacts) {
     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 = 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,
     };
@@ -311,6 +296,37 @@ function formatExecutorConstraints(sessionContextWindow, modelRegistry, sessionP
         `- Keep individual tasks completable within a single context window — if a task needs more context than fits, split it`,
     ].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) {
+    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
@@ -2190,6 +2206,7 @@ async function renderSlicePrompt(options) {
         inlinedContext,
         dependencySummaries: depContent,
         sourceFilePaths: buildSourceFilePaths(base, mid, sid),
+        repoRegistry: buildRepoRegistryBlock(base),
         executorContextConstraints,
         commitInstruction,
         skillActivation: buildSkillActivationBlock({
@@ -2298,7 +2315,7 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
         : "- (no prior tasks)";
     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)",
@@ -2922,6 +2939,47 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
         inlined.push(outstandingBlock);
         trackPromptContext(contextTelemetry, "outstanding-items", "inline", outstandingBlock);
     }
+    const persistedGateFlags = [];
+    try {
+        const gateLabels = {
+            Q3: "Threat Surface",
+            Q4: "Requirement Impact",
+        };
+        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");
@@ -3392,7 +3450,7 @@ opts) {
         const depPaths = await getDependencyTaskSummaryPaths(mid, sid, tid, node?.dependsOn ?? [], base);
         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)",