gsd-pi 2.63.0 → 2.64.0-dev.1a85e85

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

@@ -13,13 +13,20 @@ import { runUnit } from "./run-unit.js";
 import { debugLog } from "../debug-logger.js";
 import { PROJECT_FILES } from "../detection.js";
 import { MergeConflictError } from "../git-service.js";
-import { join, basename } from "node:path";
-import { existsSync, cpSync } from "node:fs";
+import { join, basename, dirname, parse as parsePath } from "node:path";
+import { existsSync, cpSync, readdirSync } from "node:fs";
 import { logWarning, logError } from "../workflow-logger.js";
 import { gsdRoot } from "../paths.js";
 import { atomicWriteSync } from "../atomic-write.js";
 import { verifyExpectedArtifact, diagnoseExpectedArtifact, buildLoopRemediationSteps } from "../auto-recovery.js";
 import { writeUnitRuntimeRecord } from "../unit-runtime.js";
+import { withTimeout, FINALIZE_POST_TIMEOUT_MS } from "./finalize-timeout.js";
+import { getEligibleSlices } from "../slice-parallel-eligibility.js";
+import { startSliceParallel } from "../slice-parallel-orchestrator.js";
+import { isDbAvailable, getMilestoneSlices } from "../gsd-db.js";
+import { resetEvidence } from "../safety/evidence-collector.js";
+import { createCheckpoint, cleanupCheckpoint, rollbackToCheckpoint } from "../safety/git-checkpoint.js";
+import { resolveSafetyHarnessConfig } from "../safety/safety-harness.js";
 // ─── generateMilestoneReport ──────────────────────────────────────────────────
 /**
  * Resolve the base path for milestone reports.
@@ -142,6 +149,50 @@ export async function runPreDispatch(ic, loopState) {
         mid,
         statePhase: state.phase,
     });
+    // ── Slice-level parallelism gate (#2340) ─────────────────────────────
+    // When slice_parallel is enabled, check if multiple slices are eligible
+    // for parallel execution. If so, dispatch them in parallel and stop the
+    // sequential loop. Workers are spawned via slice-parallel-orchestrator.ts.
+    if (prefs?.slice_parallel?.enabled &&
+        mid &&
+        !process.env.GSD_PARALLEL_WORKER &&
+        isDbAvailable()) {
+        try {
+            const dbSlices = getMilestoneSlices(mid);
+            if (dbSlices.length > 0) {
+                const doneIds = new Set(dbSlices.filter(sl => sl.status === "complete" || sl.status === "done").map(sl => sl.id));
+                const sliceInputs = dbSlices.map(sl => ({
+                    id: sl.id,
+                    done: doneIds.has(sl.id),
+                    depends: sl.depends ?? [],
+                }));
+                const eligible = getEligibleSlices(sliceInputs, doneIds);
+                if (eligible.length > 1) {
+                    debugLog("autoLoop", {
+                        phase: "slice-parallel-dispatch",
+                        iteration: ic.iteration,
+                        mid,
+                        eligibleSlices: eligible.map(e => e.id),
+                    });
+                    ctx.ui.notify(`Slice-parallel: dispatching ${eligible.length} eligible slices for ${mid}.`, "info");
+                    const result = await startSliceParallel(s.basePath, mid, eligible, { maxWorkers: prefs.slice_parallel.max_workers ?? 2 });
+                    if (result.started.length > 0) {
+                        ctx.ui.notify(`Slice-parallel: started ${result.started.length} worker(s): ${result.started.join(", ")}.`, "info");
+                        await deps.stopAuto(ctx, pi, `Slice-parallel dispatched for ${mid}`);
+                        return { action: "break", reason: "slice-parallel-dispatched" };
+                    }
+                    // Fall through to sequential if no workers started
+                }
+            }
+        }
+        catch (err) {
+            debugLog("autoLoop", {
+                phase: "slice-parallel-check-error",
+                error: err instanceof Error ? err.message : String(err),
+            });
+            // Non-fatal — fall through to sequential dispatch
+        }
+    }
     // ── Milestone transition ────────────────────────────────────────────
     if (mid && s.currentMilestoneId && mid !== s.currentMilestoneId) {
         deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "milestone-transition", data: { from: s.currentMilestoneId, to: mid } });
@@ -669,11 +720,40 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         }
         const hasProjectFile = PROJECT_FILES.some((f) => deps.existsSync(join(s.basePath, f)));
         const hasSrcDir = deps.existsSync(join(s.basePath, "src"));
-        if (!hasProjectFile && !hasSrcDir) {
+        // Xcode bundles have project-specific names (*.xcodeproj, *.xcworkspace)
+        // that cannot be matched by exact filename — scan the directory by suffix.
+        let hasXcodeBundle = false;
+        try {
+            const entries = deps.existsSync(s.basePath) ? readdirSync(s.basePath) : [];
+            hasXcodeBundle = entries.some((e) => e.endsWith(".xcodeproj") || e.endsWith(".xcworkspace"));
+        }
+        catch (err) {
+            debugLog("runUnitPhase", { phase: "xcode-bundle-scan-failed", basePath: s.basePath, error: String(err) });
+        }
+        // Monorepo support (#2347): if no project files in the worktree directory,
+        // walk parent directories up to the filesystem root. In monorepos,
+        // package.json / Cargo.toml etc. live in a parent directory.
+        let hasProjectFileInParent = false;
+        if (!hasProjectFile && !hasSrcDir && !hasXcodeBundle) {
+            let checkDir = dirname(s.basePath);
+            const { root } = parsePath(checkDir);
+            while (checkDir !== root) {
+                // Stop at git repository boundary — ancestors above the repo root
+                // (e.g. ~ or /usr/local) may contain unrelated project files.
+                if (deps.existsSync(join(checkDir, ".git")))
+                    break;
+                if (PROJECT_FILES.some((f) => deps.existsSync(join(checkDir, f)))) {
+                    hasProjectFileInParent = true;
+                    break;
+                }
+                checkDir = dirname(checkDir);
+            }
+        }
+        if (!hasProjectFile && !hasSrcDir && !hasXcodeBundle && !hasProjectFileInParent) {
             // Greenfield projects won't have project files yet — the first task creates them.
             // Log a warning but allow execution to proceed. The .git check above is sufficient
             // to ensure we're in a valid working directory.
-            debugLog("runUnitPhase", { phase: "worktree-health-warn-greenfield", basePath: s.basePath, hasProjectFile, hasSrcDir });
+            debugLog("runUnitPhase", { phase: "worktree-health-warn-greenfield", basePath: s.basePath, hasProjectFile, hasSrcDir, hasXcodeBundle });
             ctx.ui.notify(`Warning: ${s.basePath} has no recognized project files — proceeding as greenfield project`, "warning");
         }
     }
@@ -683,6 +763,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         s.currentUnit.id === unitId);
     const previousTier = s.currentUnitRouting?.tier;
     s.currentUnit = { type: unitType, id: unitId, startedAt: Date.now() };
+    s.lastToolInvocationError = null; // #2883: clear stale error from previous unit
     const unitStartSeq = ic.nextSeq();
     deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: unitStartSeq, eventType: "unit-start", data: { unitType, unitId } });
     deps.captureAvailableSkills();
@@ -695,18 +776,22 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         lastProgressKind: "dispatch",
         recoveryAttempts: 0, // Reset so re-dispatched units get full recovery budget (#2322)
     });
-    // Select and apply model (with tier escalation on retry — normal units only)
-    const modelResult = await deps.selectAndApplyModel(ctx, pi, unitType, unitId, s.basePath, prefs, s.verbose, s.autoModeStartModel, sidecarItem ? undefined : { isRetry, previousTier });
-    s.currentUnitRouting =
-        modelResult.routing;
-    s.currentUnitModel =
-        modelResult.appliedModel;
-    // Status bar + progress widget
+    // Status bar (widget + preconditions deferred until after model selection — see #2899)
     ctx.ui.setStatus("gsd-auto", "auto");
     if (mid)
         deps.updateSliceProgressCache(s.basePath, mid, state.activeSlice?.id);
-    deps.updateProgressWidget(ctx, unitType, unitId, state);
-    deps.ensurePreconditions(unitType, unitId, s.basePath, state);
+    // ── Safety harness: reset evidence + create checkpoint ──
+    const safetyConfig = resolveSafetyHarnessConfig(prefs?.safety_harness);
+    if (safetyConfig.enabled && safetyConfig.evidence_collection) {
+        resetEvidence();
+    }
+    // Only checkpoint code-executing units (not lifecycle/planning units)
+    if (safetyConfig.enabled && safetyConfig.checkpoints && unitType === "execute-task") {
+        s.checkpointSha = createCheckpoint(s.basePath, unitId);
+        if (s.checkpointSha) {
+            debugLog("runUnitPhase", { phase: "checkpoint-created", unitId, sha: s.checkpointSha.slice(0, 8) });
+        }
+    }
     // Prompt injection
     let finalPrompt = prompt;
     if (s.pendingVerificationRetry) {
@@ -764,6 +849,12 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         const msg = reorderErr instanceof Error ? reorderErr.message : String(reorderErr);
         logWarning("engine", "Prompt reorder failed", { error: msg });
     }
+    // Select and apply model (with tier escalation on retry — normal units only)
+    const modelResult = await deps.selectAndApplyModel(ctx, pi, unitType, unitId, s.basePath, prefs, s.verbose, s.autoModeStartModel, sidecarItem ? undefined : { isRetry, previousTier });
+    s.currentUnitRouting =
+        modelResult.routing;
+    s.currentUnitModel =
+        modelResult.appliedModel;
     // Apply sidecar/pre-dispatch hook model override (takes priority over standard model selection)
     const hookModelOverride = sidecarItem?.model ?? iterData.hookModelOverride;
     if (hookModelOverride) {
@@ -784,6 +875,15 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
                 `Ensure the model is defined in models.json and has auth configured.`, "warning");
         }
     }
+    // Store the final dispatched model ID so the dashboard can read it (#2899).
+    // This accounts for hook model overrides applied after selectAndApplyModel.
+    s.currentDispatchedModelId = s.currentUnitModel
+        ? `${s.currentUnitModel.provider ?? ""}/${s.currentUnitModel.id ?? ""}`
+        : null;
+    // Progress widget + preconditions — deferred to after model selection so the
+    // widget's first render tick shows the correct model (#2899).
+    deps.updateProgressWidget(ctx, unitType, unitId, state);
+    deps.ensurePreconditions(unitType, unitId, s.basePath, state);
     // Start unit supervision
     deps.clearUnitTimeout();
     deps.startUnitSupervision({
@@ -860,11 +960,13 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     if (s.currentUnit) {
         await deps.closeoutUnit(ctx, s.basePath, unitType, unitId, s.currentUnit.startedAt, deps.buildSnapshotOpts(unitType, unitId));
     }
-    // ── Zero tool-call guard (#1833) ──────────────────────────────────
-    // An execute-task agent that completes with 0 tool calls made no
-    // real changes — its summary is hallucinated. Treat as failed so
-    // the task is retried instead of silently marked complete.
-    if (unitType === "execute-task") {
+    // ── Zero tool-call guard (#1833, #2653) ──────────────────────────
+    // Any unit that completes with 0 tool calls made no real progress —
+    // likely context exhaustion where all tool calls errored out. Treat
+    // as failed so the unit is retried in a fresh context instead of
+    // silently passing through to artifact verification (which loops
+    // forever when the unit never produced its artifact).
+    {
         const currentLedger = deps.getLedger();
         if (currentLedger?.units) {
             const lastUnit = [...currentLedger.units].reverse().find((u) => u.type === unitType && u.id === unitId && u.startedAt === s.currentUnit?.startedAt);
@@ -873,11 +975,11 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
                     phase: "zero-tool-calls",
                     unitType,
                     unitId,
-                    warning: "Task completed with 0 tool calls — likely hallucinated, marking as failed",
+                    warning: "Unit completed with 0 tool calls — likely context exhaustion, marking as failed",
                 });
-                ctx.ui.notify(`${unitType} ${unitId} completed with 0 tool calls — hallucinated summary, will retry`, "warning");
+                ctx.ui.notify(`${unitType} ${unitId} completed with 0 tool calls — context exhaustion, will retry`, "warning");
                 // Fall through to next iteration where dispatch will re-derive
-                // and re-dispatch this task.
+                // and re-dispatch this unit.
                 return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt } };
             }
         }
@@ -912,6 +1014,25 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         }
     }
     deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "unit-end", data: { unitType, unitId, status: unitResult.status, artifactVerified, ...(unitResult.errorContext ? { errorContext: unitResult.errorContext } : {}) }, causedBy: { flowId: ic.flowId, seq: unitStartSeq } });
+    // ── Safety harness: checkpoint cleanup or rollback ──
+    if (s.checkpointSha) {
+        if (unitResult.status === "error" && safetyConfig.auto_rollback) {
+            const rolled = rollbackToCheckpoint(s.basePath, unitId, s.checkpointSha);
+            if (rolled) {
+                ctx.ui.notify(`Rolled back to pre-unit checkpoint for ${unitId}`, "info");
+                debugLog("runUnitPhase", { phase: "checkpoint-rollback", unitId });
+            }
+        }
+        else if (unitResult.status === "error") {
+            ctx.ui.notify(`Unit ${unitId} failed. Pre-unit checkpoint available at ${s.checkpointSha.slice(0, 8)}`, "warning");
+        }
+        else {
+            // Success — clean up checkpoint ref
+            cleanupCheckpoint(s.basePath, unitId);
+            debugLog("runUnitPhase", { phase: "checkpoint-cleaned", unitId });
+        }
+        s.checkpointSha = null;
+    }
     return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt } };
 }
 // ─── runFinalize ──────────────────────────────────────────────────────────────
@@ -993,7 +1114,21 @@ export async function runFinalize(ic, iterData, sidecarItem) {
         }
     }
     // Post-verification processing (DB dual-write, hooks, triage, quick-tasks)
-    const postResult = await deps.postUnitPostVerification(postUnitCtx);
+    // Timeout guard: if postUnitPostVerification hangs (e.g., module import
+    // deadlock, SQLite transaction hang), force-continue after timeout so the
+    // auto-loop is not permanently frozen (#2344).
+    const postResultGuard = await withTimeout(deps.postUnitPostVerification(postUnitCtx), FINALIZE_POST_TIMEOUT_MS, "postUnitPostVerification");
+    if (postResultGuard.timedOut) {
+        debugLog("autoLoop", {
+            phase: "post-verification-timeout",
+            iteration: ic.iteration,
+            unitType: iterData.unitType,
+            unitId: iterData.unitId,
+        });
+        ctx.ui.notify(`postUnitPostVerification timed out after ${FINALIZE_POST_TIMEOUT_MS / 1000}s for ${iterData.unitType} ${iterData.unitId} — continuing to next iteration`, "warning");
+        return { action: "next", data: undefined };
+    }
+    const postResult = postResultGuard.value;
     if (postResult === "stopped") {
         debugLog("autoLoop", {
             phase: "exit",

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

@@ -50,6 +50,8 @@ export class AutoSession {
     // ── Model state ──────────────────────────────────────────────────────────
     autoModeStartModel = null;
     currentUnitModel = null;
+    /** Fully-qualified model ID (provider/id) set after selectAndApplyModel + hook overrides (#2899). */
+    currentDispatchedModelId = null;
     originalModelId = null;
     originalModelProvider = null;
     lastBudgetAlertLevel = 0;
