gsd-pi 2.78.1-dev.82bcf6b71 → 2.78.1-dev.84c045fd2

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

@@ -81,13 +81,12 @@ import {
   readFileSync,
   readdirSync,
   rmSync,
-  statSync,
-  unlinkSync,
 } from "node:fs";
 import { join } from "node:path";
 import { sep as pathSep } from "node:path";
 
 import { resolveProjectRootDbPath } from "./bootstrap/dynamic-tools.js";
+import { validateDirectory } from "./validate-directory.js";
 import {
   isCustomProvider,
   resolveDefaultSessionModel,
@@ -350,6 +349,12 @@ export async function bootstrapAutoSession(
     buildResolver,
   } = deps;
 
+  const dirCheck = validateDirectory(base);
+  if (dirCheck.severity === "blocked") {
+    ctx.ui.notify(dirCheck.reason!, "error");
+    return false;
+  }
+
   const lockResult = acquireSessionLock(base);
   if (!lockResult.acquired) {
     ctx.ui.notify(lockResult.reason, "error");
@@ -428,6 +433,16 @@ export async function bootstrapAutoSession(
       return releaseLockAndReturn();
     }
 
+    const gitLockFile = join(base, ".git", "index.lock");
+    if (existsSync(gitLockFile)) {
+      ctx.ui.notify(
+        "Git index lock is present at .git/index.lock. Another git process may be running; resolve the lock before starting GSD.",
+        "error",
+      );
+      debugLog("git-index-lock-present-preflight", { path: gitLockFile });
+      return releaseLockAndReturn();
+    }
+
     // Ensure git repo exists *locally* at base.
     // nativeIsRepo() uses `git rev-parse` which traverses up to parent dirs,
     // so a parent repo can make it return true even when base has no .git of
@@ -648,7 +663,22 @@ export async function bootstrapAutoSession(
       hasSurvivorBranch = false;
     }
 
-    if (!hasSurvivorBranch) {
+    const deepProjectStagePending = !hasSurvivorBranch
+      ? (await import("./auto-dispatch.js")).hasPendingDeepStage(
+          loadEffectiveGSDPreferences(base)?.preferences,
+          base,
+        )
+      : false;
+
+    if (deepProjectStagePending) {
+      // Deep project-level setup runs before the first milestone exists. Let
+      // the auto loop dispatch workflow-preferences / project / requirements
+      // units instead of recursing back through showSmartEntry while this
+      // bootstrap still holds the session lock.
+      s.currentMilestoneId = null;
+    }
+
+    if (!hasSurvivorBranch && !deepProjectStagePending) {
       // No active work — start a new milestone via discuss flow
       if (!state.activeMilestone || state.phase === "complete") {
         // Guard against recursive dialog loop (#1348):
@@ -724,7 +754,7 @@ export async function bootstrapAutoSession(
     }
 
     // Unreachable safety check
-    if (!state.activeMilestone) {
+    if (!state.activeMilestone && !deepProjectStagePending) {
       const { showSmartEntry } = await import("./guided-flow.js");
       await showSmartEntry(ctx, pi, base, { step: requestedStepMode });
       return releaseLockAndReturn();
@@ -758,7 +788,7 @@ export async function bootstrapAutoSession(
     s.resourceVersionOnStart = readResourceVersion();
     s.pendingQuickTasks = [];
     s.currentUnit = null;
-    s.currentMilestoneId = state.activeMilestone?.id ?? null;
+    s.currentMilestoneId = deepProjectStagePending ? null : state.activeMilestone?.id ?? null;
     s.originalModelId = startModelSnapshot?.id ?? ctx.model?.id ?? null;
     s.originalModelProvider = startModelSnapshot?.provider ?? ctx.model?.provider ?? null;
     s.originalThinkingLevel = startThinkingSnapshot ?? null;
@@ -825,18 +855,11 @@ export async function bootstrapAutoSession(
     const gsdDbPath = resolveProjectRootDbPath(s.basePath);
     const gsdDirPath = join(s.basePath, ".gsd");
     if (existsSync(gsdDirPath) && !existsSync(gsdDbPath)) {
-      const hasDecisions = existsSync(join(gsdDirPath, "DECISIONS.md"));
-      const hasRequirements = existsSync(join(gsdDirPath, "REQUIREMENTS.md"));
-      const hasMilestones = existsSync(join(gsdDirPath, "milestones"));
       try {
         const { openDatabase: openDb } = await import("./gsd-db.js");
         openDb(gsdDbPath);
-        if (hasDecisions || hasRequirements || hasMilestones) {
-          const { migrateFromMarkdown } = await import("./md-importer.js");
-          migrateFromMarkdown(s.basePath);
-        }
       } catch (err) {
-        logError("engine", `auto-migration failed: ${(err as Error).message}`);
+        logError("engine", `failed to initialize project database: ${(err as Error).message}`);
       }
     }
     if (existsSync(gsdDbPath) && !isDbAvailable()) {
@@ -922,11 +945,22 @@ export async function bootstrapAutoSession(
       (m) => m.status !== "complete" && m.status !== "parked",
     ).length;
     const scopeMsg =
-      pendingCount > 1
+      deepProjectStagePending
+        ? "Will run project setup before milestone planning."
+        : pendingCount > 1
         ? `Will loop through ${pendingCount} milestones.`
         : "Will loop until milestone complete.";
     ctx.ui.notify(`${modeLabel} started. ${scopeMsg}`, "info");
 
+    const providerReportedWindow = ctx.model?.contextWindow ?? 0;
+    const contextOverride = loadEffectiveGSDPreferences(base)?.preferences.context_window_override;
+    if (providerReportedWindow > 500_000 && contextOverride === undefined) {
+      ctx.ui.notify(
+        `Model reports a ${Math.round(providerReportedWindow / 1000)}K context window. If the provider's real API limit is lower, set context_window_override in .gsd/PREFERENCES.md so wrap-up signals fire before context overflow.`,
+        "warning",
+      );
+    }
+
     // Show dynamic routing status so users know upfront if models will be
     // downgraded for simple tasks (#3962).
     // Use the same effective logic as selectAndApplyModel: check flat-rate
@@ -976,66 +1010,32 @@ export async function bootstrapAutoSession(
     writeLock(lockBase(), "starting", s.currentMilestoneId ?? "unknown");
 
     // Secrets collection gate
-    const mid = state.activeMilestone!.id;
-    try {
-      const manifestStatus = await getManifestStatus(base, mid, s.originalBasePath || base);
-      if (manifestStatus && manifestStatus.pending.length > 0) {
-        const result = await collectSecretsFromManifest(base, mid, ctx);
-        if (
-          result &&
-          result.applied &&
-          result.skipped &&
-          result.existingSkipped
-        ) {
-          ctx.ui.notify(
-            `Secrets collected: ${result.applied.length} applied, ${result.skipped.length} skipped, ${result.existingSkipped.length} already set.`,
-            "info",
-          );
-        } else {
-          ctx.ui.notify("Secrets collection skipped.", "info");
-        }
-      }
-    } catch (err) {
-      ctx.ui.notify(
-        `Secrets collection error: ${err instanceof Error ? err.message : String(err)}. Continuing with next task.`,
-        "warning",
-      );
-    }
-
-    // Self-heal: remove stale .git/index.lock.
-    //
-    // Threshold raised from 60s → 5min because a 60s-old lock is not
-    // definitively stale: `git gc --auto` triggered by a heavy commit, NFS
-    // delays, or concurrent worktree writes can hold .git/index.lock for
-    // minutes on large repos. Force-removing a live lock causes the holder
-    // to encounter `fatal: Unable to create '.git/index.lock'` on its next
-    // write, or worse, operate on a partially-written index → corruption
-    // requiring `git fsck`/`git reset` to recover.
-    // (Issue #4980 CRIT-3)
-    try {
-      const gitLockFile = join(base, ".git", "index.lock");
-      if (existsSync(gitLockFile)) {
-        const lockAge = Date.now() - statSync(gitLockFile).mtimeMs;
-        const STALE_GIT_LOCK_THRESHOLD_MS = 5 * 60_000;
-        if (lockAge > STALE_GIT_LOCK_THRESHOLD_MS) {
-          unlinkSync(gitLockFile);
-          ctx.ui.notify(
-            `Removed stale .git/index.lock (age ${Math.round(lockAge / 1000)}s, > 5min threshold).`,
-            "warning",
-          );
-        } else {
-          // Lock present but not yet stale — surface so the user knows why
-          // git ops may be queueing instead of silently waiting.
-          debugLog("git-lock-present-not-stale", {
-            ageMs: lockAge,
-            thresholdMs: STALE_GIT_LOCK_THRESHOLD_MS,
-          });
+    const mid = state.activeMilestone?.id;
+    if (mid) {
+      try {
+        const manifestStatus = await getManifestStatus(base, mid, s.originalBasePath || base);
+        if (manifestStatus && manifestStatus.pending.length > 0) {
+          const result = await collectSecretsFromManifest(base, mid, ctx);
+          if (
+            result &&
+            result.applied &&
+            result.skipped &&
+            result.existingSkipped
+          ) {
+            ctx.ui.notify(
+              `Secrets collected: ${result.applied.length} applied, ${result.skipped.length} skipped, ${result.existingSkipped.length} already set.`,
+              "info",
+            );
+          } else {
+            ctx.ui.notify("Secrets collection skipped.", "info");
+          }
         }
+      } catch (err) {
+        ctx.ui.notify(
+          `Secrets collection error: ${err instanceof Error ? err.message : String(err)}. Continuing with next task.`,
+          "warning",
+        );
       }
-    } catch (e) {
-      debugLog("git-lock-cleanup-failed", {
-        error: e instanceof Error ? e.message : String(e),
-      });
     }
 
     // Pre-flight: validate milestone queue

package/src/resources/extensions/gsd/auto-timeout-recovery.ts

@@ -19,6 +19,7 @@ import {
 import { existsSync } from "node:fs";
 
 import { bumpAndResolveSynthetic } from "./auto/resolve.js";
+import { finalizeProjectResearchTimeout } from "./project-research-policy.js";
 
 export interface RecoveryContext {
   basePath: string;
@@ -172,6 +173,27 @@ export async function recoverTimedOutUnit(
 
   const expected = diagnoseExpectedArtifact(unitType, unitId, basePath) ?? "required durable artifact";
 
+  if (unitType === "research-project") {
+    const outcome = finalizeProjectResearchTimeout(
+      basePath,
+      `${reason} timeout recovery finalized project research before all dimensions completed.`,
+    );
+    writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnitStartedAt, {
+      phase: outcome.kind === "global-blocker" ? "skipped" : "finalized",
+      recoveryAttempts: recoveryAttempts + 1,
+      lastRecoveryReason: reason,
+    });
+    const message = outcome.kind === "completed"
+      ? `Project research ${reason} timeout: research artifacts are already terminal; advancing.`
+      : outcome.kind === "partial-blockers"
+        ? `Project research ${reason} timeout: wrote blocker files for missing dimensions and advancing with partial research.`
+        : `Project research ${reason} timeout: wrote PROJECT-RESEARCH-BLOCKER.md and stopping fail-closed.`;
+    ctx.ui.notify(message, outcome.kind === "global-blocker" ? "error" : "warning");
+    unitRecoveryCount.delete(recoveryKey);
+    bumpAndResolveSynthetic(`timeout-recovery:${reason}:${unitType}/${unitId}`);
+    return "recovered";
+  }
+
   // Check if the artifact already exists on disk — agent may have written it
   // without signaling completion.
   const artifactPath = resolveExpectedArtifactPath(unitType, unitId, basePath);

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

@@ -10,7 +10,7 @@ import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
 import { readUnitRuntimeRecord, writeUnitRuntimeRecord } from "./unit-runtime.js";
 import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import { resolveAutoSupervisorConfig } from "./preferences.js";
-import type { GSDPreferences } from "./preferences.js";
+import type { AutoSupervisorConfig, GSDPreferences } from "./preferences.js";
 import { computeBudgets, resolveExecutorContextWindow } from "./context-budget.js";
 import {
   getInFlightToolCount,
@@ -40,6 +40,33 @@ export interface SupervisionContext {
   taskEstimate?: string;
 }
 
+export const PROJECT_RESEARCH_SOFT_TIMEOUT_MINUTES = 3;
+export const PROJECT_RESEARCH_HARD_TIMEOUT_MINUTES = 5;
+
+export function resolveUnitSupervisionTimeouts(
+  unitType: string,
+  supervisor: AutoSupervisorConfig,
+  timeoutScale: number,
+): { softTimeoutMs: number; idleTimeoutMs: number; hardTimeoutMs: number } {
+  const softMinutes = supervisor.soft_timeout_minutes ?? 0;
+  const idleMinutes = supervisor.idle_timeout_minutes ?? 0;
+  const hardMinutes = supervisor.hard_timeout_minutes ?? 0;
+
+  if (unitType === "research-project") {
+    return {
+      softTimeoutMs: Math.min(softMinutes, PROJECT_RESEARCH_SOFT_TIMEOUT_MINUTES) * 60 * 1000,
+      idleTimeoutMs: idleMinutes * 60 * 1000,
+      hardTimeoutMs: Math.min(hardMinutes, PROJECT_RESEARCH_HARD_TIMEOUT_MINUTES) * 60 * 1000,
+    };
+  }
+
+  return {
+    softTimeoutMs: softMinutes * 60 * 1000 * timeoutScale,
+    idleTimeoutMs: idleMinutes * 60 * 1000,
+    hardTimeoutMs: hardMinutes * 60 * 1000 * timeoutScale,
+  };
+}
+
 /**
  * Set up all four supervision timers for the current unit:
  * 1. Soft timeout warning (wrapup)
@@ -111,9 +138,14 @@ export function startUnitSupervision(sctx: SupervisionContext): void {
     ? Math.min(MAX_TIMEOUT_SCALE, Math.max(1, estimateMinutes / 10))
     : 1;
 
-  const softTimeoutMs = (supervisor.soft_timeout_minutes ?? 0) * 60 * 1000 * timeoutScale;
-  const idleTimeoutMs = (supervisor.idle_timeout_minutes ?? 0) * 60 * 1000;  // idle not scaled — idle is idle
-  const hardTimeoutMs = (supervisor.hard_timeout_minutes ?? 0) * 60 * 1000 * timeoutScale;
+  const supervisionTimeouts = resolveUnitSupervisionTimeouts(
+    unitType,
+    supervisor,
+    timeoutScale,
+  );
+  const softTimeoutMs = supervisionTimeouts.softTimeoutMs;
+  const idleTimeoutMs = supervisionTimeouts.idleTimeoutMs;
+  const hardTimeoutMs = supervisionTimeouts.hardTimeoutMs;
 
   // ── 1. Soft timeout warning ──
   s.wrapupWarningHandle = setTimeout(() => {
@@ -277,6 +309,7 @@ export function startUnitSupervision(sctx: SupervisionContext): void {
     ctx.modelRegistry as Parameters<typeof resolveExecutorContextWindow>[0],
     prefs as Parameters<typeof resolveExecutorContextWindow>[1],
     ctx.model?.contextWindow,
+    ctx.model?.provider,
   );
   const continueHereThreshold = computeBudgets(executorContextWindow).continueThresholdPercent;
   s.continueHereHandle = setInterval(() => {
@@ -324,4 +357,3 @@ export function startUnitSupervision(sctx: SupervisionContext): void {
     }
   }, 15_000);
 }
-