gsd-pi 2.33.1 → 2.34.0-dev.bbb5216

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

@@ -1,224 +0,0 @@
-/**
- * Unit supervision timers — soft timeout warning, idle watchdog,
- * hard timeout, and context-pressure monitor.
- *
- * Extracted from dispatchNextUnit() in auto.ts. All timers are set up
- * via startUnitSupervision() and torn down by the caller via clearUnitTimeout().
- */
-
-import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
-import { readUnitRuntimeRecord, writeUnitRuntimeRecord } from "./unit-runtime.js";
-import { resolveAutoSupervisorConfig } from "./preferences.js";
-import type { GSDPreferences } from "./preferences.js";
-import { computeBudgets, resolveExecutorContextWindow } from "./context-budget.js";
-import {
-  getInFlightToolCount,
-  getOldestInFlightToolStart,
-} from "./auto-tool-tracking.js";
-import { detectWorkingTreeActivity } from "./auto-supervisor.js";
-import { closeoutUnit, type CloseoutOptions } from "./auto-unit-closeout.js";
-import { saveActivityLog } from "./activity-log.js";
-import { recoverTimedOutUnit, type RecoveryContext } from "./auto-timeout-recovery.js";
-import type { AutoSession } from "./auto/session.js";
-import { getErrorMessage } from "./error-utils.js";
-
-export interface SupervisionContext {
-  s: AutoSession;
-  ctx: ExtensionContext;
-  pi: ExtensionAPI;
-  unitType: string;
-  unitId: string;
-  prefs: GSDPreferences | undefined;
-  buildSnapshotOpts: () => CloseoutOptions & Record<string, unknown>;
-  buildRecoveryContext: () => RecoveryContext;
-  pauseAuto: (ctx?: ExtensionContext, pi?: ExtensionAPI) => Promise<void>;
-}
-
-/**
- * Set up all four supervision timers for the current unit:
- * 1. Soft timeout warning (wrapup)
- * 2. Idle watchdog (progress polling, stuck tool detection)
- * 3. Hard timeout (pause + recovery)
- * 4. Context-pressure monitor (continue-here)
- */
-export function startUnitSupervision(sctx: SupervisionContext): void {
-  const { s, ctx, pi, unitType, unitId, prefs, buildSnapshotOpts, buildRecoveryContext, pauseAuto } = sctx;
-
-  const supervisor = resolveAutoSupervisorConfig();
-  const softTimeoutMs = (supervisor.soft_timeout_minutes ?? 0) * 60 * 1000;
-  const idleTimeoutMs = (supervisor.idle_timeout_minutes ?? 0) * 60 * 1000;
-  const hardTimeoutMs = (supervisor.hard_timeout_minutes ?? 0) * 60 * 1000;
-
-  // ── 1. Soft timeout warning ──
-  s.wrapupWarningHandle = setTimeout(() => {
-    s.wrapupWarningHandle = null;
-    if (!s.active || !s.currentUnit) return;
-    writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
-      phase: "wrapup-warning-sent",
-      wrapupWarningSent: true,
-    });
-    pi.sendMessage(
-      {
-        customType: "gsd-auto-wrapup",
-        display: s.verbose,
-        content: [
-          "**TIME BUDGET WARNING — keep going only if progress is real.**",
-          "This unit crossed the soft time budget.",
-          "If you are making progress, continue. If not, switch to wrap-up mode now:",
-          "1. rerun the minimal required verification",
-          "2. write or update the required durable artifacts",
-          "3. mark task or slice state on disk correctly",
-          "4. leave precise resume notes if anything remains unfinished",
-        ].join("\n"),
-      },
-      { triggerTurn: true },
-    );
-  }, softTimeoutMs);
-
-  // ── 2. Idle watchdog ──
-  s.idleWatchdogHandle = setInterval(async () => {
-    try {
-      if (!s.active || !s.currentUnit) return;
-      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.
-      if (getInFlightToolCount() > 0) {
-        const oldestStart = getOldestInFlightToolStart()!;
-        const toolAgeMs = Date.now() - oldestStart;
-        if (toolAgeMs < idleTimeoutMs) {
-          writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
-            lastProgressAt: Date.now(),
-            lastProgressKind: "tool-in-flight",
-          });
-          return;
-        }
-        ctx.ui.notify(
-          `Stalled tool detected: a tool has been in-flight for ${Math.round(toolAgeMs / 60000)}min. Treating as hung — attempting idle recovery.`,
-          "warning",
-        );
-      }
-
-      // Check if the agent is producing work on disk.
-      if (detectWorkingTreeActivity(s.basePath)) {
-        writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
-          lastProgressAt: Date.now(),
-          lastProgressKind: "filesystem-activity",
-        });
-        return;
-      }
-
-      if (s.currentUnit) {
-        await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, buildSnapshotOpts());
-      } else {
-        saveActivityLog(ctx, s.basePath, unitType, unitId);
-      }
-
-      const recovery = await recoverTimedOutUnit(ctx, pi, unitType, unitId, "idle", buildRecoveryContext());
-      if (recovery === "recovered") return;
-
-      writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
-        phase: "paused",
-      });
-      ctx.ui.notify(
-        `Unit ${unitType} ${unitId} made no meaningful progress for ${supervisor.idle_timeout_minutes}min. Pausing auto-mode.`,
-        "warning",
-      );
-      await pauseAuto(ctx, pi);
-    } catch (err) {
-      const message = getErrorMessage(err);
-      console.error(`[idle-watchdog] Unhandled error: ${message}`);
-      try {
-        ctx.ui.notify(`Idle watchdog error: ${message}`, "warning");
-      } catch { /* best effort */ }
-    }
-  }, 15000);
-
-  // ── 3. Hard timeout ──
-  s.unitTimeoutHandle = setTimeout(async () => {
-    try {
-      s.unitTimeoutHandle = null;
-      if (!s.active) return;
-      if (s.currentUnit) {
-        writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
-          phase: "timeout",
-          timeoutAt: Date.now(),
-        });
-        await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, buildSnapshotOpts());
-      } else {
-        saveActivityLog(ctx, s.basePath, unitType, unitId);
-      }
-
-      const recovery = await recoverTimedOutUnit(ctx, pi, unitType, unitId, "hard", buildRecoveryContext());
-      if (recovery === "recovered") return;
-
-      ctx.ui.notify(
-        `Unit ${unitType} ${unitId} exceeded ${supervisor.hard_timeout_minutes}min hard timeout. Pausing auto-mode.`,
-        "warning",
-      );
-      await pauseAuto(ctx, pi);
-    } catch (err) {
-      const message = getErrorMessage(err);
-      console.error(`[hard-timeout] Unhandled error: ${message}`);
-      try {
-        ctx.ui.notify(`Hard timeout error: ${message}`, "warning");
-      } catch { /* best effort */ }
-    }
-  }, hardTimeoutMs);
-
-  // ── 4. Context-pressure continue-here monitor ──
-  if (s.continueHereHandle) {
-    clearInterval(s.continueHereHandle);
-    s.continueHereHandle = null;
-  }
-  const executorContextWindow = resolveExecutorContextWindow(
-    ctx.modelRegistry as Parameters<typeof resolveExecutorContextWindow>[0],
-    prefs as Parameters<typeof resolveExecutorContextWindow>[1],
-    ctx.model?.contextWindow,
-  );
-  const continueHereThreshold = computeBudgets(executorContextWindow).continueThresholdPercent;
-  s.continueHereHandle = setInterval(() => {
-    if (!s.active || !s.currentUnit || !s.cmdCtx) return;
-    const runtime = readUnitRuntimeRecord(s.basePath, unitType, unitId);
-    if (runtime?.continueHereFired) return;
-
-    const contextUsage = s.cmdCtx.getContextUsage();
-    if (!contextUsage || contextUsage.percent == null || contextUsage.percent < continueHereThreshold) return;
-
-    writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit!.startedAt, {
-      continueHereFired: true,
-    });
-
-    if (s.verbose) {
-      ctx.ui.notify(
-        `Context at ${contextUsage.percent}% (threshold: ${continueHereThreshold}%) — sending wrap-up signal.`,
-        "info",
-      );
-    }
-
-    pi.sendMessage(
-      {
-        customType: "gsd-auto-wrapup",
-        display: s.verbose,
-        content: [
-          "**CONTEXT BUDGET WARNING — wrap up this unit now.**",
-          `Context window is at ${contextUsage.percent}% (threshold: ${continueHereThreshold}%).`,
-          "The next unit needs a fresh context to work effectively. Wrap up now:",
-          "1. Finish any in-progress file writes",
-          "2. Write or update the required durable artifacts (summary, checkboxes)",
-          "3. Mark task state on disk correctly",
-          "4. Leave precise resume notes if anything remains unfinished",
-          "Do NOT start new sub-tasks or investigations.",
-        ].join("\n"),
-      },
-      { triggerTurn: true },
-    );
-
-    if (s.continueHereHandle) {
-      clearInterval(s.continueHereHandle);
-      s.continueHereHandle = null;
-    }
-  }, 15_000);
-}