@@ -62,6 +64,10 @@ export class AutoSession {
     lastStateRebuildAt = 0;
     // ── Sidecar queue ─────────────────────────────────────────────────────
     sidecarQueue = [];
+    // ── Tool invocation errors (#2883) ──────────────────────────────────
+    /** Set when a GSD tool execution ends with isError due to malformed/truncated
+     *  JSON arguments. Checked by postUnitPreVerification to break retry loops. */
+    lastToolInvocationError = null;
     // ── Isolation degradation ────────────────────────────────────────────
     /** Set to true when worktree creation fails; prevents merge of nonexistent branch. */
     isolationDegraded = false;
@@ -76,6 +82,9 @@ export class AutoSession {
     lastPromptCharCount;
     lastBaselineCharCount;
     pendingQuickTasks = [];
+    // ── Safety harness ───────────────────────────────────────────────────────
+    /** SHA of the pre-unit git checkpoint ref. Cleared on success or rollback. */
+    checkpointSha = null;
     // ── Signal handler ───────────────────────────────────────────────────────
     sigtermHandler = null;
     // ── Loop promise state ──────────────────────────────────────────────────
@@ -132,6 +141,7 @@ export class AutoSession {
         // Model
         this.autoModeStartModel = null;
         this.currentUnitModel = null;
+        this.currentDispatchedModelId = null;
         this.originalModelId = null;
         this.originalModelProvider = null;
         this.lastBudgetAlertLevel = 0;
@@ -149,8 +159,10 @@ export class AutoSession {
         this.pendingQuickTasks = [];
         this.sidecarQueue = [];
         this.rewriteAttemptCount = 0;
+        this.lastToolInvocationError = null;
         this.isolationDegraded = false;
         this.milestoneMergedInPhases = false;
+        this.checkpointSha = null;
         // Signal handler
         this.sigtermHandler = null;
         // Loop promise state lives in auto-loop.ts module scope

package/dist/resources/extensions/gsd/auto-dashboard.js

@@ -472,11 +472,11 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                     : "";
                 lines.push(rightAlign(headerLeft, headerRight, width));
                 // Worktree/branch right-aligned below header
-                if (worktreeName && cachedBranch) {
-                    lines.push(rightAlign("", theme.fg("dim", `${worktreeName} (${cachedBranch})`), width));
-                }
-                else if (cachedBranch) {
-                    lines.push(rightAlign("", theme.fg("dim", cachedBranch), width));
+                const branchLabel = worktreeName && cachedBranch
+                    ? `${worktreeName} (${cachedBranch})`
+                    : cachedBranch ?? "";
+                if (branchLabel) {
+                    lines.push(rightAlign("", theme.fg("dim", branchLabel), width));
                 }
                 // Show health signal details when degraded (yellow/red)
                 if (score.level !== "green" && score.signals.length > 0 && widgetMode !== "min") {
@@ -516,9 +516,15 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                 const cxWindow = cxUsage?.contextWindow ?? cmdCtx?.model?.contextWindow ?? 0;
                 const cxPctVal = cxUsage?.percent ?? 0;
                 const cxPct = cxUsage?.percent !== null ? cxPctVal.toFixed(1) : "?";
-                // Model display — shown in context section, not stats
-                const modelId = cmdCtx?.model?.id ?? "";
-                const modelProvider = cmdCtx?.model?.provider ?? "";
+                // Model display — prefer dispatched model ID (set after selectAndApplyModel
+                // + hook overrides) over cmdCtx?.model which can be stale (#2899).
+                const dispatchedModelId = accessors.getCurrentDispatchedModelId();
+                const modelId = dispatchedModelId
+                    ? dispatchedModelId.split("/").slice(1).join("/") || dispatchedModelId
+                    : (cmdCtx?.model?.id ?? "");
+                const modelProvider = dispatchedModelId
+                    ? dispatchedModelId.split("/")[0] || ""
+                    : (cmdCtx?.model?.provider ?? "");
                 const tierIcon = resolveServiceTierIcon(effectiveServiceTier, modelId);
                 const modelDisplay = (modelProvider && modelId
                     ? `${modelProvider}/${modelId}`

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

@@ -15,6 +15,9 @@ export function resolvePreferredModelConfig(unitType, autoModeStartModel) {
     const routingConfig = resolveDynamicRoutingConfig();
     if (!routingConfig.enabled || !routingConfig.tier_models)
         return undefined;
+    // Don't synthesize a routing config for flat-rate providers (#3453).
+    if (autoModeStartModel && isFlatRateProvider(autoModeStartModel.provider))
+        return undefined;
     const ceilingModel = routingConfig.tier_models.heavy
         ?? (autoModeStartModel ? `${autoModeStartModel.provider}/${autoModeStartModel.id}` : undefined);
     if (!ceilingModel)
@@ -41,6 +44,25 @@ export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, p
         const routingConfig = resolveDynamicRoutingConfig();
         let effectiveModelConfig = modelConfig;
         let routingTierLabel = "";
+        // 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.
+        // Fail-closed: if primary model can't be resolved, fall back to
+        // provider-level signals rather than allowing unwanted downgrades.
+        if (routingConfig.enabled) {
+            const primaryModel = resolveModelId(modelConfig.primary, availableModels, ctx.model?.provider);
+            if (primaryModel) {
+                if (isFlatRateProvider(primaryModel.provider)) {
+                    routingConfig.enabled = false;
+                }
+            }
+            else if ((autoModeStartModel && isFlatRateProvider(autoModeStartModel.provider))
+                || (ctx.model?.provider && isFlatRateProvider(ctx.model.provider))) {
+                // Primary model unresolvable but provider signals indicate flat-rate —
+                // disable routing to prevent quality degradation.
+                routingConfig.enabled = false;
+            }
+        }
         if (routingConfig.enabled) {
             let budgetPct;
             if (routingConfig.budget_pressure !== false) {
@@ -244,3 +266,13 @@ export function resolveModelId(modelId, availableModels, currentProvider) {
     // Fall back to first non-extension candidate, or any candidate
     return candidates.find(m => !EXTENSION_PROVIDERS.has(m.provider)) ?? candidates[0];
 }
+/**
+ * Flat-rate providers charge the same per request regardless of model.
+ * Dynamic routing provides no cost benefit — it only degrades quality (#3453).
+ * Uses case-insensitive matching with alias support to prevent fail-open on
+ * provider naming variations (e.g. "copilot" vs "github-copilot").
+ */
+const FLAT_RATE_PROVIDERS = new Set(["github-copilot", "copilot"]);
+export function isFlatRateProvider(provider) {
+    return FLAT_RATE_PROVIDERS.has(provider.toLowerCase());
+}