gsd-pi 2.74.0-dev.b741afb → 2.74.0-dev.b7c5f96

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

@@ -24,6 +24,8 @@ import { writeVerificationJSON } from "./verification-evidence.js";
 import { logWarning } from "./workflow-logger.js";
 import { runPostExecutionChecks } from "./post-execution-checks.js";
 import { join } from "node:path";
+import { resolveUokFlags } from "./uok/flags.js";
+import { UokGateRunner } from "./uok/gate-runner.js";
 function isInfraVerificationFailure(stderr) {
     return /\b(ENOENT|ENOTFOUND|ETIMEDOUT|ECONNRESET|EAI_AGAIN|spawn\s+\S+\s+ENOENT|command not found)\b/i.test(stderr);
 }
@@ -43,6 +45,31 @@ function isInfraVerificationFailure(stderr) {
  */
 async function runValidateMilestonePostCheck(vctx, pauseAuto) {
     const { s, ctx, pi } = vctx;
+    const prefs = loadEffectiveGSDPreferences()?.preferences;
+    const uokFlags = resolveUokFlags(prefs);
+    const persistMilestoneValidationGate = async (outcome, failureClass, rationale, findings = "", milestoneId) => {
+        if (!uokFlags.gates || !s.currentUnit)
+            return;
+        const gateRunner = new UokGateRunner();
+        gateRunner.register({
+            id: "milestone-validation-post-check",
+            type: "verification",
+            execute: async () => ({
+                outcome,
+                failureClass,
+                rationale,
+                findings,
+            }),
+        });
+        await gateRunner.run("milestone-validation-post-check", {
+            basePath: s.basePath,
+            traceId: `validation-post-check:${s.currentUnit.id}`,
+            turnId: s.currentUnit.id,
+            milestoneId,
+            unitType: s.currentUnit.type,
+            unitId: s.currentUnit.id,
+        });
+    };
     if (!s.currentUnit)
         return "continue";
     const { milestone: mid } = parseUnitId(s.currentUnit.id);
@@ -55,17 +82,22 @@ async function runValidateMilestonePostCheck(vctx, pauseAuto) {
     if (!validationContent)
         return "continue";
     const verdict = extractVerdict(validationContent);
-    if (verdict !== "needs-remediation")
+    if (verdict !== "needs-remediation") {
+        await persistMilestoneValidationGate("pass", "none", `milestone validation verdict is ${verdict}; no remediation loop risk`, "", mid);
         return "continue";
+    }
     const incompleteSliceCount = await countIncompleteSlices(s.basePath, mid);
     // If any non-closed slices exist, the agent successfully queued remediation
     // work — proceed normally. The state machine will execute those slices and
     // re-validate per the #3596/#3670 fix.
-    if (incompleteSliceCount > 0)
+    if (incompleteSliceCount > 0) {
+        await persistMilestoneValidationGate("pass", "none", `remediation slices present (${incompleteSliceCount}); validation can continue`, "", mid);
         return "continue";
+    }
     ctx.ui.notify(`Milestone ${mid} validation returned verdict=needs-remediation but no remediation slices were added. Pausing for human review.`, "error");
     process.stderr.write(`validate-milestone: pausing — verdict=needs-remediation with no incomplete slices for ${mid}. ` +
         `The agent must call gsd_reassess_roadmap to add remediation slices before re-validation.\n`);
+    await persistMilestoneValidationGate("manual-attention", "manual-attention", "needs-remediation verdict without queued remediation slices", `No incomplete slices found for ${mid} while verdict=needs-remediation`, mid);
     await pauseAuto(ctx, pi);
     return "pause";
 }
@@ -122,6 +154,7 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
     try {
         const effectivePrefs = loadEffectiveGSDPreferences();
         const prefs = effectivePrefs?.preferences;
+        const uokFlags = resolveUokFlags(prefs);
         // Read task plan verify field
         const { milestone: mid, slice: sid, task: tid } = parseUnitId(s.currentUnit.id);
         let taskPlanVerify;
@@ -153,6 +186,35 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
                 process.stderr.write(`  [${w.severity}] ${w.name}: ${w.title}\n`);
             }
         }
+        if (uokFlags.gates) {
+            const gateRunner = new UokGateRunner();
+            gateRunner.register({
+                id: "verification-gate",
+                type: "verification",
+                execute: async () => ({
+                    outcome: result.passed ? "pass" : "fail",
+                    failureClass: result.runtimeErrors?.some((e) => e.blocking)
+                        ? "execution"
+                        : "verification",
+                    rationale: result.passed
+                        ? "verification checks passed"
+                        : "verification checks failed",
+                    findings: result.passed
+                        ? ""
+                        : formatFailureContext(result),
+                }),
+            });
+            await gateRunner.run("verification-gate", {
+                basePath: s.basePath,
+                traceId: `verification:${s.currentUnit.id}`,
+                turnId: s.currentUnit.id,
+                milestoneId: mid ?? undefined,
+                sliceId: sid ?? undefined,
+                taskId: tid ?? undefined,
+                unitType: s.currentUnit.type,
+                unitId: s.currentUnit.id,
+            });
+        }
         // Auto-fix retry preferences
         const autoFixEnabled = prefs?.verification_auto_fix !== false;
         const maxRetries = typeof prefs?.verification_max_retries === "number"
@@ -253,6 +315,42 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
                                     : "⚠";
                             process.stderr.write(`gsd-post-exec:   ${checkEmoji} [${check.category}] ${check.target}: ${check.message}\n`);
                         }