package/dist/resources/extensions/gsd/auto-tool-tracking.ts

@@ -1,54 +0,0 @@
-/**
- * In-flight tool call tracking for auto-mode idle detection.
- * Tracks which tool calls are currently executing so the idle watchdog
- * can distinguish "waiting for tool completion" from "truly idle".
- */
-
-const inFlightTools = new Map<string, number>();
-
-/**
- * Mark a tool execution as in-flight.
- * Records start time so the idle watchdog can detect tools hung longer than the idle timeout.
- */
-export function markToolStart(toolCallId: string, isActive: boolean): void {
-  if (!isActive) return;
-  inFlightTools.set(toolCallId, Date.now());
-}
-
-/**
- * Mark a tool execution as completed.
- */
-export function markToolEnd(toolCallId: string): void {
-  inFlightTools.delete(toolCallId);
-}
-
-/**
- * Returns the age (ms) of the oldest currently in-flight tool, or 0 if none.
- */
-export function getOldestInFlightToolAgeMs(): number {
-  if (inFlightTools.size === 0) return 0;
-  const oldestStart = Math.min(...inFlightTools.values());
-  return Date.now() - oldestStart;
-}
-
-/**
- * Returns the number of currently in-flight tools.
- */
-export function getInFlightToolCount(): number {
-  return inFlightTools.size;
-}
-
-/**
- * Returns the start timestamp of the oldest in-flight tool, or undefined if none.
- */
-export function getOldestInFlightToolStart(): number | undefined {
-  if (inFlightTools.size === 0) return undefined;
-  return Math.min(...inFlightTools.values());
-}
-
-/**
- * Clear all in-flight tool tracking state.
- */
-export function clearInFlightTools(): void {
-  inFlightTools.clear();
-}

