gsd-pi 2.33.0-dev.bafba33 → 2.33.1-dev.235d83a

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

@@ -1,151 +0,0 @@
-/**
- * Idempotency checks for auto-mode unit dispatch.
- *
- * Handles completed-key membership, artifact cross-validation,
- * consecutive skip counting, phantom skip loop detection, key eviction,
- * and fallback persistence.
- *
- * Extracted from dispatchNextUnit() in auto.ts. Pure decision logic
- * with set mutations — does NOT call dispatchNextUnit or stopAuto.
- */
-
-import { invalidateAllCaches } from "./cache.js";
-import {
-  verifyExpectedArtifact,
-  persistCompletedKey,
-  removePersistedKey,
-} from "./auto-recovery.js";
-import { resolveMilestoneFile } from "./paths.js";
-import { MAX_CONSECUTIVE_SKIPS, MAX_LIFETIME_DISPATCHES } from "./auto/session.js";
-import type { AutoSession } from "./auto/session.js";
-import { parseUnitId } from "./unit-id.js";
-
-export interface IdempotencyContext {
-  s: AutoSession;
-  unitType: string;
-  unitId: string;
-  basePath: string;
-  /** Notification callback */
-  notify: (message: string, level: "info" | "warning" | "error") => void;
-}
-
-export type IdempotencyResult =
-  | { action: "skip"; reason: string }
-  | { action: "rerun"; reason: string }
-  | { action: "proceed" }
-  | { action: "stop"; reason: string };
-
-/**
- * Check whether a unit should be skipped (already completed), rerun
- * (stale completion record), or dispatched normally.
- *
- * Mutates s.completedKeySet, s.unitConsecutiveSkips, s.unitLifetimeDispatches,
- * and s.recentlyEvictedKeys as needed.
- */
-export function checkIdempotency(ictx: IdempotencyContext): IdempotencyResult {
-  const { s, unitType, unitId, basePath, notify } = ictx;
-  const idempotencyKey = `${unitType}/${unitId}`;
-
-  // ── Primary path: key exists in completed set ──
-  if (s.completedKeySet.has(idempotencyKey)) {
-    const artifactExists = verifyExpectedArtifact(unitType, unitId, basePath);
-    if (artifactExists) {
-      // Guard against infinite skip loops
-      const skipCount = (s.unitConsecutiveSkips.get(idempotencyKey) ?? 0) + 1;
-      s.unitConsecutiveSkips.set(idempotencyKey, skipCount);
-      if (skipCount > MAX_CONSECUTIVE_SKIPS) {
-        // Cross-check: verify the unit's milestone is still active (#790)
-        const skippedMid = parseUnitId(unitId).milestone;
-        const skippedMilestoneComplete = skippedMid
-          ? !!resolveMilestoneFile(basePath, skippedMid, "SUMMARY")
-          : false;
-        if (skippedMilestoneComplete) {
-          s.unitConsecutiveSkips.delete(idempotencyKey);
-          invalidateAllCaches();
-          notify(
-            `Phantom skip loop cleared: ${unitType} ${unitId} belongs to completed milestone ${skippedMid}. Re-dispatching from fresh state.`,
-            "info",
-          );
-          return { action: "skip", reason: "phantom-loop-cleared" };
-        }
-        s.unitConsecutiveSkips.delete(idempotencyKey);
-        s.completedKeySet.delete(idempotencyKey);
-        s.recentlyEvictedKeys.add(idempotencyKey);
-        removePersistedKey(basePath, idempotencyKey);
-        invalidateAllCaches();
-        notify(
-          `Skip loop detected: ${unitType} ${unitId} skipped ${skipCount} times without advancing. Evicting completion record and forcing reconciliation.`,
-          "warning",
-        );
-        return { action: "skip", reason: "evicted" };
-      }
-      // Count toward lifetime cap
-      const lifeSkip = (s.unitLifetimeDispatches.get(idempotencyKey) ?? 0) + 1;
-      s.unitLifetimeDispatches.set(idempotencyKey, lifeSkip);
-      if (lifeSkip > MAX_LIFETIME_DISPATCHES) {
-        return { action: "stop", reason: `Hard loop: ${unitType} ${unitId} (skip cycle)` };
-      }
-      notify(
-        `Skipping ${unitType} ${unitId} — already completed in a prior session. Advancing.`,
-        "info",
-      );
-      return { action: "skip", reason: "completed" };
-    } else {
-      // Stale completion record — artifact missing. Remove and re-run.
-      s.completedKeySet.delete(idempotencyKey);
-      removePersistedKey(basePath, idempotencyKey);
-      notify(
-        `Re-running ${unitType} ${unitId} — marked complete but expected artifact missing.`,
-        "warning",
-      );
-      return { action: "rerun", reason: "stale-key" };
-    }
-  }
-
-  // ── Fallback: key missing but artifact exists ──
-  if (verifyExpectedArtifact(unitType, unitId, basePath) && !s.recentlyEvictedKeys.has(idempotencyKey)) {
-    persistCompletedKey(basePath, idempotencyKey);
-    s.completedKeySet.add(idempotencyKey);
-    invalidateAllCaches();
-    // Same consecutive-skip guard as the primary path
-    const skipCount2 = (s.unitConsecutiveSkips.get(idempotencyKey) ?? 0) + 1;
-    s.unitConsecutiveSkips.set(idempotencyKey, skipCount2);
-    if (skipCount2 > MAX_CONSECUTIVE_SKIPS) {
-      const skippedMid2 = parseUnitId(unitId).milestone;
-      const skippedMilestoneComplete2 = skippedMid2
-        ? !!resolveMilestoneFile(basePath, skippedMid2, "SUMMARY")
-        : false;
-      if (skippedMilestoneComplete2) {
-        s.unitConsecutiveSkips.delete(idempotencyKey);
-        invalidateAllCaches();
-        notify(
-          `Phantom skip loop cleared: ${unitType} ${unitId} belongs to completed milestone ${skippedMid2}. Re-dispatching from fresh state.`,
-          "info",
-        );
-        return { action: "skip", reason: "phantom-loop-cleared" };
-      }
-      s.unitConsecutiveSkips.delete(idempotencyKey);
-      s.completedKeySet.delete(idempotencyKey);
-      removePersistedKey(basePath, idempotencyKey);
-      invalidateAllCaches();
-      notify(
-        `Skip loop detected: ${unitType} ${unitId} skipped ${skipCount2} times without advancing. Evicting completion record and forcing reconciliation.`,
-        "warning",
-      );
-      return { action: "skip", reason: "evicted" };
-    }
-    // Count toward lifetime cap
-    const lifeSkip2 = (s.unitLifetimeDispatches.get(idempotencyKey) ?? 0) + 1;
-    s.unitLifetimeDispatches.set(idempotencyKey, lifeSkip2);
-    if (lifeSkip2 > MAX_LIFETIME_DISPATCHES) {
-      return { action: "stop", reason: `Hard loop: ${unitType} ${unitId} (skip cycle)` };
-    }
-    notify(
-      `Skipping ${unitType} ${unitId} — artifact exists but completion key was missing. Repaired and advancing.`,
-      "info",
-    );
-    return { action: "skip", reason: "fallback-persisted" };
-  }
-
-  return { action: "proceed" };
-}

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

