gsd-pi 2.8.2 → 2.9.0

package/src/resources/extensions/browser-tools/core.d.ts

@@ -0,0 +1,205 @@
+/**
+ * Type declarations for core.js — runtime-neutral helper logic for browser-tools.
+ */
+
+export interface ActionTimeline {
+	limit: number;
+	nextId: number;
+	entries: ActionEntry[];
+}
+
+export interface ActionEntry {
+	id: number;
+	tool: string;
+	paramsSummary: string;
+	startedAt: number;
+	finishedAt: number | null;
+	status: string;
+	beforeUrl: string;
+	afterUrl: string;
+	verificationSummary?: string;
+	warningSummary?: string;
+	diffSummary?: string;
+	changed?: boolean;
+	error?: string;
+}
+
+export interface ActionPartial {
+	tool: string;
+	paramsSummary?: string;
+	startedAt?: number;
+	beforeUrl?: string;
+	afterUrl?: string;
+	verificationSummary?: string;
+	warningSummary?: string;
+	diffSummary?: string;
+	changed?: boolean;
+	error?: string;
+}
+
+export interface ActionUpdates {
+	finishedAt?: number;
+	status?: string;
+	afterUrl?: string;
+	verificationSummary?: string;
+	warningSummary?: string;
+	diffSummary?: string;
+	changed?: boolean;
+	error?: string;
+}
+
+export interface DiffResult {
+	changed: boolean;
+	changes: Array<{ type: string; before: unknown; after: unknown }>;
+	summary: string;
+}
+
+export interface Threshold {
+	op: string;
+	n: number;
+}
+
+export interface PageRegistry {
+	pages: PageEntry[];
+	activePageId: number | null;
+	nextId: number;
+}
+
+export interface PageEntry {
+	id: number;
+	page: any;
+	title: string;
+	url: string;
+	opener: number | null;
+}
+
+export interface PageListEntry {
+	id: number;
+	title: string;
+	url: string;
+	opener: number | null;
+	isActive: boolean;
+}
+
+export interface SnapshotModeConfig {
+	tags: string[];
+	roles: string[];
+	selectors: string[];
+	ariaAttributes: string[];
+	useInteractiveFilter: boolean;
+	visibleOnly?: boolean;
+	containerExpand?: boolean;
+}
+
+export interface AssertionCheckResult {
+	name: string;
+	passed: boolean;
+	actual: unknown;
+	expected: unknown;
+	selector?: string;
+	text?: string;
+}
+
+export interface AssertionEvaluation {
+	verified: boolean;
+	checks: AssertionCheckResult[];
+	summary: string;
+	agentHint: string;
+}
+
+export interface WaitValidationError {
+	error: string;
+}
+
+export interface BatchStepResult {
+	ok: boolean;
+	stopReason: string | null;
+	failedStepIndex: number | null;
+	stepResults: unknown[];
+	summary: string;
+}
+
+export interface FormattedTimeline {
+	entries: Array<{
+		id: number | null;
+		tool: string;
+		status: string;
+		durationMs: number | null;
+		beforeUrl: string;
+		afterUrl: string;
+		line: string;
+	}>;
+	retained: number;
+	totalRecorded: number;
+	bounded: boolean;
+	summary: string;
+}
+
+export interface FailureHypothesis {
+	hasFailures: boolean;
+	categories: string[];
+	summary: string;
+	signals: Array<{ category: string; source: string; detail: string }>;
+}
+
+export interface SessionSummary {
+	counts: {
+		pages: number;
+		actions: { total: number; retained: number; success: number; error: number; running: number };
+		waits: { total: number; success: number; error: number; running: number };
+		assertions: { total: number; passed: number; failed: number; running: number };
+		consoleErrors: number;
+		failedRequests: number;
+		dialogs: number;
+	};
+	activePage: { id: number | null; title: string; url: string } | null;
+	caveats: string[];
+	failureHypothesis: FailureHypothesis;
+	summary: string;
+}
+
+export function createActionTimeline(limit?: number): ActionTimeline;
+export function beginAction(timeline: ActionTimeline, partial: ActionPartial): ActionEntry;
+export function finishAction(timeline: ActionTimeline, actionId: number, updates?: ActionUpdates): ActionEntry | null;
+export function findAction(timeline: ActionTimeline, actionId: number): ActionEntry | null;
+export function toActionParamsSummary(params: unknown): string;
+export function diffCompactStates(before: unknown, after: unknown): DiffResult;
+export function includesNeedle(haystack: string, needle: string): boolean;
+export function parseThreshold(value: string | null | undefined): Threshold | null;
+export function meetsThreshold(count: number, threshold: Threshold): boolean;
+export function getEntriesSince(
+	entries: Array<{ timestamp?: number }>,
+	sinceActionId: number | undefined,
+	timeline: ActionTimeline,
+): unknown[];
+export function evaluateAssertionChecks(args: { checks: unknown[]; state: unknown }): AssertionEvaluation;
+export function validateWaitParams(params: { condition: string; value?: string; threshold?: string }): WaitValidationError | null;
+export function createRegionStableScript(selector: string): string;
+export function createPageRegistry(): PageRegistry;
+export function registryAddPage(
+	registry: PageRegistry,
+	info: { page: unknown; title?: string; url?: string; opener?: number | null },
+): PageEntry;
+export function registryRemovePage(registry: PageRegistry, pageId: number): { removed: PageEntry; newActiveId: number | null };
+export function registrySetActive(registry: PageRegistry, pageId: number): void;
+export function registryGetActive(registry: PageRegistry): PageEntry;
+export function registryGetPage(registry: PageRegistry, pageId: number): PageEntry | null;
+export function registryListPages(registry: PageRegistry): PageListEntry[];
+export function createBoundedLogPusher(maxSize: number): (array: unknown[], entry: unknown) => void;
+export function runBatchSteps(args: {
+	steps: unknown[];
+	executeStep: (step: unknown, index: number) => Promise<{ ok: boolean; [key: string]: unknown }>;
+	stopOnFailure?: boolean;
+}): Promise<BatchStepResult>;
+
+export declare const SNAPSHOT_MODES: Record<string, SnapshotModeConfig>;
+export function getSnapshotModeConfig(mode: string): SnapshotModeConfig | null;
+export function computeContentHash(text: string): string;
+export function computeStructuralSignature(tag: string, role: string, childTags: string[]): string;
+export function matchFingerprint(
+	stored: { contentHash?: string; structuralSignature?: string },
+	candidate: { contentHash?: string; structuralSignature?: string },
+): boolean;
+export function formatTimelineEntries(entries?: unknown[], options?: Record<string, unknown>): FormattedTimeline;
+export function buildFailureHypothesis(session?: Record<string, unknown>): FailureHypothesis;
+export function summarizeBrowserSession(session?: Record<string, unknown>): SessionSummary;