package/dist/resources/extensions/gsd/auto-unit-closeout.ts

@@ -1,48 +0,0 @@
-/**
- * Unit closeout helper — consolidates the repeated pattern of
- * snapshotting metrics + saving activity log + extracting memories
- * that appears 6+ times in auto.ts.
- */
-
-import type { ExtensionContext } from "@gsd/pi-coding-agent";
-import { snapshotUnitMetrics } from "./metrics.js";
-import { saveActivityLog } from "./activity-log.js";
-
-export interface CloseoutOptions {
-  promptCharCount?: number;
-  baselineCharCount?: number;
-  tier?: string;
-  modelDowngraded?: boolean;
-  continueHereFired?: boolean;
-}
-
-/**
- * Snapshot metrics, save activity log, and fire-and-forget memory extraction
- * for a completed unit. Returns the activity log file path (if any).
- */
-export async function closeoutUnit(
-  ctx: ExtensionContext,
-  basePath: string,
-  unitType: string,
-  unitId: string,
-  startedAt: number,
-  opts?: CloseoutOptions,
-): Promise<string | undefined> {
-  const modelId = ctx.model?.id ?? "unknown";
-  snapshotUnitMetrics(ctx, unitType, unitId, startedAt, modelId, opts);
-  const activityFile = saveActivityLog(ctx, basePath, unitType, unitId);
-
-  if (activityFile) {
-    try {
-      const { buildMemoryLLMCall, extractMemoriesFromUnit } = await import('./memory-extractor.js');
-      const llmCallFn = buildMemoryLLMCall(ctx);
-      if (llmCallFn) {
-        extractMemoriesFromUnit(activityFile, unitType, unitId, llmCallFn).catch((err) => {
-          if (process.env.GSD_DEBUG) console.error(`[gsd] memory extraction failed for ${unitType}/${unitId}:`, err);
-        });
-      }
-    } catch { /* non-fatal */ }
-  }
-
-  return activityFile ?? undefined;
-}