@@ -1,179 +0,0 @@
-/**
- * Model selection and dynamic routing for auto-mode unit dispatch.
- * Handles complexity-based routing, model resolution across providers,
- * and fallback chains.
- */
-
-import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
-import type { GSDPreferences } from "./preferences.js";
-import { resolveModelWithFallbacksForUnit, resolveDynamicRoutingConfig } from "./preferences.js";
-import { classifyUnitComplexity, tierLabel } from "./complexity-classifier.js";
-import { resolveModelForComplexity } from "./model-router.js";
-import { getLedger, getProjectTotals } from "./metrics.js";
-import { unitPhaseLabel } from "./auto-dashboard.js";
-
-export interface ModelSelectionResult {
-  /** Routing metadata for metrics recording */
-  routing: { tier: string; modelDowngraded: boolean } | null;
-}
-
-/**
- * Select and apply the appropriate model for a unit dispatch.
- * Handles: per-unit-type model preferences, dynamic complexity routing,
- * provider/model resolution, fallback chains, and start-model re-application.
- *
- * Returns routing metadata for metrics tracking.
- */
-export async function selectAndApplyModel(
-  ctx: ExtensionContext,
-  pi: ExtensionAPI,
-  unitType: string,
-  unitId: string,
-  basePath: string,
-  prefs: GSDPreferences | undefined,
-  verbose: boolean,
-  autoModeStartModel: { provider: string; id: string } | null,
-): Promise<ModelSelectionResult> {
-  const modelConfig = resolveModelWithFallbacksForUnit(unitType);
-  let routing: { tier: string; modelDowngraded: boolean } | null = null;
-
-  if (modelConfig) {
-    const availableModels = ctx.modelRegistry.getAvailable();
-
-    // ─── Dynamic Model Routing ─────────────────────────────────────────
-    const routingConfig = resolveDynamicRoutingConfig();
-    let effectiveModelConfig = modelConfig;
-    let routingTierLabel = "";
-
-    if (routingConfig.enabled) {
-      let budgetPct: number | undefined;
-      if (routingConfig.budget_pressure !== false) {
-        const budgetCeiling = prefs?.budget_ceiling;
-        if (budgetCeiling !== undefined && budgetCeiling > 0) {
-          const currentLedger = getLedger();
-          const totalCost = currentLedger ? getProjectTotals(currentLedger.units).cost : 0;
-          budgetPct = totalCost / budgetCeiling;
-        }
-      }
-
-      const isHook = unitType.startsWith("hook/");
-      const shouldClassify = !isHook || routingConfig.hooks !== false;
-
-      if (shouldClassify) {
-        const classification = classifyUnitComplexity(unitType, unitId, basePath, budgetPct);
-        const availableModelIds = availableModels.map(m => m.id);
-        const routingResult = resolveModelForComplexity(classification, modelConfig, routingConfig, availableModelIds);
-
-        if (routingResult.wasDowngraded) {
-          effectiveModelConfig = {
-            primary: routingResult.modelId,
-            fallbacks: routingResult.fallbacks,
-          };
-          if (verbose) {
-            ctx.ui.notify(
-              `Dynamic routing [${tierLabel(classification.tier)}]: ${routingResult.modelId} (${classification.reason})`,
-              "info",
-            );
-          }
-        }
-        routingTierLabel = ` [${tierLabel(classification.tier)}]`;
-        routing = { tier: classification.tier, modelDowngraded: routingResult.wasDowngraded };
-      }
-    }
-
-    const modelsToTry = [effectiveModelConfig.primary, ...effectiveModelConfig.fallbacks];
-
-    for (const modelId of modelsToTry) {
-      const model = resolveModelId(modelId, availableModels, ctx.model?.provider);
-
-      if (!model) {
-        if (verbose) ctx.ui.notify(`Model ${modelId} not found, trying fallback.`, "info");
-        continue;
-      }
-
-      // Warn if the ID is ambiguous across providers
-      if (!modelId.includes("/")) {
-        const providers = availableModels.filter(m => m.id === modelId).map(m => m.provider);
-        if (providers.length > 1 && model.provider !== ctx.model?.provider) {
-          ctx.ui.notify(
-            `Model ID "${modelId}" exists in multiple providers (${providers.join(", ")}). ` +
-            `Resolved to ${model.provider}. Use "provider/model" format for explicit targeting.`,
-            "warning",
-          );
-        }
-      }
-
-      const ok = await pi.setModel(model, { persist: false });
-      if (ok) {
-        const fallbackNote = modelId === effectiveModelConfig.primary
-          ? ""
-          : ` (fallback from ${effectiveModelConfig.primary})`;
-        const phase = unitPhaseLabel(unitType);
-        ctx.ui.notify(`Model [${phase}]${routingTierLabel}: ${model.provider}/${model.id}${fallbackNote}`, "info");
-        break;
-      } else {
-        const nextModel = modelsToTry[modelsToTry.indexOf(modelId) + 1];
-        if (nextModel) {
-          if (verbose) ctx.ui.notify(`Failed to set model ${modelId}, trying ${nextModel}...`, "info");
-        } else {
-          ctx.ui.notify(`All preferred models unavailable for ${unitType}. Using default.`, "warning");
-        }
-      }
-    }
-  } else if (autoModeStartModel) {
-    // No model preference for this unit type — re-apply the model captured
-    // at auto-mode start to prevent bleed from shared global settings.json (#650).
-    const availableModels = ctx.modelRegistry.getAvailable();
-    const startModel = availableModels.find(
-      m => m.provider === autoModeStartModel.provider && m.id === autoModeStartModel.id,
-    );
-    if (startModel) {
-      const ok = await pi.setModel(startModel, { persist: false });
-      if (!ok) {
-        const byId = availableModels.find(m => m.id === autoModeStartModel.id);
-        if (byId) await pi.setModel(byId, { persist: false });
-      }
-    }
-  }
-
-  return { routing };
-}
-
-/**
- * Resolve a model ID string to a model object from the available models list.
- * Handles formats: "provider/model", "bare-id", "org/model-name" (OpenRouter).
- */
-function resolveModelId<T extends { id: string; provider: string }>(
-  modelId: string,
-  availableModels: T[],
-  currentProvider: string | undefined,
-): T | undefined {
-  const slashIdx = modelId.indexOf("/");
-
-  if (slashIdx !== -1) {
-    const maybeProvider = modelId.substring(0, slashIdx);
-    const id = modelId.substring(slashIdx + 1);
-
-    const knownProviders = new Set(availableModels.map(m => m.provider.toLowerCase()));
-    if (knownProviders.has(maybeProvider.toLowerCase())) {
-      const match = availableModels.find(
-        m => m.provider.toLowerCase() === maybeProvider.toLowerCase()
-          && m.id.toLowerCase() === id.toLowerCase(),
-      );
-      if (match) return match;
-    }
-
-    // Try matching the full string as a model ID (OpenRouter-style)
-    const lower = modelId.toLowerCase();
-    return availableModels.find(
-      m => m.id.toLowerCase() === lower
-        || `${m.provider}/${m.id}`.toLowerCase() === lower,
-    );
-  }
-
-  // Bare ID — prefer current provider, then first available
-  const exactProviderMatch = availableModels.find(
-    m => m.id === modelId && m.provider === currentProvider,
-  );
-  return exactProviderMatch ?? availableModels.find(m => m.id === modelId);
-}

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