+                        if (uokFlags.gates) {
+                            const strictMode = prefs?.enhanced_verification_strict === true;
+                            const warnEscalated = postExecResult.status === "warn" && strictMode;
+                            const blockingFailure = postExecResult.status === "fail" || warnEscalated;
+                            const findings = postExecResult.checks
+                                .filter((check) => !check.passed)
+                                .map((check) => `[${check.category}] ${check.target}: ${check.message}`)
+                                .join("\n");
+                            const gateRunner = new UokGateRunner();
+                            gateRunner.register({
+                                id: "post-execution-checks",
+                                type: "artifact",
+                                execute: async () => ({
+                                    outcome: blockingFailure ? "fail" : "pass",
+                                    failureClass: postExecResult.status === "fail"
+                                        ? "artifact"
+                                        : warnEscalated
+                                            ? "policy"
+                                            : "none",
+                                    rationale: blockingFailure
+                                        ? `post-execution checks ${postExecResult.status}${warnEscalated ? " (strict)" : ""}`
+                                        : "post-execution checks passed",
+                                    findings,
+                                }),
+                            });
+                            await gateRunner.run("post-execution-checks", {
+                                basePath: s.basePath,
+                                traceId: `verification:${s.currentUnit.id}`,
+                                turnId: s.currentUnit.id,
+                                milestoneId: mid,
+                                sliceId: sid,
+                                taskId: tid,
+                                unitType: s.currentUnit.type,
+                                unitId: s.currentUnit.id,
+                            });
+                        }
                         // Check for blocking failures
                         if (postExecResult.status === "fail") {
                             postExecBlockingFailure = true;

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/auto.js

@@ -65,6 +65,8 @@ import { autoCommitUnit, postUnitPreVerification, postUnitPostVerification, } fr
 import { bootstrapAutoSession, openProjectDbIfPresent } from "./auto-start.js";
 import { initHealthWidget } from "./health-widget.js";
 import { autoLoop, resolveAgentEnd, resolveAgentEndCancelled, _resetPendingResolve, isSessionSwitchInFlight } from "./auto-loop.js";
+import { runAutoLoopWithUok } from "./uok/kernel.js";
+import { resolveUokFlags } from "./uok/flags.js";
 import { WorktreeResolver, } from "./worktree-resolver.js";
 import { reorderForCaching } from "./prompt-ordering.js";
 // ─── Session State ─────────────────────────────────────────────────────────
@@ -360,10 +362,22 @@ function clearUnitTimeout() {
 }
 /** Build snapshot metric opts. */
 function buildSnapshotOpts(_unitType, _unitId) {
+    const prefs = loadEffectiveGSDPreferences()?.preferences;
+    const uokFlags = resolveUokFlags(prefs);
     return {
         ...(s.autoStartTime > 0 ? { autoSessionKey: String(s.autoStartTime) } : {}),
         promptCharCount: s.lastPromptCharCount,
         baselineCharCount: s.lastBaselineCharCount,
+        traceId: s.currentTraceId ?? undefined,
+        turnId: s.currentTurnId ?? undefined,
+        ...(uokFlags.gitops
+            ? {
+                gitAction: uokFlags.gitopsTurnAction,
+                gitPush: uokFlags.gitopsTurnPush,
+                gitStatus: s.lastGitActionStatus ?? undefined,
+                gitError: s.lastGitActionFailure ?? undefined,
+            }
+            : {}),
         ...(s.currentUnitRouting ?? {}),
     };
 }
@@ -1165,7 +1179,13 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         writeLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown");
         logCmuxEvent(loadEffectiveGSDPreferences()?.preferences, s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", "progress");
         captureProjectRootEnv(s.originalBasePath || s.basePath);
-        await autoLoop(ctx, pi, s, buildLoopDeps());
+        await runAutoLoopWithUok({
+            ctx,
+            pi,
+            s,
+            deps: buildLoopDeps(),
+            runLegacyLoop: autoLoop,
+        });
         cleanupAfterLoopExit(ctx);
         return;
     }
@@ -1189,7 +1209,13 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     }
     logCmuxEvent(loadEffectiveGSDPreferences()?.preferences, requestedStepMode ? "Step-mode started." : "Auto-mode started.", "progress");
     // Dispatch the first unit
