gsd-pi 2.76.0-dev.4100bd590 → 2.76.0-dev.4c866b677

package/dist/resource-loader.d.ts

@@ -21,6 +21,6 @@ export declare function getNewerManagedResourceVersion(agentDir: string, current
  *
  * Inspectable: `ls ~/.gsd/agent/extensions/`
  */
-export declare function initResources(agentDir: string): void;
+export declare function initResources(agentDir: string, skillsDir?: string): void;
 export declare function hasStaleCompiledExtensionSiblings(extensionsDir: string, sourceDir?: string): boolean;
 export declare function buildResourceLoader(agentDir: string): DefaultResourceLoader;

package/dist/resource-loader.js

@@ -506,7 +506,7 @@ function pruneRemovedBundledExtensions(manifest, agentDir) {
  *
  * Inspectable: `ls ~/.gsd/agent/extensions/`
  */
-export function initResources(agentDir) {
+export function initResources(agentDir, skillsDir = join(homedir(), '.agents', 'skills')) {
     mkdirSync(agentDir, { recursive: true });
     const currentVersion = getBundledGsdVersion();
     const manifest = readManagedResourceManifest(agentDir);
@@ -538,13 +538,7 @@ export function initResources(agentDir) {
     // Sync bundled resources — overwrite so updates land on next launch.
     syncResourceDir(bundledExtensionsDir, join(agentDir, 'extensions'));
     syncResourceDir(join(resourcesDir, 'agents'), join(agentDir, 'agents'));
-    // Skills are no longer force-synced here. Users install skills via the
-    // skills.sh CLI (`npx skills add <repo>`) into ~/.agents/skills/ which
-    // is the industry-standard Agent Skills ecosystem directory.
-    //
-    // Migration from the legacy ~/.gsd/agent/skills/ directory is handled
-    // above the manifest check so it runs on every launch (including retries
-    // after partial copy failures).
+    syncResourceDir(join(resourcesDir, 'skills'), skillsDir);
     // Sync GSD-WORKFLOW.md to agentDir as a fallback for when GSD_WORKFLOW_PATH
     // env var is not set (e.g. fork/dev builds, alternative entry points).
     const workflowSrc = join(resourcesDir, 'GSD-WORKFLOW.md');

package/dist/resources/extensions/gsd/auto/phases.js

@@ -1094,7 +1094,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         logWarning("engine", "Prompt reorder failed", { error: msg });
     }
     // Select and apply model (with tier escalation on retry — normal units only)
-    const modelResult = await deps.selectAndApplyModel(ctx, pi, unitType, unitId, s.basePath, prefs, s.verbose, s.autoModeStartModel, sidecarItem ? undefined : { isRetry, previousTier }, undefined, s.manualSessionModelOverride);
+    const modelResult = await deps.selectAndApplyModel(ctx, pi, unitType, unitId, s.basePath, prefs, s.verbose, s.autoModeStartModel, sidecarItem ? undefined : { isRetry, previousTier }, undefined, s.manualSessionModelOverride, s.autoModeStartThinkingLevel);
     s.currentUnitRouting =
         modelResult.routing;
     s.currentUnitModel =
@@ -1107,6 +1107,9 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         if (match) {
             const ok = await pi.setModel(match, { persist: false });
             if (ok) {
+                if (s.autoModeStartThinkingLevel) {
+                    pi.setThinkingLevel(s.autoModeStartThinkingLevel);
+                }
                 s.currentUnitModel = match;
                 ctx.ui.notify(`Hook model override: ${match.provider}/${match.id}`, "info");
             }

package/dist/resources/extensions/gsd/auto/session.js

@@ -65,6 +65,8 @@ export class AutoSession {
     currentDispatchedModelId = null;
     originalModelId = null;
     originalModelProvider = null;
+    autoModeStartThinkingLevel = null;
+    originalThinkingLevel = null;
     lastBudgetAlertLevel = 0;
     // ── Recovery ─────────────────────────────────────────────────────────────
     pendingCrashRecovery = null;
@@ -177,6 +179,8 @@ export class AutoSession {
         this.currentDispatchedModelId = null;
         this.originalModelId = null;
         this.originalModelProvider = null;
+        this.autoModeStartThinkingLevel = null;
+        this.originalThinkingLevel = null;
         this.lastBudgetAlertLevel = 0;
         // Recovery
         this.pendingCrashRecovery = null;

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

@@ -13,6 +13,11 @@ import { logWarning } from "./workflow-logger.js";
 import { resolveUokFlags } from "./uok/flags.js";
 import { applyModelPolicyFilter } from "./uok/model-policy.js";
 import { isModelBlocked } from "./blocked-models.js";
+function reapplyThinkingLevel(pi, level) {
+    if (!level)
+        return;
+    pi.setThinkingLevel(level);
+}
 export function resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode = true) {
     const explicitConfig = resolveModelWithFallbacksForUnit(unitType);
     if (explicitConfig) {
@@ -58,7 +63,9 @@ export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, p
  *  Dynamic routing only applies in auto-mode where cost optimization is expected. (#3962) */
 isAutoMode = true, 
 /** Explicit /gsd model pin captured at bootstrap for long-running auto loops. */
-sessionModelOverride) {
+sessionModelOverride, 
+/** Thinking level captured at auto-mode start and re-applied after model swaps. */
+autoModeStartThinkingLevel) {
     const uokFlags = resolveUokFlags(prefs);
     const effectiveSessionModelOverride = sessionModelOverride === undefined
         ? getSessionModelOverride(ctx.sessionManager.getSessionId())
@@ -280,6 +287,7 @@ sessionModelOverride) {
             const ok = await pi.setModel(model, { persist: false });
             if (ok) {
                 appliedModel = model;
+                reapplyThinkingLevel(pi, autoModeStartThinkingLevel);
                 // ADR-005: Adjust active tool set for the selected model's provider capabilities.
                 // Hard-filter incompatible tools, then let extensions override via adjust_tool_set hook.
                 const activeToolNames = pi.getActiveTools();
@@ -346,12 +354,15 @@ sessionModelOverride) {
                     const byId = availableModels.find(m => m.id === autoModeStartModel.id && !isModelBlocked(basePath, m.provider, m.id));
                     if (byId) {
                         const fallbackOk = await pi.setModel(byId, { persist: false });
-                        if (fallbackOk)
+                        if (fallbackOk) {
                             appliedModel = byId;
+                            reapplyThinkingLevel(pi, autoModeStartThinkingLevel);
+                        }
                     }
                 }
                 else {
                     appliedModel = startModel;
+                    reapplyThinkingLevel(pi, autoModeStartThinkingLevel);
                 }
             }
         }

package/dist/resources/extensions/gsd/auto-start.js

@@ -30,7 +30,7 @@ import { initRoutingHistory } from "./routing-history.js";
 import { restoreHookState, resetHookState } from "./post-unit-hooks.js";
 import { resetProactiveHealing, setLevelChangeCallback } from "./doctor-proactive.js";
 import { snapshotSkills } from "./skill-discovery.js";
-import { isDbAvailable, getMilestone, openDatabase } from "./gsd-db.js";
+import { isDbAvailable, getMilestone, openDatabase, getDbStatus } from "./gsd-db.js";
 import { hideFooter } from "./auto-dashboard.js";
 import { debugLog, enableDebug, isDebugEnabled, getDebugLogPath, } from "./debug-logger.js";
 import { logWarning, logError } from "./workflow-logger.js";
@@ -190,8 +190,8 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
     //
     // Precedence:
     // 1) Explicit session override via /gsd model (this session)
-    // 2) GSD model preferences from PREFERENCES.md (validated against live auth)
-    // 3) Current session model from settings/session restore (if provider ready)
+    // 2) Current session model from settings/session restore (if provider ready)
+    // 3) GSD model preferences from PREFERENCES.md (validated against live auth)
     //
     // This preserves #3517 defaults while honoring explicit runtime model
     // selection for subsequent /gsd runs in the same session.
@@ -224,11 +224,14 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         }
     }
     const sessionModelReady = ctx.model && ctx.modelRegistry.isProviderRequestReady(ctx.model.provider);
+    const currentSessionModel = (sessionModelReady && ctx.model)
+        ? { provider: ctx.model.provider, id: ctx.model.id }
+        : null;
+    const startThinkingSnapshot = pi.getThinkingLevel();
     const startModelSnapshot = manualSessionOverride
+        ?? currentSessionModel
         ?? validatedPreferredModel
-        ?? (sessionModelReady && ctx.model
-            ? { provider: ctx.model.provider, id: ctx.model.id }
-            : null);
+        ?? null;
     try {
         // Validate GSD_PROJECT_ID early so the user gets immediate feedback
         const customProjectId = process.env.GSD_PROJECT_ID;
@@ -506,8 +509,9 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         s.pendingQuickTasks = [];
         s.currentUnit = null;
         s.currentMilestoneId = state.activeMilestone?.id ?? null;
-        s.originalModelId = ctx.model?.id ?? null;
-        s.originalModelProvider = ctx.model?.provider ?? null;
+        s.originalModelId = startModelSnapshot?.id ?? ctx.model?.id ?? null;
+        s.originalModelProvider = startModelSnapshot?.provider ?? ctx.model?.provider ?? null;
+        s.originalThinkingLevel = startThinkingSnapshot ?? null;
         // Register SIGTERM handler
         registerSigtermHandler(base);
         // Capture integration branch
@@ -593,8 +597,21 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // call returns "db_unavailable", triggering artifact-retry which
         // re-dispatches the same task — producing an infinite loop (#2419).
         if (existsSync(gsdDbPath) && !isDbAvailable()) {
-            ctx.ui.notify("SQLite database exists but failed to open. Auto-mode cannot proceed without a working database provider. " +
-                "Check for corrupt gsd.db or missing native SQLite bindings.", "error");
+            const dbStatus = getDbStatus();
+            const phaseHint = dbStatus.lastPhase === "open"
+                ? "The database file could not be opened"
+                : dbStatus.lastPhase === "initSchema"
+                    ? "The database schema could not be initialized"
+                    : dbStatus.lastPhase === "vacuum-recovery"
+                        ? "Corruption recovery (VACUUM) failed"
+                        : dbStatus.attempted
+                            ? "The database could not be opened (phase unknown)"
+                            : "The database provider could not be loaded";
+            const errorDetail = dbStatus.lastError ? ` (${dbStatus.lastError.message})` : "";
+            const providerHint = dbStatus.provider
+                ? ` Provider: ${dbStatus.provider}.`
+                : " No SQLite provider available — check Node >= 22 or install better-sqlite3.";
+            ctx.ui.notify(`SQLite database exists but failed to open: ${gsdDbPath}. ${phaseHint}${errorDetail}.${providerHint}`, "error");
             return releaseLockAndReturn();
         }
         // Initialize metrics
@@ -608,6 +625,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 id: startModelSnapshot.id,
             };
         }
+        s.autoModeStartThinkingLevel = startThinkingSnapshot ?? null;
         s.manualSessionModelOverride = manualSessionOverride ?? null;
         // Apply worker model override from parallel orchestrator (#worker-model).
         // GSD_WORKER_MODEL is injected by the coordinator when parallel.worker_model

package/dist/resources/extensions/gsd/auto.js

@@ -695,13 +695,16 @@ export async function stopAuto(ctx, pi, reason) {
         catch (err) { /* non-fatal */
             logWarning("engine", `file unlink failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
         }
-        // ── Step 13: Restore original model (before reset clears IDs) ──
+        // ── Step 13: Restore original model + thinking (before reset clears IDs) ──
         try {
             if (pi && ctx && s.originalModelId && s.originalModelProvider) {
                 const original = ctx.modelRegistry.find(s.originalModelProvider, s.originalModelId);
                 if (original)
                     await pi.setModel(original);
             }
+            if (pi && s.originalThinkingLevel) {
+                pi.setThinkingLevel(s.originalThinkingLevel);
+            }
         }
         catch (e) {
             debugLog("stop-cleanup-model", { error: e instanceof Error ? e.message : String(e) });

package/dist/resources/extensions/gsd/complexity-classifier.js

@@ -8,10 +8,12 @@ import { getAdaptiveTierAdjustment } from "./routing-history.js";
 import { parseUnitId } from "./unit-id.js";
 // ─── Unit Type → Default Tier Mapping ────────────────────────────────────────
 const UNIT_TYPE_TIERS = {
-    // Tier 1 — Light: structured summaries, completion, UAT
-    "complete-slice": "light",
+    // Tier 1 — Light: compact verification turns
     "run-uat": "light",
-    // Tier 2 — Standard: research, routine discussion
+    // Tier 2 — Standard: research, routine discussion, slice completion
+    // complete-slice can carry large inlined context; avoid routing it to the
+    // cheapest "light" model by default (#4520).
+    "complete-slice": "standard",
     "discuss-milestone": "standard",
     "discuss-slice": "standard",
     "research-milestone": "standard",

package/dist/resources/extensions/gsd/gsd-db.js

@@ -1097,6 +1097,8 @@ let currentPath = null;
 let currentPid = 0;
 let _exitHandlerRegistered = false;
 let _dbOpenAttempted = false;
+let _lastDbError = null;
+let _lastDbPhase = null;
 export function getDbProvider() {
     loadProvider();
     return providerName;
@@ -1113,13 +1115,54 @@ export function isDbAvailable() {
 export function wasDbOpenAttempted() {
     return _dbOpenAttempted;
 }
+export function getDbStatus() {
+    loadProvider();
+    return {
+        available: currentDb !== null,
+        provider: providerName,
+        attempted: _dbOpenAttempted,
+        lastError: _lastDbError,
+        lastPhase: _lastDbPhase,
+    };
+}
 export function openDatabase(path) {
     _dbOpenAttempted = true;
     if (currentDb && currentPath !== path)
         closeDatabase();
     if (currentDb && currentPath === path)
         return true;
-    const rawDb = openRawDb(path);
+    // Reset error state only when a new open attempt is actually going to run.
+    _lastDbError = null;
+    _lastDbPhase = null;
+    let rawDb;
+    let fallbackProvider = null;
+    let fallbackModule = null;
+    try {
+        rawDb = openRawDb(path);
+    }
+    catch (primaryErr) {
+        _lastDbPhase = "open";
+        _lastDbError = primaryErr instanceof Error ? primaryErr : new Error(String(primaryErr));
+        // node:sqlite loaded but failed to open this file — try better-sqlite3 as fallback.
+        if (providerName === "node:sqlite") {
+            try {
+                const mod = _require("better-sqlite3");
+                const Db = (mod && mod.default) ? mod.default : mod;
+                if (typeof Db === "function") {
+                    rawDb = new Db(path);
+                    fallbackProvider = "better-sqlite3";
+                    fallbackModule = Db;
+                    _lastDbError = null;
+                    _lastDbPhase = null;
+                }
+            }
+            catch {
+                // fallback unavailable; surface original error
+            }
+        }
+        if (!rawDb)
+            throw primaryErr;
+    }
     if (!rawDb)
         return false;
     const adapter = createAdapter(rawDb);
@@ -1137,6 +1180,8 @@ export function openDatabase(path) {
                 process.stderr.write("gsd-db: recovered corrupt database via VACUUM\n");
             }
             catch (retryErr) {
+                _lastDbPhase = "vacuum-recovery";
+                _lastDbError = retryErr instanceof Error ? retryErr : new Error(String(retryErr));
                 try {
                     adapter.close();
                 }
@@ -1147,15 +1192,22 @@ export function openDatabase(path) {
             }
         }
         else {
+            _lastDbPhase = "initSchema";
+            _lastDbError = err instanceof Error ? err : new Error(String(err));
             try {
                 adapter.close();
             }
             catch (e) {
-                logWarning("db", `close after VACUUM failed: ${e.message}`);
+                logWarning("db", `close after initSchema failed: ${e.message}`);
             }
             throw err;
         }
     }
+    // Commit fallback provider switch only after open + schema both succeeded.
+    if (fallbackProvider) {
+        providerName = fallbackProvider;
+        providerModule = fallbackModule;
+    }
     currentDb = adapter;
     currentPath = path;
     currentPid = process.pid;
@@ -1194,8 +1246,12 @@ export function closeDatabase() {
         currentDb = null;
         currentPath = null;
         currentPid = 0;
-        _dbOpenAttempted = false;
     }
+    // Reset session-scoped state unconditionally so stale error info from a
+    // failed open doesn't persist into the next open attempt or status check.
+    _dbOpenAttempted = false;
+    _lastDbError = null;
+    _lastDbPhase = null;
 }
 /** Run a full VACUUM — call sparingly (e.g. after milestone completion). */
 export function vacuumDatabase() {

package/dist/resources/extensions/gsd/init-wizard.js

@@ -8,7 +8,7 @@
 import { existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { showNextAction } from "../shared/tui.js";
-import { nativeInit } from "./native-git-bridge.js";
+import { nativeInit, nativeAddAll, nativeCommit } from "./native-git-bridge.js";
 import { ensureGitignore, untrackRuntimeFiles } from "./gitignore.js";
 import { gsdRoot } from "./paths.js";
 import { assertSafeDirectory } from "./validate-directory.js";
@@ -40,6 +40,7 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
         ctx.ui.notify(`Project detected:\n${detectionSummary.join("\n")}`, "info");
     }
     // ── Step 2: Git setup ──────────────────────────────────────────────────────
+    let didInitGit = false;
     if (!signals.isGitRepo) {
         const gitChoice = await showNextAction(ctx, {
             title: "GSD — Project Setup",
@@ -54,6 +55,7 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
             return { completed: false, bootstrapped: false };
         if (gitChoice === "init_git") {
             nativeInit(basePath, prefs.mainBranch);
+            didInitGit = true;
         }
     }
     else {
@@ -244,6 +246,18 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
     // Ensure .gitignore
     ensureGitignore(basePath);
     untrackRuntimeFiles(basePath);
+    // Create initial commit so git log and git worktree work immediately (#4530).
+    // Without this, the branch is "unborn" (zero commits) and downstream operations
+    // like `git log` and `git worktree add` fail.
+    if (didInitGit) {
+        try {
+            nativeAddAll(basePath);
+            nativeCommit(basePath, "chore: init project");
+        }
+        catch {
+            // Non-fatal — user can commit manually; don't block project init
+        }
+    }
     // Auto-generate codebase map for instant agent orientation
     try {
         const result = generateCodebaseMap(basePath);

package/dist/resources/extensions/gsd/prompt-loader.js

@@ -22,6 +22,27 @@ import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
 import { logWarning } from "./workflow-logger.js";
+function hasRequiredExtensionAssets(rootDir, exists = existsSync) {
+    return (exists(join(rootDir, "prompts")) &&
+        exists(join(rootDir, "templates", "task-summary.md")));
+}
+export function resolveExtensionDirFromCandidates(moduleDir, agentGsdDir, exists = existsSync) {
+    const moduleUsable = hasRequiredExtensionAssets(moduleDir, exists);
+    const agentUsable = hasRequiredExtensionAssets(agentGsdDir, exists);
+    // Prefer the user-local extension tree when both are valid. This avoids
+    // leaking npm/global-install paths into prompts on Windows.
+    if (agentUsable)
+        return agentGsdDir;
+    if (moduleUsable)
+        return moduleDir;
+    // Degraded fallback: if required template is missing in both locations,
+    // keep previous behavior and prefer whichever still has prompts/.
+    if (exists(join(moduleDir, "prompts")))
+        return moduleDir;
+    if (exists(join(agentGsdDir, "prompts")))
+        return agentGsdDir;
+    return moduleDir;
+}
 /**
  * Resolve the GSD extension directory.
  *
@@ -34,15 +55,9 @@ import { logWarning } from "./workflow-logger.js";
  */
 function resolveExtensionDir() {
     const moduleDir = dirname(fileURLToPath(import.meta.url));
-    if (existsSync(join(moduleDir, "prompts")))
-        return moduleDir;
-    // Fallback: user-local agent directory
     const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
     const agentGsdDir = join(gsdHome, "agent", "extensions", "gsd");
-    if (existsSync(join(agentGsdDir, "prompts")))
-        return agentGsdDir;
-    // Last resort: return the module dir (warmCache will silently handle the miss)
-    return moduleDir;
+    return resolveExtensionDirFromCandidates(moduleDir, agentGsdDir);
 }
 const __extensionDir = resolveExtensionDir();
 const promptsDir = join(__extensionDir, "prompts");

package/dist/resources/extensions/gsd/safety/file-change-validator.js

@@ -62,7 +62,7 @@ export function validateFileChanges(basePath, expectedOutput, plannedFiles) {
 // ─── Internals ──────────────────────────────────────────────────────────────
 function getChangedFilesFromLastCommit(basePath) {
     try {
-        const result = execFileSync("git", ["diff", "--name-only", "HEAD~1", "HEAD"], { cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+        const result = execFileSync("git", ["diff-tree", "--root", "--no-commit-id", "-r", "--name-only", "HEAD"], { cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
         return result ? result.split("\n").filter(Boolean) : [];
     }
     catch (e) {