package/src/resources/extensions/browser-tools/index.ts

@@ -28,11 +28,11 @@ export default function (pi: ExtensionAPI) {
 		parseRef: u.parseRef, formatVersionedRef: u.formatVersionedRef, staleRefGuidance: u.staleRefGuidance,
 		beginTrackedAction: u.beginTrackedAction, finishTrackedAction: u.finishTrackedAction,
 		truncateText: u.truncateText, verificationFromChecks: u.verificationFromChecks,
-		verificationLine: u.verificationLine, collectAssertionState: u.collectAssertionState,
+		verificationLine: u.verificationLine, collectAssertionState: (p, checks, target?) => u.collectAssertionState(p, checks, captureCompactPageState, target),
 		formatAssertionText: u.formatAssertionText, formatDiffText: u.formatDiffText,
 		getUrlHash: u.getUrlHash,
 		captureClickTargetState: u.captureClickTargetState, readInputLikeValue: u.readInputLikeValue,
-		firstErrorLine: u.firstErrorLine, captureAccessibilityMarkdown: u.captureAccessibilityMarkdown,
+		firstErrorLine: u.firstErrorLine, captureAccessibilityMarkdown: (selector?) => u.captureAccessibilityMarkdown(getActiveTarget(), selector),
 		resolveAccessibilityScope: u.resolveAccessibilityScope,
 		getLivePagesSnapshot: u.createGetLivePagesSnapshot(ensureBrowser),
 		getSinceTimestamp: u.getSinceTimestamp, getConsoleEntriesSince: u.getConsoleEntriesSince,

package/src/resources/extensions/browser-tools/refs.ts

@@ -124,7 +124,7 @@ export async function buildRefSnapshot(
 					sib = sib.previousElementSibling;
 				}
 				// Check if the parent itself is a heading (unlikely but possible)
-				const parent = current.parentElement;
+				const parent: Element | null = current.parentElement;
 				if (parent && (headingTags.has(parent.tagName) || parent.getAttribute("role") === "heading")) {
 					return (parent.textContent || "").trim().replace(/\s+/g, " ").slice(0, 80);
 				}

package/src/resources/extensions/browser-tools/tools/session.ts

@@ -379,7 +379,7 @@ export function registerSessionTools(pi: ExtensionAPI, deps: ToolDeps): void {
 							console: consoleLogs.length,
 							network: networkLogs.length,
 							dialog: dialogLogs.length,
-							actions: timeline.count,
+							actions: timeline.retained,
 							pages: pages.length,
 						},
 						elapsedMs: Date.now() - startedAt,

package/src/resources/extensions/context7/index.ts

@@ -233,7 +233,7 @@ export default function (pi: ExtensionAPI) {
 		renderResult(result, { isPartial }, theme) {
 			const d = result.details as ResolveDetails | undefined;
 			if (isPartial) return new Text(theme.fg("warning", "Searching Context7..."), 0, 0);
-			if (result.isError || d?.error) {
+			if ((result as any).isError || d?.error) {
 				return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
 			}
 			let text = theme.fg("success", `${d?.resultCount ?? 0} ${d?.resultCount === 1 ? "library" : "libraries"} found`);
@@ -388,7 +388,7 @@ export default function (pi: ExtensionAPI) {
 			const d = result.details as DocsDetails | undefined;
 
 			if (isPartial) return new Text(theme.fg("warning", "Fetching documentation..."), 0, 0);
-			if (result.isError || d?.error) {
+			if ((result as any).isError || d?.error) {
 				return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
 			}
 

package/src/resources/extensions/get-secrets-from-user.ts

@@ -160,7 +160,7 @@ async function collectOneSecret(
 ): Promise<string | null> {
 	if (!ctx.hasUI) return null;
 
-	return ctx.ui.custom<string | null>((tui: any, theme: any, _kb: any, done: (r: string | null) => void) => {
+	return ctx.ui.custom((tui: any, theme: any, _kb: any, done: (r: string | null) => void) => {
 		let value = "";
 		let cachedLines: string[] | undefined;
 
@@ -286,7 +286,7 @@ export async function showSecretsSummary(
 
 	const existingSet = new Set(existingKeys);
 
-	await ctx.ui.custom<void>((tui: any, theme: Theme, _kb: any, done: () => void) => {
+	await (ctx.ui.custom as Function)((tui: any, theme: Theme, _kb: any, done: () => void) => {
 		let cachedLines: string[] | undefined;
 
 		function handleInput(_data: string) {
@@ -549,6 +549,7 @@ export default function secureEnv(pi: ExtensionAPI) {
 				return {
 					content: [{ type: "text", text: "Error: UI not available (interactive mode required for secure env collection)." }],
 					isError: true,
+					details: undefined as unknown,
 				};
 			}
 

package/src/resources/extensions/google-search/index.ts

@@ -261,7 +261,7 @@ export default function (pi: ExtensionAPI) {
 			const d = result.details as SearchDetails | undefined;
 
 			if (isPartial) return new Text(theme.fg("warning", "Searching Google..."), 0, 0);
-			if (result.isError || d?.error) {
+			if ((result as any).isError || d?.error) {
 				return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
 			}
 

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

@@ -60,10 +60,12 @@ import { readdirSync, readFileSync, existsSync, mkdirSync, writeFileSync } from
 import { execSync, execFileSync } from "node:child_process";
 import {
   autoCommitCurrentBranch,
+  captureIntegrationBranch,
   ensureSliceBranch,
   getCurrentBranch,
   getMainBranch,
   parseSliceBranch,
+  setActiveMilestoneId,
   switchToMain,
   mergeSliceToMain,
 } from "./worktree.ts";
@@ -152,6 +154,7 @@ let currentMilestoneId: string | null = null;
 
 /** Model the user had selected before auto-mode started */
 let originalModelId: string | null = null;
+let originalModelProvider: string | null = null;
 
 /** Progress-aware timeout supervision */
 let unitTimeoutHandle: ReturnType<typeof setTimeout> | null = null;
@@ -257,6 +260,11 @@ export async function stopAuto(ctx?: ExtensionContext, pi?: ExtensionAPI): Promi
     ctx?.ui.notify("Auto-mode stopped.", "info");
   }
 
+  // Sync disk state so next resume starts from accurate state
+  if (basePath) {
+    try { await rebuildState(basePath); } catch { /* non-fatal */ }
+  }
+
   resetMetrics();
   active = false;
   paused = false;
@@ -272,10 +280,11 @@ export async function stopAuto(ctx?: ExtensionContext, pi?: ExtensionAPI): Promi
   ctx?.ui.setFooter(undefined);
 
   // Restore the user's original model
-  if (pi && ctx && originalModelId) {
-    const original = ctx.modelRegistry.find("anthropic", originalModelId);
+  if (pi && ctx && originalModelId && originalModelProvider) {
+    const original = ctx.modelRegistry.find(originalModelProvider, originalModelId);
     if (original) await pi.setModel(original);
     originalModelId = null;
+    originalModelProvider = null;
   }
 
   cmdCtx = null;
@@ -354,6 +363,8 @@ export async function startAuto(
     unitDispatchCount.clear();
     // Re-initialize metrics in case ledger was lost during pause
     if (!getLedger()) initMetrics(base);
+    // Ensure milestone ID is set on git service for integration branch resolution
+    if (currentMilestoneId) setActiveMilestoneId(base, currentMilestoneId);
     ctx.ui.setStatus("gsd-auto", stepMode ? "next" : "auto");
     ctx.ui.setFooter(hideFooter);
     ctx.ui.notify(stepMode ? "Step-mode resumed." : "Auto-mode resumed.", "info");
@@ -459,6 +470,16 @@ export async function startAuto(
   currentUnit = null;
   currentMilestoneId = state.activeMilestone?.id ?? null;
   originalModelId = ctx.model?.id ?? null;
+  originalModelProvider = ctx.model?.provider ?? null;
+
+  // Capture the integration branch — records the branch the user was on when
+  // auto-mode started. Slice branches will merge back to this branch instead
+  // of the repo's default (main/master). Idempotent: only writes if not
+  // already recorded, so restarts/resumes don't overwrite.
+  if (currentMilestoneId) {
+    captureIntegrationBranch(base, currentMilestoneId);
+    setActiveMilestoneId(base, currentMilestoneId);
+  }
 
   // Initialize metrics — loads existing ledger from disk
   initMetrics(base);
@@ -994,8 +1015,13 @@ async function dispatchNextUnit(
     // Reset stuck detection for new milestone
     unitDispatchCount.clear();
     unitRecoveryCount.clear();
+    // Capture integration branch for the new milestone and update git service
+    captureIntegrationBranch(basePath, mid);
+  }
+  if (mid) {
+    currentMilestoneId = mid;
+    setActiveMilestoneId(basePath, mid);
   }
-  if (mid) currentMilestoneId = mid;
 
   if (!mid) {
     // Save final session before stopping
@@ -1008,6 +1034,14 @@ async function dispatchNextUnit(
     return;
   }
 
+  // Guard: mid/midTitle must be defined strings from this point onward.
+  // The !mid check above returns early if mid is falsy; midTitle comes from
+  // the same object so it should always be present when mid is.
+  if (!midTitle) {
+    await stopAuto(ctx, pi);
+    return;
+  }
+
   // ── General merge guard: merge completed slice branches before advancing ──
   // If we're on a gsd/MID/SID branch and that slice is done (roadmap [x]),
   // merge to main before dispatching the next unit. This handles:
@@ -1080,6 +1114,17 @@ async function dispatchNextUnit(
     }
   }
 
+  // After merge, mid/midTitle may have been re-derived and could be undefined
+  if (!mid || !midTitle) {
+    if (currentUnit) {
+      const modelId = ctx.model?.id ?? "unknown";
+      snapshotUnitMetrics(ctx, currentUnit.type, currentUnit.id, currentUnit.startedAt, modelId);
+      saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+    }
+    await stopAuto(ctx, pi);
+    return;
+  }
+
   // Determine next unit
   let unitType: string;
   let unitId: string;
@@ -1181,7 +1226,7 @@ async function dispatchNextUnit(
 
       // Research before roadmap if no research exists
       const researchFile = resolveMilestoneFile(basePath, mid, "RESEARCH");
-      const hasResearch = !!(researchFile && await loadFile(researchFile));
+      const hasResearch = !!researchFile;
 
       if (!hasResearch) {
         unitType = "research-milestone";
@@ -1198,13 +1243,13 @@ async function dispatchNextUnit(
       const sid = state.activeSlice!.id;
       const sTitle = state.activeSlice!.title;
       const researchFile = resolveSliceFile(basePath, mid, sid, "RESEARCH");
-      const hasResearch = !!(researchFile && await loadFile(researchFile));
+      const hasResearch = !!researchFile;
 
       if (!hasResearch) {
         // Skip slice research for S01 when milestone research already exists —
         // the milestone research already covers the same ground for the first slice.
         const milestoneResearchFile = resolveMilestoneFile(basePath, mid, "RESEARCH");
-        const hasMilestoneResearch = !!(milestoneResearchFile && await loadFile(milestoneResearchFile));
+        const hasMilestoneResearch = !!milestoneResearchFile;
         if (hasMilestoneResearch && sid === "S01") {
           unitType = "plan-slice";
           unitId = `${mid}/${sid}`;
@@ -1312,6 +1357,26 @@ async function dispatchNextUnit(
   }
   unitDispatchCount.set(dispatchKey, prevCount + 1);
   if (prevCount > 0) {
+    // Self-repair: if summary exists but checkbox not marked, fix it and re-derive
+    if (unitType === "execute-task") {
+      const status = await inspectExecuteTaskDurability(basePath, unitId);
+      if (status?.summaryExists && !status.taskChecked) {
+        const [mid, sid, tid] = unitId.split("/");
+        if (mid && sid && tid) {
+          const repaired = skipExecuteTask(basePath, mid, sid, tid, status, "self-repair", 0);
+          if (repaired) {
+            ctx.ui.notify(
+              `Self-repaired ${unitId}: summary existed but checkbox was unmarked. Marked [x] and advancing.`,
+              "warning",
+            );
+            unitDispatchCount.delete(dispatchKey);
+            await new Promise(r => setImmediate(r));
+            await dispatchNextUnit(ctx, pi);
+            return;
+          }
+        }
+      }
+    }
     ctx.ui.notify(
       `${unitType} ${unitId} didn't produce expected artifact. Retrying (${prevCount + 1}/${MAX_UNIT_DISPATCHES}).`,
       "warning",
@@ -1414,14 +1479,46 @@ async function dispatchNextUnit(
   // Try primary model, then fallbacks in order if setting fails
   const modelConfig = resolveModelWithFallbacksForUnit(unitType);
   if (modelConfig) {
-    const allModels = ctx.modelRegistry.getAll();
+    const availableModels = ctx.modelRegistry.getAvailable();
     const modelsToTry = [modelConfig.primary, ...modelConfig.fallbacks];
     let modelSet = false;
 
     for (const modelId of modelsToTry) {
-      const model = allModels.find(m => m.id === modelId);
+      // Support "provider/model" format for explicit provider targeting
+      const slashIdx = modelId.indexOf("/");
+      let model;
+      if (slashIdx !== -1) {
+        const provider = modelId.substring(0, slashIdx);
+        const id = modelId.substring(slashIdx + 1);
+        model = availableModels.find(
+          m => m.provider.toLowerCase() === provider.toLowerCase()
+            && m.id.toLowerCase() === id.toLowerCase(),
+        );
+      } else {
+        // For bare IDs, prefer the current session's provider, then first available match
+        const currentProvider = ctx.model?.provider;
+        const exactProviderMatch = availableModels.find(
+          m => m.id === modelId && m.provider === currentProvider,
+        );
+        const anyMatch = availableModels.find(m => m.id === modelId);
+        model = exactProviderMatch ?? anyMatch;
+
+        // Warn if the ID is ambiguous across providers
+        if (anyMatch && !exactProviderMatch) {
+          const providers = availableModels
+            .filter(m => m.id === modelId)
+            .map(m => m.provider);
+          if (providers.length > 1) {
+            ctx.ui.notify(
+              `Model ID "${modelId}" exists in multiple providers (${providers.join(", ")}). ` +
+              `Resolved to ${anyMatch.provider}. Use "provider/model" format for explicit targeting.`,
+              "warning",
+            );
+          }
+        }
+      }
       if (!model) {
-        ctx.ui.notify(`Model ${modelId} not found in registry, trying fallback.`, "warning");
+        ctx.ui.notify(`Model ${modelId} not found in available models, trying fallback.`, "warning");
         continue;
       }
 
@@ -1462,9 +1559,9 @@ async function dispatchNextUnit(
   // soft timeout; only idle/stalled tasks pause early.
   clearUnitTimeout();
   const supervisor = resolveAutoSupervisorConfig();
-  const softTimeoutMs = supervisor.soft_timeout_minutes * 60 * 1000;
-  const idleTimeoutMs = supervisor.idle_timeout_minutes * 60 * 1000;
-  const hardTimeoutMs = supervisor.hard_timeout_minutes * 60 * 1000;
+  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;
 
   wrapupWarningHandle = setTimeout(() => {
     wrapupWarningHandle = null;
@@ -2772,6 +2869,23 @@ function verifyExpectedArtifact(unitType: string, unitId: string, base: string):
   if (!absPath) return true;
   if (!existsSync(absPath)) return false;
 
+  // execute-task must also have its checkbox marked [x] in the slice plan
+  if (unitType === "execute-task") {
+    const parts = unitId.split("/");
+    const mid = parts[0];
+    const sid = parts[1];
+    const tid = parts[2];
+    if (mid && sid && tid) {
+      const planAbs = resolveSliceFile(base, mid, sid, "PLAN");
+      if (planAbs && existsSync(planAbs)) {
+        const planContent = readFileSync(planAbs, "utf-8");
+        const escapedTid = tid.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const re = new RegExp(`^- \\[[xX]\\] \\*\\*${escapedTid}:`, "m");
+        if (!re.test(planContent)) return false;
+      }
+    }
+  }
+
   // complete-slice must also produce a UAT file
   if (unitType === "complete-slice") {
     const parts = unitId.split("/");