npm - @opengsd/gsd-pi - Versions diffs - 1.1.1-dev.9bb7453 → 1.1.1-dev.9f86580 - Mend

@opengsd/gsd-pi 1.1.1-dev.9bb7453 → 1.1.1-dev.9f86580

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (219) hide show

package/src/resources/extensions/browser-tools/tests/web-app-detect.test.mjs ADDED Viewed

@@ -0,0 +1,68 @@
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+const { detectWebApp } = await import("../web-app-detect.ts");
+function makeProject(files) {
+  const root = mkdtempSync(join(tmpdir(), "gsd-webapp-detect-"));
+  for (const [relPath, contents] of Object.entries(files)) {
+    const full = join(root, relPath);
+    mkdirSync(join(full, ".."), { recursive: true });
+    writeFileSync(full, contents);
+  }
+  return root;
+}
+describe("detectWebApp", () => {
+  const roots = [];
+  after(() => roots.forEach((root) => rmSync(root, { recursive: true, force: true })));
+  const project = (files) => {
+    const root = makeProject(files);
+    roots.push(root);
+    return root;
+  };
+  it("detects a React dependency", () => {
+    const root = project({ "package.json": JSON.stringify({ dependencies: { react: "^18.0.0" } }) });
+    assert.equal(detectWebApp(root), true);
+  });
+  it("detects a Vite/Next dev dependency", () => {
+    const root = project({ "package.json": JSON.stringify({ devDependencies: { vite: "^5.0.0" } }) });
+    assert.equal(detectWebApp(root), true);
+  });
+  it("detects a dev-server script", () => {
+    const root = project({ "package.json": JSON.stringify({ scripts: { dev: "next dev" } }) });
+    assert.equal(detectWebApp(root), true);
+  });
+  it("detects a static index.html site", () => {
+    const root = project({ "index.html": "<!doctype html>" });
+    assert.equal(detectWebApp(root), true);
+  });
+  it("returns false for a CLI/library package", () => {
+    const root = project({
+      "package.json": JSON.stringify({
+        dependencies: { commander: "^12.0.0" },
+        scripts: { build: "tsc", test: "node --test" },
+      }),
+    });
+    assert.equal(detectWebApp(root), false);
+  });
+  it("returns false when there is no package.json or index.html", () => {
+    const root = project({ "README.md": "# nothing" });
+    assert.equal(detectWebApp(root), false);
+  });
+  it("does not throw on malformed package.json", () => {
+    const root = project({ "package.json": "{ not valid json" });
+    assert.equal(detectWebApp(root), false);
+  });
+});

package/src/resources/extensions/browser-tools/web-app-detect.ts ADDED Viewed

@@ -0,0 +1,63 @@
+/**
+ * web-app-detect — lightweight, synchronous heuristic for deciding whether the
+ * project under development is a web app. Used only when the optional managed
+ * gsd-browser engine is selected and can be warmed before first use.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+// Frontend frameworks / bundlers whose presence in dependencies indicates a
+// browser-facing web app worth warming the optional managed engine for.
+const WEB_DEPENDENCY_RE =
+  /^(react|react-dom|next|nuxt|vue|@vue\/|svelte|@sveltejs\/|solid-js|astro|@remix-run\/|gatsby|preact|@angular\/core|vite|@vitejs\/|@builder\.io\/qwik|@web\/dev-server|@11ty\/eleventy)/;
+// package.json scripts that imply a dev server / browser-facing build.
+const WEB_SCRIPT_RE = /\b(vite|next|nuxt|astro|remix|webpack(-dev-server)?|parcel|ng serve|serve\b|http-server|live-server|gatsby)\b/;
+interface MinimalPackageJson {
+  dependencies?: Record<string, unknown>;
+  devDependencies?: Record<string, unknown>;
+  peerDependencies?: Record<string, unknown>;
+  scripts?: Record<string, unknown>;
+}
+function readPackageJson(projectRoot: string): MinimalPackageJson | null {
+  const packageJsonPath = resolve(projectRoot, "package.json");
+  if (!existsSync(packageJsonPath)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(packageJsonPath, "utf-8")) as unknown;
+    return parsed && typeof parsed === "object" ? (parsed as MinimalPackageJson) : null;
+  } catch {
+    return null;
+  }
+}
+function dependencyNames(pkg: MinimalPackageJson): string[] {
+  return [
+    ...Object.keys(pkg.dependencies ?? {}),
+    ...Object.keys(pkg.devDependencies ?? {}),
+    ...Object.keys(pkg.peerDependencies ?? {}),
+  ];
+}
+/**
+ * Returns true when the project looks like a browser-facing web app. Conservative
+ * and dependency-free: a false negative just means lazy connection (the prior
+ * behavior); a false positive only warms an idle engine connection.
+ */
+export function detectWebApp(projectRoot: string): boolean {
+  const pkg = readPackageJson(projectRoot);
+  if (pkg) {
+    if (dependencyNames(pkg).some((name) => WEB_DEPENDENCY_RE.test(name))) return true;
+    const scriptValues = Object.values(pkg.scripts ?? {}).filter(
+      (value): value is string => typeof value === "string",
+    );
+    if (scriptValues.some((script) => WEB_SCRIPT_RE.test(script))) return true;
+  }
+  // No package.json signal — fall back to a top-level index.html (static sites).
+  if (existsSync(resolve(projectRoot, "index.html"))) return true;
+  if (existsSync(resolve(projectRoot, "public", "index.html"))) return true;
+  return false;
+}