-    await autoLoop(ctx, pi, s, buildLoopDeps());
+    await runAutoLoopWithUok({
+        ctx,
+        pi,
+        s,
+        deps: buildLoopDeps(),
+        runLegacyLoop: autoLoop,
+    });
     cleanupAfterLoopExit(ctx);
 }
 // ─── Agent End Handler ────────────────────────────────────────────────────────

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/bootstrap/register-extension.js

@@ -1,6 +1,7 @@
 // GSD2 — Extension registration: wires all GSD tools, commands, and hooks into pi
 import { registerExitCommand } from "../exit-command.js";
 import { registerWorktreeCommand } from "../worktree-command.js";
+import { loadEcosystemExtensions } from "../ecosystem/loader.js";
 import { registerDbTools } from "./db-tools.js";
 import { registerDynamicTools } from "./dynamic-tools.js";
 import { registerJournalTools } from "./journal-tools.js";
@@ -57,6 +58,9 @@ export function registerGsdExtension(pi) {
     registerWorktreeCommand(pi);
     registerExitCommand(pi);
     installEpipeGuard();
+    // Ecosystem handlers captured by the GSDExtensionAPI wrapper for the
+    // GSD-owned `before_agent_start` dispatch step (#3338).
+    const ecosystemHandlers = [];
     pi.registerCommand("kill", {
         description: "Exit GSD immediately (no cleanup)",
         handler: async (_args, _ctx) => {
@@ -71,7 +75,12 @@ export function registerGsdExtension(pi) {
         ["journal-tools", () => registerJournalTools(pi)],
         ["query-tools", () => registerQueryTools(pi)],
         ["shortcuts", () => registerShortcuts(pi)],
-        ["hooks", () => registerHooks(pi)],
+        ["hooks", () => registerHooks(pi, ecosystemHandlers)],
+        ["ecosystem", () => {
+                void loadEcosystemExtensions(pi, ecosystemHandlers).catch((err) => {
+                    logWarning("ecosystem", `loader failed: ${err instanceof Error ? err.message : String(err)}`);
+                });
+            }],
     ];
     for (const [name, register] of nonCriticalRegistrations) {
         try {

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -1,5 +1,7 @@
 import { join } from "node:path";
 import { isToolCallEventType } from "@gsd/pi-coding-agent";
+import { updateSnapshot } from "../ecosystem/gsd-extension-api.js";
+import { getEcosystemReadyPromise } from "../ecosystem/loader.js";
 import { buildMilestoneFileName, resolveMilestonePath, resolveSliceFile, resolveSlicePath } from "../paths.js";
 import { buildBeforeAgentStartResult } from "./system-context.js";
 import { handleAgentEnd } from "./agent-end-recovery.js";
@@ -29,7 +31,7 @@ async function syncServiceTierStatus(ctx) {
     const { getEffectiveServiceTier, formatServiceTierFooterStatus } = await import("../service-tier.js");
     ctx.ui.setStatus("gsd-fast", formatServiceTierFooterStatus(getEffectiveServiceTier(), ctx.model?.id));
 }
-export function registerHooks(pi) {
+export function registerHooks(pi, ecosystemHandlers) {
     pi.on("session_start", async (_event, ctx) => {
         initNotificationStore(process.cwd());
         installNotifyInterceptor(ctx);
@@ -39,8 +41,12 @@ export function registerHooks(pi) {
         resetToolCallLoopGuard();
         resetAskUserQuestionsCache();
         await syncServiceTierStatus(ctx);
-        const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
-        prepareWorkflowMcpForProject(ctx, process.cwd());
+        // Skip MCP auto-prep when running inside an auto-worktree (see session_switch below).
+        const { isInAutoWorktree } = await import("../auto-worktree.js");
+        if (!isInAutoWorktree(process.cwd())) {
+            const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
+            prepareWorkflowMcpForProject(ctx, process.cwd());
+        }
         // Apply show_token_cost preference (#1515)
         try {
             const { loadEffectiveGSDPreferences } = await import("../preferences.js");
@@ -80,12 +86,56 @@ export function registerHooks(pi) {
         resetAskUserQuestionsCache();
         clearDiscussionFlowState();
         await syncServiceTierStatus(ctx);
-        const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
-        prepareWorkflowMcpForProject(ctx, process.cwd());
+        // Skip MCP auto-prep when running inside an auto-worktree. The worktree
+        // already has .mcp.json from createAutoWorktree, and re-running the writer
+        // post-chdir rewrites the file mid-run (non-idempotent due to cwd-relative
+        // CLI path resolution), dirtying the tree and breaking the milestone merge.
+        const { isInAutoWorktree } = await import("../auto-worktree.js");
+        if (!isInAutoWorktree(process.cwd())) {
+            const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
+            prepareWorkflowMcpForProject(ctx, process.cwd());
+        }
         loadToolApiKeys();
     });
     pi.on("before_agent_start", async (event, ctx) => {
-        return buildBeforeAgentStartResult(event, ctx);
+        // Wait for ecosystem loader to finish (no-op after first turn).
+        await getEcosystemReadyPromise();
+        // GSD's own context injection (existing behavior — unchanged).
+        const gsdResult = await buildBeforeAgentStartResult(event, ctx);
+        // Refresh the snapshot used by ecosystem getPhase()/getActiveUnit().
+        // deriveState has its own ~100ms cache so this is cheap on repeat calls.
+        try {
+            const state = await deriveState(process.cwd());
+            updateSnapshot(state);
+        }
+        catch {
+            updateSnapshot(null);
+        }
+        // Chain ecosystem handlers using pi's runner.ts chaining protocol:
+        // each handler sees the systemPrompt mutated by prior handlers.
+        let currentSystemPrompt = gsdResult?.systemPrompt ?? event.systemPrompt;
+        // `any` because pi's BeforeAgentStartEventResult.message uses an internal
+        // CustomMessage type that's not re-exported (see ecosystem/gsd-extension-api.ts).
+        let lastMessage = gsdResult?.message;
+        for (const handler of ecosystemHandlers) {
+            try {
+                const r = await handler({ ...event, systemPrompt: currentSystemPrompt }, ctx);
+                if (r?.systemPrompt !== undefined)
+                    currentSystemPrompt = r.systemPrompt;
+                if (r?.message)
+                    lastMessage = r.message;
+            }
+            catch (err) {
+                safetyLogWarning("ecosystem", `before_agent_start handler failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        // Compose result. Return undefined if nothing changed (preserves runner contract).
+        if (currentSystemPrompt === event.systemPrompt && !lastMessage)
+            return undefined;
+        return {
+            systemPrompt: currentSystemPrompt !== event.systemPrompt ? currentSystemPrompt : undefined,
+            message: lastMessage,
+        };
     });
     pi.on("agent_end", async (event, ctx) => {
         resetToolCallLoopGuard();
@@ -116,8 +166,10 @@ export function registerHooks(pi) {
         const state = await deriveState(basePath);
         if (!state.activeMilestone || !state.activeSlice || !state.activeTask)
             return;
-        if (state.phase !== "executing")
-            return;
+        // Write checkpoint for ALL phases, not just "executing" — discuss, research,
+        // and planning also carry in-memory state (user answers, gate verification)
+        // that would be lost on compaction (#4258).
+        // if (state.phase !== "executing") return;
         const sliceDir = resolveSlicePath(basePath, state.activeMilestone.id, state.activeSlice.id);
         if (!sliceDir)
             return;
@@ -240,7 +292,7 @@ export function registerHooks(pi) {
     pi.on("tool_call", async (event, ctx) => {
         if (!isAutoActive())
             return;
-        safetyRecordToolCall(event.toolName, event.input);
+        safetyRecordToolCall(event.toolCallId, event.toolName, event.input);
         // Destructive command classification (warn only, never block)
         if (isToolCallEventType("bash", event)) {
             const classification = classifyCommand(event.input.command);

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

@@ -1,6 +1,6 @@
 // GSD Extension — Unified Cache Invalidation
 //
-// Three module-scoped caches exist across the GSD extension:
+// Three module-scoped read caches exist across the GSD extension:
 //   1. State cache (state.ts)  — memoized deriveState() result
 //   2. Path cache  (paths.ts)  — directory listing results (readdirSync)
 //   3. Parse cache (files.ts)  — parsed markdown file results
@@ -8,20 +8,31 @@
 // After any file write that changes .gsd/ contents, all three must be
 // invalidated together to prevent stale reads. This module provides a
 // single function that clears all three atomically.
+//
+// NOTE: The DB `artifacts` table is NOT included here. Earlier versions
+// called clearArtifacts() as part of this bundle (#793), intending to
+// force deriveState() to re-parse from disk when files were edited
+// out-of-band. But invalidateAllCaches() fires on every post-unit pass,
+// so bundling a DESTRUCTIVE `DELETE FROM artifacts` with routine cache
+// invalidation meant every row written by saveArtifactToDb / writeAndStore
+// was wiped within seconds — leaving the milestone completed on disk but
+// the `artifacts` table empty and the agent looping on "file exists but
+// DB record missing" recovery calls. If a call site genuinely needs the
+// artifact table cleared after an out-of-band file mutation, it should
+// invoke clearArtifacts() from gsd-db.js explicitly — do not add it back
+// here.
 import { invalidateStateCache } from './state.js';
 import { clearPathCache } from './paths.js';
 import { clearParseCache } from './files.js';
-import { clearArtifacts } from './gsd-db.js';
 /**
- * Invalidate all GSD runtime caches in one call.
+ * Invalidate all GSD runtime read caches in one call.
  *
  * Call this after file writes, milestone transitions, merge reconciliation,
  * or any operation that changes .gsd/ contents on disk. Forgetting to clear
- * any single cache causes stale reads (see #431, #793).
+ * any single cache causes stale reads (see #431).
  */
 export function invalidateAllCaches() {
     invalidateStateCache();
     clearPathCache();
     clearParseCache();
-    clearArtifacts();
 }

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/handlers/ops.js

@@ -233,5 +233,10 @@ Examples:
         await handleAddTests(trimmed.replace(/^add-tests\s*/, "").trim(), ctx, pi);
         return true;
     }
+    if (trimmed === "extract-learnings" || trimmed.startsWith("extract-learnings ")) {
+        const { handleExtractLearnings } = await import("../../commands-extract-learnings.js");
+        await handleExtractLearnings(trimmed.replace(/^extract-learnings\s*/, "").trim(), ctx, pi);
+        return true;
+    }
     return false;
 }