gsd-pi 2.74.0-dev.ffbcc03 → 2.75.0-dev.063e5a3

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

@@ -14,6 +14,8 @@ import { debugLog } from "../debug-logger.js";
 import { PROJECT_FILES } from "../detection.js";
 import { MergeConflictError } from "../git-service.js";
 import { setCurrentPhase, clearCurrentPhase } from "../../shared/gsd-phase-state.js";
+import { pauseAutoForProviderError } from "../provider-error-pause.js";
+import { resumeAutoAfterProviderDelay } from "../bootstrap/provider-error-resume.js";
 import { join, basename, dirname, parse as parsePath } from "node:path";
 import { existsSync, cpSync, readdirSync } from "node:fs";
 import { logWarning, logError, _resetLogs, drainLogs, drainAndSummarize, formatForNotification, hasAnyIssues, } from "../workflow-logger.js";
@@ -32,6 +34,12 @@ import { resetEvidence } from "../safety/evidence-collector.js";
 import { createCheckpoint, cleanupCheckpoint, rollbackToCheckpoint } from "../safety/git-checkpoint.js";
 import { resolveSafetyHarnessConfig } from "../safety/safety-harness.js";
 import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForAutoUnit, } from "../workflow-mcp.js";
+// ─── Session timeout auto-resume state ────────────────────────────────────────
+let consecutiveSessionTimeouts = 0;
+const MAX_SESSION_TIMEOUT_AUTO_RESUMES = 3;
+export function resetSessionTimeoutState() {
+    consecutiveSessionTimeouts = 0;
+}
 // ─── generateMilestoneReport ──────────────────────────────────────────────────
 /**
  * Resolve the base path for milestone reports.
@@ -1105,19 +1113,54 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
             debugLog("autoLoop", { phase: "exit", reason: "provider-pause", isTransient: unitResult.errorContext.isTransient });
             return { action: "break", reason: "provider-pause" };
         }
-        // Session creation timeout (not a structural error): pause auto-mode
-        // and let the provider-error-resume timer handle recovery (#3767). This
-        // matches the provider-pause path — break out cleanly, don't hard-stop.
+        // Timeout category covers two distinct scenarios:
+        //   1. Session creation timeout (120s) — transient, auto-resume with backoff
+        //   2. Unit hard timeout (30min+) — stuck agent, pause for manual review
         // Structural errors (TypeError, is not a function) are NOT transient
         // and must hard-stop to avoid infinite retry loops.
         if (unitResult.errorContext?.isTransient &&
             unitResult.errorContext?.category === "timeout") {
-            ctx.ui.notify(`Session creation timed out for ${unitType} ${unitId}. Pausing auto-mode (recoverable).`, "warning");
-            debugLog("autoLoop", { phase: "session-timeout-pause", unitType, unitId });
+            const isSessionCreationTimeout = unitResult.errorContext.message?.includes("Session creation timed out");
+            if (isSessionCreationTimeout) {
+                consecutiveSessionTimeouts += 1;
+                const baseRetryAfterMs = 30_000;
+                const retryAfterMs = baseRetryAfterMs * 2 ** Math.max(0, consecutiveSessionTimeouts - 1);
+                const allowAutoResume = consecutiveSessionTimeouts <= MAX_SESSION_TIMEOUT_AUTO_RESUMES;
+                if (!allowAutoResume) {
+                    ctx.ui.notify(`Session creation timed out ${consecutiveSessionTimeouts} consecutive times for ${unitType} ${unitId}. Pausing for manual review.`, "warning");
+                }
+                debugLog("autoLoop", {
+                    phase: "session-timeout-pause",
+                    unitType, unitId,
+                    consecutiveSessionTimeouts,
+                    retryAfterMs,
+                    allowAutoResume,
+                });
+                const errorDetail = ` for ${unitType} ${unitId}`;
+                await pauseAutoForProviderError(ctx.ui, errorDetail, () => deps.pauseAuto(ctx, pi), {
+                    isRateLimit: false,
+                    isTransient: allowAutoResume,
+                    retryAfterMs,
+                    resume: allowAutoResume
+                        ? () => {
+                            void resumeAutoAfterProviderDelay(pi, ctx).catch((err) => {
+                                const message = err instanceof Error ? err.message : String(err);
+                                ctx.ui.notify(`Session timeout recovery failed: ${message}`, "error");
+                            });
+                        }
+                        : undefined,
+                });
+                await deps.autoCommitUnit?.(s.basePath, unitType, unitId, ctx);
+                await emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, unitResult.errorContext);
+                return { action: "break", reason: "session-timeout" };
+            }
+            // Unit hard timeout (30min+): pause without auto-resume — stuck agent
+            ctx.ui.notify(`Unit timed out for ${unitType} ${unitId} (supervision may have failed). Pausing auto-mode.`, "warning");
+            debugLog("autoLoop", { phase: "unit-hard-timeout-pause", unitType, unitId });
             await deps.pauseAuto(ctx, pi);
             await deps.autoCommitUnit?.(s.basePath, unitType, unitId, ctx);
             await emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, unitResult.errorContext);
-            return { action: "break", reason: "session-timeout" };
+            return { action: "break", reason: "unit-hard-timeout" };
         }
         // All other cancelled states (structural errors, non-transient failures): hard stop
         if (s.currentUnit) {
@@ -1136,6 +1179,8 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     // Guard: stopAuto() may have nulled s.currentUnit via s.reset() while
     // this coroutine was suspended at `await runUnit(...)` (#2939).
     if (s.currentUnit) {
+        // Reset session timeout counter — any successful unit clears the slate
+        consecutiveSessionTimeouts = 0;
         await deps.closeoutUnit(ctx, s.basePath, unitType, unitId, s.currentUnit.startedAt, deps.buildSnapshotOpts(unitType, unitId));
     }
     // ── Zero tool-call guard (#1833, #2653) ──────────────────────────

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

@@ -405,10 +405,10 @@ export function isFlatRateProvider(provider, opts) {
  */
 export function buildFlatRateContext(provider, ctx, prefs) {
     let authMode;
-    const getAuthMode = ctx?.modelRegistry?.getProviderAuthMode;
-    if (typeof getAuthMode === "function") {
+    const registry = ctx?.modelRegistry;
+    if (registry && typeof registry.getProviderAuthMode === "function") {
         try {
-            const mode = getAuthMode(provider);
+            const mode = registry.getProviderAuthMode(provider);
             if (mode === "apiKey" || mode === "oauth" || mode === "externalCli" || mode === "none") {
                 authMode = mode;
             }

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

@@ -54,6 +54,8 @@ function isSamePath(a, b) {
         return realpathSync(a) === realpathSync(b);
     }
     catch (e) {
+        if (e.code === "ENOENT")
+            return false;
         logWarning("worktree", `isSamePath failed: ${e.message}`);
         return false;
     }

package/dist/resources/extensions/gsd/bootstrap/provider-error-resume.js

@@ -1,5 +1,6 @@
 import { getAutoDashboardData, startAuto } from "../auto.js";
 import { resetTransientRetryState } from "./agent-end-recovery.js";
+import { resetSessionTimeoutState } from "../auto/phases.js";
 const defaultDeps = {
     getSnapshot: () => getAutoDashboardData(),
     startAuto,
@@ -14,10 +15,11 @@ export async function resumeAutoAfterProviderDelay(pi, ctx, deps = defaultDeps)
         ctx.ui.notify("Provider error recovery delay elapsed, but no paused auto-mode base path was available. Leaving auto-mode paused.", "warning");
         return "missing-base";
     }
-    // Reset the transient retry counter before restarting — without this,
-    // consecutiveTransientCount accumulates across pause/resume cycles and
-    // permanently locks out auto-resume after MAX_TRANSIENT_AUTO_RESUMES errors.
+    // Reset retry counters before restarting — without this, counters
+    // accumulate across pause/resume cycles and permanently lock out
+    // auto-resume after their respective MAX thresholds.
     resetTransientRetryState();
+    resetSessionTimeoutState();
     await deps.startAuto(ctx, pi, snapshot.basePath, false, { step: snapshot.stepMode });
     return "resumed";
 }

package/dist/resources/extensions/gsd/commands/catalog.js

@@ -4,7 +4,7 @@ import { join } from "node:path";
 import { loadRegistry } from "../workflow-templates.js";
 import { resolveProjectRoot } from "../worktree.js";
 const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
-export const GSD_COMMAND_DESCRIPTION = "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|queue|quick|discuss|capture|triage|dispatch|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|model|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|inspect|extensions|update|fast|mcp|rethink|codebase|notifications|ship|do|session-report|backlog|pr-branch|add-tests";
+export const GSD_COMMAND_DESCRIPTION = "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|queue|quick|discuss|capture|triage|dispatch|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|model|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|inspect|extensions|update|fast|mcp|rethink|codebase|notifications|ship|do|session-report|backlog|pr-branch|add-tests|language";
 export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "help", desc: "Categorized command reference with descriptions" },
     { cmd: "next", desc: "Explicit step mode (same as /gsd)" },
@@ -68,6 +68,7 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "backlog", desc: "Manage backlog items (add, promote, remove, list)" },
     { cmd: "pr-branch", desc: "Create clean PR branch filtering .gsd/ commits" },
     { cmd: "add-tests", desc: "Generate tests for completed slices" },
+    { cmd: "language", desc: "Set or clear the global response language (e.g. /gsd language Chinese)" },
 ];
 const NESTED_COMPLETIONS = {
     auto: [
@@ -256,6 +257,10 @@ const NESTED_COMPLETIONS = {
         { cmd: "--dry-run", desc: "Preview what would be filtered" },
         { cmd: "--name", desc: "Custom branch name" },
     ],
+    language: [
+        { cmd: "off", desc: "Clear the language preference (revert to default)" },
+        { cmd: "clear", desc: "Alias for off — clear the language preference" },
+    ],
 };
 function filterOptions(partial, options, prefix = "") {
     const normalizedPrefix = prefix ? `${prefix} ` : "";

package/dist/resources/extensions/gsd/commands/handlers/core.js

@@ -1,6 +1,6 @@
 import { computeProgressScore, formatProgressLine } from "../../progress-score.js";
 import { getGlobalGSDPreferencesPath, getProjectGSDPreferencesPath } from "../../preferences.js";
-import { ensurePreferencesFile, handlePrefs, handlePrefsMode, handlePrefsWizard } from "../../commands-prefs-wizard.js";
+import { ensurePreferencesFile, handlePrefs, handlePrefsMode, handlePrefsWizard, handleLanguage } from "../../commands-prefs-wizard.js";
 import { runEnvironmentChecks } from "../../doctor-environment.js";
 import { deriveState } from "../../state.js";
 import { handleCmux } from "../../commands-cmux.js";
@@ -339,6 +339,10 @@ export async function handleCoreCommand(trimmed, ctx, pi) {
         await handlePrefs(trimmed.replace(/^prefs\s*/, "").trim(), ctx);
         return true;
     }
+    if (trimmed === "language" || trimmed.startsWith("language ")) {
+        await handleLanguage(trimmed.replace(/^language\s*/, "").trim(), ctx);
+        return true;
+    }
     if (trimmed === "cmux" || trimmed.startsWith("cmux ")) {
         await handleCmux(trimmed.replace(/^cmux\s*/, "").trim(), ctx);
         return true;

package/dist/resources/extensions/gsd/commands-prefs-wizard.js

@@ -642,8 +642,8 @@ export async function handlePrefsWizard(ctx, scope) {
 export function yamlSafeString(val) {
     if (typeof val !== "string")
         return String(val);
-    if (/[:#{\[\]'"`,|>&*!?@%]/.test(val) || val.trim() !== val || val === "") {
-        return `"${val.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+    if (/[:#{\[\]'"`,|>&*!?@%\r\n]/.test(val) || val.trim() !== val || val === "") {
+        return `"${val.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\r/g, "\\r").replace(/\n/g, "\\n")}"`;
     }
     return val;
 }
@@ -708,7 +708,7 @@ export function serializePreferencesToFrontmatter(prefs) {
         "dynamic_routing", "uok", "token_profile", "phases", "parallel",
         "auto_visualize", "auto_report",
         "verification_commands", "verification_auto_fix", "verification_max_retries",
-        "search_provider", "context_selection",
+        "search_provider", "context_selection", "language",
     ];
     const seen = new Set();
     for (const key of orderedKeys) {
@@ -739,3 +739,50 @@ export async function ensurePreferencesFile(path, ctx, scope) {
         ctx.ui.notify(`Using existing ${scope} GSD skill preferences at ${path}`, "info");
     }
 }
+/**
+ * Handle `/gsd language [code]` — set or clear the global language preference.
+ * Without an argument, shows the current setting.
+ * Project-level override can be set by editing `.gsd/preferences.md` directly
+ * (project language overrides global when both are set).
+ */
+export async function handleLanguage(args, ctx) {
+    const path = getGlobalGSDPreferencesPath();
+    const lang = args.trim();
+    // Show current setting when called without argument
+    if (!lang) {
+        const loaded = loadGlobalGSDPreferences();
+        const current = loaded?.preferences.language;
+        if (current) {
+            ctx.ui.notify(`Current language preference: ${current}\nUse /gsd language <name> to change, or /gsd language off to clear.`, "info");
+        }
+        else {
+            ctx.ui.notify("No language preference set. Use /gsd language <name> to set one (e.g. /gsd language Chinese).", "info");
+        }
+        return;
+    }
+    // Ensure preferences file exists with the canonical template
+    await ensurePreferencesFile(path, ctx, "global");
+    // Read via the same validated path as other handlers
+    const existing = loadGlobalGSDPreferences();
+    const prefs = existing?.preferences ? { ...existing.preferences } : { version: 1 };
+    if (lang === "off" || lang === "none" || lang === "clear") {
+        delete prefs.language;
+        ctx.ui.notify("Language preference cleared. GSD will use the default language.", "info");
+    }
+    else {
+        // Validate before writing — reject values that would fail on next load
+        if (lang.length > 50 || /[\r\n]/.test(lang)) {
+            ctx.ui.notify("Language value must be 50 characters or fewer with no newlines (e.g. /gsd language Chinese).", "warning");
+            return;
+        }
+        prefs.language = lang;
+        ctx.ui.notify(`Language preference set to: ${lang}\nGSD will now respond in ${lang} across all sessions.`, "info");
+    }
+    const rawContent = existsSync(path) ? readFileSync(path, "utf-8") : `---\nversion: 1\n---\n`;
+    const frontmatter = serializePreferencesToFrontmatter(prefs);
+    const body = extractBodyAfterFrontmatter(rawContent)
+        ?? "\n# GSD Skill Preferences\n\nSee `~/.gsd/agent/extensions/gsd/docs/preferences-reference.md` for full field documentation and examples.\n";
+    await saveFile(path, `---\n${frontmatter}---${body}`);
+    await ctx.waitForIdle();
+    await ctx.reload();
+}

package/dist/resources/extensions/gsd/docs/preferences-reference.md

@@ -102,6 +102,8 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
 
 - `custom_instructions`: extra durable instructions related to skill use. For operational project knowledge (recurring rules, gotchas, patterns), use `.gsd/KNOWLEDGE.md` instead — it's injected into every agent prompt automatically and agents can append to it during execution.
 
+- `language`: preferred response language for all GSD interactions. Accepts any language name or code — `"Chinese"`, `"zh"`, `"German"`, `"de"`, `"日本語"`, etc. When set, GSD injects "Always respond in \<language\>" into every agent's system prompt, including after `/clear`. Quickest way to set it: `/gsd language <name>`. To clear: `/gsd language off`.
+
 - `models`: per-stage model selection (applies to both auto-mode and guided-flow dispatches). Keys: `research`, `planning`, `discuss`, `execution`, `execution_simple`, `completion`, `validation`, `subagent`. Values can be:
   - Simple string: `"claude-sonnet-4-6"` — single model, no fallbacks
   - Provider-qualified string: `"bedrock/claude-sonnet-4-6"` — targets a specific provider when the same model ID exists across multiple providers

package/dist/resources/extensions/gsd/guided-flow.js

@@ -212,11 +212,13 @@ export function checkAutoStartAfterDiscuss() {
         logWarning("guided", `CONTEXT-DRAFT.md unlink failed: ${e.message}`);
     }
     // Cleanup: remove discussion manifest after auto-start (only needed during discussion)
-    try {
-        unlinkSync(manifestPath);
-    }
-    catch (e) {
-        logWarning("guided", `manifest unlink failed: ${e.message}`);
+    if (existsSync(manifestPath)) {
+        try {
+            unlinkSync(manifestPath);
+        }
+        catch (e) {
+            logWarning("guided", `manifest unlink failed: ${e.message}`);
+        }
     }
     pendingAutoStartMap.delete(basePath);
     ctx.ui.notify(`Milestone ${milestoneId} ready.`, "success");

package/dist/resources/extensions/gsd/preferences-types.js

@@ -85,6 +85,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "discuss_web_research",
     "discuss_depth",
     "flat_rate_providers",
+    "language",
 ]);
 /** Canonical list of all dispatch unit types. */
 export const KNOWN_UNIT_TYPES = [

package/dist/resources/extensions/gsd/preferences-validation.js

@@ -1144,5 +1144,15 @@ export function validatePreferences(preferences) {
             errors.push(`discuss_depth must be one of: quick, standard, thorough`);
         }
     }
+    // ─── Language ────────────────────────────────────────────────────────
+    if (preferences.language !== undefined) {
+        const trimmed = typeof preferences.language === "string" ? preferences.language.trim() : undefined;
+        if (trimmed && trimmed.length <= 50 && !/[\r\n]/.test(trimmed)) {
+            validated.language = trimmed;
+        }
+        else {
+            errors.push(`language must be a non-empty string up to 50 characters with no newlines (e.g. "Chinese", "de", "日本語")`);
+        }
+    }
     return { preferences: validated, errors, warnings };
 }

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

@@ -360,6 +360,7 @@ function mergePreferences(base, override) {
         slice_parallel: (base.slice_parallel || override.slice_parallel)
             ? { ...(base.slice_parallel ?? {}), ...(override.slice_parallel ?? {}) }
             : undefined,
+        language: override.language ?? base.language,
     };
 }
 function mergeStringLists(base, override) {
@@ -454,6 +455,10 @@ export function renderPreferencesForSystemPrompt(preferences, resolutions) {
             lines.push(`  - ${instruction}`);
         }
     }
+    if (preferences.language) {
+        const safeLang = preferences.language.replace(/[\r\n]/g, " ").slice(0, 50);
+        lines.push(`- Language: Always respond in ${safeLang}.`);
+    }
     return lines.join("\n");
 }
 // ─── Hook Resolution ──────────────────────────────────────────────────────────

package/dist/resources/extensions/gsd/templates/PREFERENCES.md

@@ -89,6 +89,7 @@ remote_questions:
 uat_dispatch:
 post_unit_hooks: []
 pre_dispatch_hooks: []
+# language:
 # experimental:
 #   rtk: false
 ---