package/src/resources/extensions/gsd/auto/phases.ts CHANGED Viewed

@@ -35,6 +35,8 @@ import { detectStuck } from "./detect-stuck.js";
 import { runUnit } from "./run-unit.js";
 import { debugLog } from "../debug-logger.js";
 import { resolveWorktreeProjectRoot, normalizeWorktreePathForCompare } from "../worktree-root.js";
+import { buildManualValidationGuidance } from "../worktree-manager.js";
+import { relSliceFile } from "../paths.js";
 import { classifyProject } from "../detection.js";
 import { MergeConflictError } from "../git-service.js";
 import { setCurrentPhase, clearCurrentPhase } from "../../shared/gsd-phase-state.js";
@@ -83,6 +85,7 @@ import {
   supportsStructuredQuestions,
 } from "../workflow-mcp.js";
 import { prepareWorkflowMcpForProject } from "../workflow-mcp-auto-prep.js";
+import { getToolBaselineSnapshot } from "../auto-model-selection.js";
 import type { DispatchAction } from "../auto-dispatch.js";
 import { resolveManifest } from "../unit-context-manifest.js";
 import { createWorktreeSafetyModule, type WorktreeSafetyResult } from "../worktree-safety.js";
@@ -397,6 +400,8 @@ async function validateSourceWriteWorktreeSafety(
 let consecutiveSessionTimeouts = 0;
 const MAX_SESSION_TIMEOUT_AUTO_RESUMES = 3;
+/** Maximum zero-tool-call retries before pausing — context exhaustion is deterministic. */
+const MAX_ZERO_TOOL_RETRIES = 1;
 export function resetSessionTimeoutState(): void {
   consecutiveSessionTimeouts = 0;
@@ -1446,7 +1451,13 @@ export async function runDispatch(
   const authMode = provider && typeof ctx.modelRegistry?.getProviderAuthMode === "function"
     ? ctx.modelRegistry.getProviderAuthMode(provider)
     : undefined;
-  const activeTools = typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [];
+  // Use the baseline snapshot rather than the live active-tool set: a prior
+  // unit's per-provider narrowing (hook overrides, Groq 128-tool cap, etc.)
+  // can strip required MCP tools from the live set even though
+  // selectAndApplyModel will restore them before the unit is dispatched.
+  // Checking a stale-narrowed set causes false transport-preflight warnings
+  // that repeat on every /gsd auto resume (#477 follow-up).
+  const activeTools = getToolBaselineSnapshot(pi);
   // Deep planning intentionally keeps human checkpoints in plain chat. In
   // Claude Code/local MCP transports, structured question requests can be
   // cancelled outside the normal chat flow, which made approval gates easy to
@@ -1470,6 +1481,9 @@ export async function runDispatch(
     sessionContextWindow: ctx.model?.contextWindow,
     sessionProvider: ctx.model?.provider,
     modelRegistry: ctx.modelRegistry as MinimalModelRegistry | undefined,
+    activeTools,
+    sessionBaseUrl: ctx.model?.baseUrl,
+    sessionAuthMode: authMode,
   });
   if (isUnhandledPhaseWarning(dispatchResult)) {
     deps.invalidateAllCaches();
@@ -1493,6 +1507,9 @@ export async function runDispatch(
       sessionContextWindow: ctx.model?.contextWindow,
       sessionProvider: ctx.model?.provider,
       modelRegistry: ctx.modelRegistry as MinimalModelRegistry | undefined,
+      activeTools,
+      sessionBaseUrl: ctx.model?.baseUrl,
+      sessionAuthMode: authMode,
     });
   }
@@ -2711,14 +2728,27 @@ export async function runUnitPhase(
             unitId,
           });
         } else {
+          const zeroToolKey = `${unitType}/${unitId}`;
+          const attempt = (s.zeroToolRetryCount.get(zeroToolKey) ?? 0) + 1;
           debugLog("runUnitPhase", {
             phase: "zero-tool-calls",
             unitType,
             unitId,
+            attempt,
             warning: "Unit completed with 0 tool calls — likely context exhaustion, marking as failed",
           });
+          if (attempt > MAX_ZERO_TOOL_RETRIES) {
+            s.zeroToolRetryCount.delete(zeroToolKey);
+            ctx.ui.notify(
+              `${unitType} ${unitId} completed with 0 tool calls — context exhaustion, pausing auto-mode after ${MAX_ZERO_TOOL_RETRIES} retry.`,
+              "error",
+            );
+            await deps.pauseAuto(ctx, pi);
+            return { action: "break", reason: "zero-tool-calls-exhausted" };
+          }
+          s.zeroToolRetryCount.set(zeroToolKey, attempt);
           ctx.ui.notify(
-            `${unitType} ${unitId} completed with 0 tool calls — context exhaustion, will retry`,
+            `${unitType} ${unitId} completed with 0 tool calls — context exhaustion, will retry (attempt ${attempt}/${MAX_ZERO_TOOL_RETRIES})`,
             "warning",
           );
           return {
@@ -2748,6 +2778,7 @@ export async function runUnitPhase(
   if (artifactVerified) {
     s.unitDispatchCount.delete(dispatchKey);
     s.unitRecoveryCount.delete(`${unitType}/${unitId}`);
+    s.zeroToolRetryCount.delete(dispatchKey);
   }
   // Write phase handoff anchor after successful research/planning completion
@@ -2927,10 +2958,21 @@ export async function runFinalize(
   }
   if (pauseAfterUatDispatch) {
-    ctx.ui.notify(
-      "UAT requires human execution. Auto-mode will pause after this unit writes the result file.",
-      "info",
-    );
+    const pauseMid = iterData.mid;
+    const pauseSliceId = pauseMid && iterData.unitId.startsWith(`${pauseMid}/`)
+      ? iterData.unitId.slice(pauseMid.length + 1)
+      : undefined;
+    const guidance = pauseMid
+      ? buildManualValidationGuidance(s.basePath, pauseMid, {
+          uatPath: pauseSliceId
+            ? relSliceFile(s.basePath, pauseMid, pauseSliceId, "UAT")
+            : undefined,
+        })
+      : null;
+    const pauseMessage = guidance
+      ? `UAT requires human execution. Auto-mode will pause after this unit writes the result file.\n\n${guidance}`
+      : "UAT requires human execution. Auto-mode will pause after this unit writes the result file.";
+    ctx.ui.notify(pauseMessage, "info");
     await deps.pauseAuto(ctx, pi);
     debugLog("autoLoop", { phase: "exit", reason: "uat-pause" });
     clearFinalizingUnit();

package/src/resources/extensions/gsd/auto/session.ts CHANGED Viewed

@@ -176,6 +176,7 @@ export class AutoSession {
   readonly verificationRetryCount = new Map<string, number>();
   readonly verificationRetryFailureHashes = new Map<string, string>();
   readonly exhaustedVerificationUnits = new Set<string>();
+  readonly zeroToolRetryCount = new Map<string, number>();
   pausedSessionFile: string | null = null;
   pausedUnitType: string | null = null;
   pausedUnitId: string | null = null;
@@ -362,6 +363,7 @@ export class AutoSession {
     this.verificationRetryCount.clear();
     this.verificationRetryFailureHashes.clear();
     this.exhaustedVerificationUnits.clear();
+    this.zeroToolRetryCount.clear();
     this.pausedSessionFile = null;
     this.pausedUnitType = null;
     this.pausedUnitId = null;

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

@@ -17,7 +17,17 @@ import type { GSDPreferences } from "./preferences.js";
 import type { UatType } from "./files.js";
 import type { MinimalModelRegistry } from "./context-budget.js";
 import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
-import { isDbAvailable, getMilestoneSlices, getPendingGates, markAllGatesOmitted, getMilestone, insertAssessment, setSliceSketchFlag, transaction, getAssessment } from "./gsd-db.js";
+import {
+  isDbAvailable,
+  getMilestoneSlices,
+  getPendingGates,
+  markAllGatesOmitted,
+  getMilestone,
+  insertAssessment,
+  setSliceSketchFlag,
+  transaction,
+  getAssessment,
+} from "./gsd-db.js";
 import { isClosedStatus } from "./status-guards.js";
 import { extractVerdict, isAcceptableUatVerdict } from "./verdict-parser.js";
@@ -76,6 +86,10 @@ import { isAutoActive } from "./auto.js";
 import { markDepthVerified } from "./bootstrap/write-gate.js";
 import { ensureWorkflowPreferencesCaptured } from "./planning-depth.js";
 import { MILESTONE_ID_RE } from "./milestone-ids.js";
+import {
+  getWorkflowTransportSupportError,
+  getRequiredWorkflowToolsForAutoUnit,
+} from "./workflow-mcp.js";
 import {
   PROJECT_RESEARCH_INFLIGHT_MARKER,
 } from "./project-research-policy.js";
@@ -96,6 +110,10 @@ 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 {
+  checkCloseoutConsistencyGate,
+  formatCloseoutConsistencyBlock,
+} from "./closeout-consistency-gate.js";
 // ─── Types ────────────────────────────────────────────────────────────────
@@ -132,6 +150,12 @@ export interface DispatchContext {
   modelRegistry?: MinimalModelRegistry;
   /** Session model provider, used for provider-specific effective context windows. */
   sessionProvider?: string;
+  /** Active tools in the current session, used for transport preflight checks. */
+  activeTools?: string[];
+  /** Session model base URL, used for transport preflight checks. */
+  sessionBaseUrl?: string;
+  /** Session model auth mode, used for transport preflight checks. */
+  sessionAuthMode?: "apiKey" | "oauth" | "externalCli" | "none";
 }
 function resolveExistingExpectedArtifact(
@@ -649,11 +673,23 @@ export const DISPATCH_RULES: DispatchRule[] = [
   },
   {
     name: "run-uat (post-completion)",
-    match: async ({ state, mid, basePath, prefs }) => {
+    match: async ({ state, mid, basePath, prefs, sessionProvider, sessionAuthMode, activeTools, sessionBaseUrl }) => {
       const needsRunUat = await checkNeedsRunUat(basePath, mid, state, prefs);
       if (!needsRunUat) return null;
       const { sliceId, uatType } = needsRunUat;
+      // Transport preflight: verify required MCP tools are actually connected
+      // before consuming a retry attempt. Fixes tool-starved sessions burning
+      // all MAX_UAT_ATTEMPTS before stopping (#477).
+      const transportError = getWorkflowTransportSupportError(
+        sessionProvider,
+        getRequiredWorkflowToolsForAutoUnit("run-uat"),
+        { projectRoot: basePath, surface: "auto-mode", unitType: "run-uat", authMode: sessionAuthMode, baseUrl: sessionBaseUrl, activeTools },
+      );
+      if (transportError) {
+        return { action: "stop" as const, reason: transportError, level: "warning" as const };
+      }
       // Cap run-uat dispatch attempts to prevent infinite replay (#3624).
       // Check before incrementing so an exhausted counter cannot create a
       // no-progress skip loop that starves later dispatch rules.
@@ -1635,6 +1671,16 @@ export const DISPATCH_RULES: DispatchRule[] = [
             prompt: await buildCompleteMilestonePrompt(mid, midTitle, basePath),
           };
         }
+        if (milestone) {
+          const closeoutGate = checkCloseoutConsistencyGate(mid, { refreshFromDisk: true });
+          if (!closeoutGate.ok) {
+            return {
+              action: "stop",
+              reason: formatCloseoutConsistencyBlock(closeoutGate),
+              level: "warning",
+            };
+          }
+        }
       }
       return {
         action: "stop",

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

@@ -90,6 +90,32 @@ export function clearToolBaseline(pi: ExtensionAPI | object): void {
   TOOL_BASELINE.delete(pi as unknown as object);
 }
+/**
+ * Return the union of the pre-dispatch baseline tool set and the current live
+ * active tools, or just the live tools when no baseline has been recorded yet.
+ *
+ * Use this instead of `pi.getActiveTools()` anywhere you need the full tool
+ * surface for a preflight/routing check that runs BEFORE `selectAndApplyModel`
+ * restores the baseline — e.g. in `runDispatch` and `decideNextUnit`.
+ *
+ * The union is intentional:
+ *   - Baseline covers tools that a prior unit's per-provider narrowing (hook
+ *     overrides, Groq 128-tool cap, etc.) has removed from the live set.
+ *     Those tools will be restored by `selectAndApplyModel` before dispatch, so
+ *     dropping them from the preflight check would be a false negative.
+ *   - Live set covers tools connected after the baseline was first captured
+ *     (e.g. MCP servers attached mid-session or after a paused resume).
+ *     Without the live merge, a stale baseline permanently hides newly
+ *     connected MCP tools and prevents transport-preflight from clearing on
+ *     resume (#477 follow-up).
+ */
+export function getToolBaselineSnapshot(pi: ExtensionAPI): string[] {
+  const live = typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [];
+  const baseline = TOOL_BASELINE.get(pi as unknown as object);
+  if (baseline === undefined) return live;
+  return [...new Set([...baseline, ...live])];
+}
 /**
  * Models eligible for the pre-dispatch policy gate. Prefer registry-available
  * models; when that list is empty (common after worktree resume before registry

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

@@ -46,6 +46,7 @@ import { hasBrowserRequiredText } from "./browser-evidence.js";
 import { debugLog } from "./debug-logger.js";
 import { buildSkillActivationBlock, buildSkillDiscoveryVars } from "./skill-activation.js";
 import { findMilestoneIds } from "./milestone-ids.js";
+import { buildRunUatPresentationForType, RUN_UAT_TOOL_PRESENTATION_PLAN_ID } from "./tool-presentation-plan.js";
 export { buildSkillActivationBlock, buildSkillDiscoveryVars };
@@ -3384,6 +3385,7 @@ export async function buildRunUatPrompt(
   const uatResultPath = join(base, relSliceFile(base, mid, sliceId, "ASSESSMENT"));
   const uatType = resolveEffectiveUatType(uatContent);
+  const canonicalPresentation = JSON.stringify(buildRunUatPresentationForType(uatType), null, 2);
   return loadPrompt("run-uat", {
     workingDirectory: base,
@@ -3392,6 +3394,8 @@ export async function buildRunUatPrompt(
     uatPath,
     uatResultPath,
     uatType,
+    toolPresentationPlanId: RUN_UAT_TOOL_PRESENTATION_PLAN_ID,
+    canonicalPresentation,
     inlinedContext,
     skillActivation: buildSkillActivationBlock({
       base,

package/src/resources/extensions/gsd/auto-recovery.ts CHANGED Viewed

@@ -54,6 +54,7 @@ import { isGsdWorktreePath } from "./worktree-root.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
 import { hasImplementationArtifacts } from "./milestone-implementation-evidence.js";
 import { loadAllCaptures, loadPendingCaptures } from "./captures.js";
+import { checkCloseoutConsistencyGate } from "./closeout-consistency-gate.js";
 // Re-export so existing consumers of auto-recovery.ts keep working.
 export { resolveExpectedArtifactPath, diagnoseExpectedArtifact };
@@ -626,9 +627,8 @@ export function verifyExpectedArtifact(
     if (summaryOutcome === "failure") return false;
     const { milestone: mid } = parseUnitId(unitId);
     if (mid && isDbAvailable()) {
-      const dbMilestone = getMilestone(mid);
-      if (!dbMilestone) return false;
-      if (!isClosedStatus(dbMilestone.status) && summaryOutcome !== "success") return false;
+      const closeoutGate = checkCloseoutConsistencyGate(mid, { refreshFromDisk: true });
+      if (!closeoutGate.ok) return false;
     }
     if (hasImplementationArtifacts(base, mid) === "absent") return false;
   }

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

@@ -147,6 +147,15 @@ export function startUnitSupervision(sctx: SupervisionContext): void {
   const softTimeoutMs = supervisionTimeouts.softTimeoutMs;
   const idleTimeoutMs = supervisionTimeouts.idleTimeoutMs;
   const hardTimeoutMs = supervisionTimeouts.hardTimeoutMs;
+  // A single hung tool gets its own short budget, NOT the general idle window:
+  // a long-but-progressing session is not idle, but a tool stuck for minutes
+  // is. Falls back to the idle window only if misconfigured to zero. The
+  // hung-tool budget is intentionally not scaled by task estimate — a stuck
+  // tool call is stuck regardless of how long the overall task should take.
+  const stalledToolTimeoutMs =
+    (supervisor.stalled_tool_timeout_minutes ?? 0) > 0
+      ? supervisor.stalled_tool_timeout_minutes! * 60 * 1000
+      : idleTimeoutMs;
   // ── 1. Soft timeout warning ──
   s.wrapupWarningHandle = setTimeout(() => {
@@ -189,10 +198,13 @@ export function startUnitSupervision(sctx: SupervisionContext): void {
       };
       const runtime = readUnitRuntimeRecord(s.basePath, unitType, unitId);
       if (!runtime) return;
-      if (Date.now() - runtime.lastProgressAt < idleTimeoutMs) return;
-      // Agent has tool calls currently executing — not idle, just waiting.
-      // But only suppress recovery if the tool started recently.
+      // In-flight tool handling runs on its own dedicated hung-tool budget,
+      // independent of the general idle gate below, so a genuinely stuck tool
+      // is caught in minutes instead of waiting out the (typically much longer)
+      // idle window (#2527, follow-up). A tool actively executing within budget
+      // is real progress, so refreshing lastProgressAt here also keeps the idle
+      // gate from firing during legitimate long-running tool calls.
       let stalledToolDetected = false;
       if (getInFlightToolCount() > 0) {
         // User-interactive tools (ask_user_questions, secure_env_collect) block
@@ -206,25 +218,29 @@ export function startUnitSupervision(sctx: SupervisionContext): void {
         }
         const oldestStart = getOldestInFlightToolStart()!;
         const toolAgeMs = Date.now() - oldestStart;
-        if (toolAgeMs < idleTimeoutMs) {
+        if (toolAgeMs < stalledToolTimeoutMs) {
           writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
             lastProgressAt: Date.now(),
             lastProgressKind: "tool-in-flight",
           });
           return;
         }
-        // Tool has been in-flight longer than idle timeout — treat as hung.
-        // Clear the stale entries so subsequent ticks don't re-detect them,
-        // and set the flag so the filesystem-activity check below does not
-        // override the stall verdict (#2527).
+        // Tool has been in-flight longer than the hung-tool budget — treat as
+        // hung. Clear the stale entries so subsequent ticks don't re-detect
+        // them, and set the flag so the idle gate and filesystem-activity check
+        // below do not override the stall verdict (#2527).
         stalledToolDetected = true;
         clearInFlightTools();
         ctx.ui.notify(
-          `Stalled tool detected: a tool has been in-flight for ${Math.round(toolAgeMs / 60000)}min. Treating as hung — attempting idle recovery.`,
+          `Stalled tool detected: a tool has been in-flight for ${Math.round(toolAgeMs / 60000)}min (budget ${Math.round(stalledToolTimeoutMs / 60000)}min). Treating as hung — attempting idle recovery.`,
           "warning",
         );
       }
+      // No hung tool — apply the general idle gate. A unit that has made
+      // meaningful progress within the idle window is not idle yet.
+      if (!stalledToolDetected && Date.now() - runtime.lastProgressAt < idleTimeoutMs) return;
       // Check if the agent is producing work on disk.
       // Skip this when a stalled tool was just detected — filesystem changes
       // from earlier in the task should not override the stall verdict (#2527).