package/dist/resources/extensions/gsd/auto-verification.ts

@@ -1,229 +0,0 @@
-/**
- * Post-unit verification gate for auto-mode.
- *
- * Runs typecheck/lint/test checks, captures runtime errors, performs
- * dependency audits, handles auto-fix retry logic, and writes
- * verification evidence JSON.
- *
- * Extracted from handleAgentEnd() in auto.ts. Returns a sentinel
- * value instead of calling return/pauseAuto directly — the caller
- * checks the result and handles control flow.
- */
-
-import type { ExtensionContext, ExtensionAPI } from "@gsd/pi-coding-agent";
-import { loadFile, parsePlan } from "./files.js";
-import { resolveSliceFile, resolveSlicePath } from "./paths.js";
-import { loadEffectiveGSDPreferences } from "./preferences.js";
-import {
-  runVerificationGate,
-  formatFailureContext,
-  captureRuntimeErrors,
-  runDependencyAudit,
-} from "./verification-gate.js";
-import { writeVerificationJSON } from "./verification-evidence.js";
-import { removePersistedKey } from "./auto-recovery.js";
-import type { AutoSession, PendingVerificationRetry } from "./auto/session.js";
-import { join } from "node:path";
-import { getErrorMessage } from "./error-utils.js";
-import { parseUnitId } from "./unit-id.js";
-
-export interface VerificationContext {
-  s: AutoSession;
-  ctx: ExtensionContext;
-  pi: ExtensionAPI;
-}
-
-export type VerificationResult = "continue" | "retry" | "pause";
-
-/**
- * Run the verification gate for the current execute-task unit.
- * Returns:
- * - "continue" — gate passed (or no checks configured), proceed normally
- * - "retry" — gate failed with retries remaining, dispatchNextUnit already called
- * - "pause" — gate failed with retries exhausted, pauseAuto already called
- */
-export async function runPostUnitVerification(
-  vctx: VerificationContext,
-  dispatchNextUnit: (ctx: ExtensionContext, pi: ExtensionAPI) => Promise<void>,
-  startDispatchGapWatchdog: (ctx: ExtensionContext, pi: ExtensionAPI) => void,
-  pauseAuto: (ctx?: ExtensionContext, pi?: ExtensionAPI) => Promise<void>,
-): Promise<VerificationResult> {
-  const { s, ctx, pi } = vctx;
-
-  if (!s.currentUnit || s.currentUnit.type !== "execute-task") {
-    return "continue";
-  }
-
-  try {
-    const effectivePrefs = loadEffectiveGSDPreferences();
-    const prefs = effectivePrefs?.preferences;
-
-    // Read task plan verify field
-    const { milestone: mid, slice: sid, task: tid } = parseUnitId(s.currentUnit.id);
-    let taskPlanVerify: string | undefined;
-    if (mid && sid && tid) {
-      const planFile = resolveSliceFile(s.basePath, mid, sid, "PLAN");
-      if (planFile) {
-        const planContent = await loadFile(planFile);
-        if (planContent) {
-          const slicePlan = parsePlan(planContent);
-          const taskEntry = slicePlan?.tasks?.find(t => t.id === tid);
-          taskPlanVerify = taskEntry?.verify;
-        }
-      }
-    }
-
-    const result = runVerificationGate({
-      basePath: s.basePath,
-      unitId: s.currentUnit.id,
-      cwd: s.basePath,
-      preferenceCommands: prefs?.verification_commands,
-      taskPlanVerify,
-    });
-
-    // Capture runtime errors
-    const runtimeErrors = await captureRuntimeErrors();
-    if (runtimeErrors.length > 0) {
-      result.runtimeErrors = runtimeErrors;
-      if (runtimeErrors.some(e => e.blocking)) {
-        result.passed = false;
-      }
-    }
-
-    // Dependency audit
-    const auditWarnings = runDependencyAudit(s.basePath);
-    if (auditWarnings.length > 0) {
-      result.auditWarnings = auditWarnings;
-      process.stderr.write(`verification-gate: ${auditWarnings.length} audit warning(s)\n`);
-      for (const w of auditWarnings) {
-        process.stderr.write(`  [${w.severity}] ${w.name}: ${w.title}\n`);
-      }
-    }
-
-    // Auto-fix retry preferences
-    const autoFixEnabled = prefs?.verification_auto_fix !== false;
-    const maxRetries = typeof prefs?.verification_max_retries === "number" ? prefs.verification_max_retries : 2;
-    const completionKey = `${s.currentUnit.type}/${s.currentUnit.id}`;
-
-    if (result.checks.length > 0) {
-      const blockingChecks = result.checks.filter(c => c.blocking);
-      const advisoryChecks = result.checks.filter(c => !c.blocking);
-      const blockingPassCount = blockingChecks.filter(c => c.exitCode === 0).length;
-      const advisoryFailCount = advisoryChecks.filter(c => c.exitCode !== 0).length;
-
-      if (result.passed) {
-        let msg = blockingChecks.length > 0
-          ? `Verification gate: ${blockingPassCount}/${blockingChecks.length} blocking checks passed`
-          : `Verification gate: passed (no blocking checks)`;
-        if (advisoryFailCount > 0) {
-          msg += ` (${advisoryFailCount} advisory warning${advisoryFailCount > 1 ? "s" : ""})`;
-        }
-        ctx.ui.notify(msg);
-        // Log advisory warnings to stderr for visibility
-        if (advisoryFailCount > 0) {
-          const advisoryFailures = advisoryChecks.filter(c => c.exitCode !== 0);
-          process.stderr.write(`verification-gate: ${advisoryFailCount} advisory (non-blocking) failure(s)\n`);
-          for (const f of advisoryFailures) {
-            process.stderr.write(`  [advisory] ${f.command} exited ${f.exitCode}\n`);
-          }
-        }
-      } else {
-        const blockingFailures = blockingChecks.filter(c => c.exitCode !== 0);
-        const failNames = blockingFailures.map(f => f.command).join(", ");
-        ctx.ui.notify(`Verification gate: FAILED — ${failNames}`);
-        process.stderr.write(`verification-gate: ${blockingFailures.length}/${blockingChecks.length} blocking checks failed\n`);
-        for (const f of blockingFailures) {
-          process.stderr.write(`  ${f.command} exited ${f.exitCode}\n`);
-          if (f.stderr) process.stderr.write(`  stderr: ${f.stderr.slice(0, 500)}\n`);
-        }
-        if (advisoryFailCount > 0) {
-          process.stderr.write(`verification-gate: ${advisoryFailCount} additional advisory (non-blocking) failure(s)\n`);
-        }
-      }
-    }
-
-    // Log blocking runtime errors
-    if (result.runtimeErrors?.some(e => e.blocking)) {
-      const blockingErrors = result.runtimeErrors.filter(e => e.blocking);
-      process.stderr.write(`verification-gate: ${blockingErrors.length} blocking runtime error(s) detected\n`);
-      for (const err of blockingErrors) {
-        process.stderr.write(`  [${err.source}] ${err.severity}: ${err.message.slice(0, 200)}\n`);
-      }
-    }
-
-    // Write verification evidence JSON
-    const attempt = s.verificationRetryCount.get(s.currentUnit.id) ?? 0;
-    if (mid && sid && tid) {
-      try {
-        const sDir = resolveSlicePath(s.basePath, mid, sid);
-        if (sDir) {
-          const tasksDir = join(sDir, "tasks");
-          if (result.passed) {
-            writeVerificationJSON(result, tasksDir, tid, s.currentUnit.id);
-          } else {
-            const nextAttempt = attempt + 1;
-            writeVerificationJSON(result, tasksDir, tid, s.currentUnit.id, nextAttempt, maxRetries);
-          }
-        }
-      } catch (evidenceErr) {
-        process.stderr.write(`verification-evidence: write error — ${(evidenceErr as Error).message}\n`);
-      }
-    }
-
-    // ── Auto-fix retry logic ──
-    if (result.passed) {
-      s.verificationRetryCount.delete(s.currentUnit.id);
-      s.pendingVerificationRetry = null;
-      return "continue";
-    } else if (result.discoverySource === "package-json") {
-      // Auto-discovered checks from package.json may fail on pre-existing errors
-      // that the current task didn't introduce. Don't trigger the retry loop —
-      // log a warning and let the task proceed (#1186).
-      process.stderr.write(
-        `verification-gate: auto-discovered checks failed (source: package-json) — treating as advisory, not blocking\n`,
-      );
-      ctx.ui.notify(
-        `Verification: auto-discovered checks failed (pre-existing errors likely). Continuing without retry.`,
-        "warning",
-      );
-      s.verificationRetryCount.delete(s.currentUnit.id);
-      s.pendingVerificationRetry = null;
-      return "continue";
-    } else if (autoFixEnabled && attempt + 1 <= maxRetries) {
-      const nextAttempt = attempt + 1;
-      s.verificationRetryCount.set(s.currentUnit.id, nextAttempt);
-      s.pendingVerificationRetry = {
-        unitId: s.currentUnit.id,
-        failureContext: formatFailureContext(result),
-        attempt: nextAttempt,
-      };
-      ctx.ui.notify(`Verification failed — auto-fix attempt ${nextAttempt}/${maxRetries}`, "warning");
-      s.completedKeySet.delete(completionKey);
-      removePersistedKey(s.basePath, completionKey);
-      // Dispatch retry immediately
-      try {
-        await dispatchNextUnit(ctx, pi);
-      } catch (retryDispatchErr) {
-        const msg = getErrorMessage(retryDispatchErr);
-        ctx.ui.notify(`Verification retry dispatch error: ${msg}`, "error");
-        startDispatchGapWatchdog(ctx, pi);
-      }
-      return "retry";
-    } else {
-      // Gate failed, retries exhausted
-      const exhaustedAttempt = attempt + 1;
-      s.verificationRetryCount.delete(s.currentUnit.id);
-      s.pendingVerificationRetry = null;
-      ctx.ui.notify(
-        `Verification gate FAILED after ${exhaustedAttempt > maxRetries ? exhaustedAttempt - 1 : exhaustedAttempt} retries — pausing for human review`,
-        "error",
-      );
-      await pauseAuto(ctx, pi);
-      return "pause";
-    }
-  } catch (err) {
-    // Gate errors are non-fatal
-    process.stderr.write(`verification-gate: error — ${(err as Error).message}\n`);
-    return "continue";
-  }
-}