@@ -1,72 +0,0 @@
-/**
- * Pre-dispatch observability checks for auto-mode units.
- * Validates plan/summary file quality and builds repair instructions
- * for the agent to fix gaps before proceeding with the unit.
- */
-
-import type { ExtensionContext } from "@gsd/pi-coding-agent";
-import {
-  validatePlanBoundary,
-  validateExecuteBoundary,
-  validateCompleteBoundary,
-  formatValidationIssues,
-} from "./observability-validator.js";
-import type { ValidationIssue } from "./observability-validator.js";
-import { parseUnitId } from "./unit-id.js";
-
-export async function collectObservabilityWarnings(
-  ctx: ExtensionContext,
-  basePath: string,
-  unitType: string,
-  unitId: string,
-): Promise<ValidationIssue[]> {
-  // Hook units have custom artifacts — skip standard observability checks
-  if (unitType.startsWith("hook/")) return [];
-
-  const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
-
-  if (!mid || !sid) return [];
-
-  let issues = [] as Awaited<ReturnType<typeof validatePlanBoundary>>;
-
-  if (unitType === "plan-slice") {
-    issues = await validatePlanBoundary(basePath, mid, sid);
-  } else if (unitType === "execute-task" && tid) {
-    issues = await validateExecuteBoundary(basePath, mid, sid, tid);
-  } else if (unitType === "complete-slice") {
-    issues = await validateCompleteBoundary(basePath, mid, sid);
-  }
-
-  if (issues.length > 0) {
-    ctx.ui.notify(
-      `Observability check (${unitType}) found ${issues.length} warning${issues.length === 1 ? "" : "s"}:\n${formatValidationIssues(issues)}`,
-      "warning",
-    );
-  }
-
-  return issues;
-}
-
-export function buildObservabilityRepairBlock(issues: ValidationIssue[]): string {
-  if (issues.length === 0) return "";
-  const items = issues.map(issue => {
-    const fileName = issue.file.split("/").pop() || issue.file;
-    let line = `- **${fileName}**: ${issue.message}`;
-    if (issue.suggestion) line += ` → ${issue.suggestion}`;
-    return line;
-  });
-  return [
-    "",
-    "---",
-    "",
-    "## Pre-flight: Observability gaps to fix FIRST",
-    "",
-    "The following issues were detected in plan/summary files for this unit.",
-    "**Read each flagged file, apply the fix described, then proceed with the unit.**",
-    "",
-    ...items,
-    "",
-    "---",
-    "",
-  ].join("\n");
-}