gsd-pi 2.76.0 → 2.77.0-dev.538325aea

package/dist/resources/extensions/gsd/hook-emitter.js

@@ -0,0 +1,108 @@
+// GSD Extension — Layer 2 Event Emitter Bridge
+//
+// Holds a module-scoped reference to the ExtensionAPI so deeply-nested code
+// (auto-loop, git-service callers, verification, budget) can emit Layer 2
+// events without having to thread `pi` through every function signature.
+//
+// Set once from `registerGsdExtension`. All emitters are best-effort — a
+// missing `pi` (e.g. in standalone unit tests) silently becomes a no-op.
+let _pi;
+export function setHookEmitter(pi) {
+    _pi = pi;
+}
+export function clearHookEmitter() {
+    _pi = undefined;
+}
+// ─── Notification ──────────────────────────────────────────────────────────
+export async function emitNotification(kind, message, details) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "notification", kind, message, details });
+}
+// ─── Git Lifecycle ─────────────────────────────────────────────────────────
+export async function emitBeforeCommit(args) {
+    if (!_pi)
+        return undefined;
+    return (await _pi.emitExtensionEvent({
+        type: "before_commit",
+        ...args,
+    }));
+}
+export async function emitCommit(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "commit", ...args });
+}
+export async function emitBeforePush(args) {
+    if (!_pi)
+        return undefined;
+    return (await _pi.emitExtensionEvent({
+        type: "before_push",
+        ...args,
+    }));
+}
+export async function emitPush(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "push", ...args });
+}
+export async function emitBeforePr(args) {
+    if (!_pi)
+        return undefined;
+    return (await _pi.emitExtensionEvent({
+        type: "before_pr",
+        ...args,
+    }));
+}
+export async function emitPrOpened(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "pr_opened", ...args });
+}
+// ─── Verification ──────────────────────────────────────────────────────────
+export async function emitBeforeVerify(args) {
+    if (!_pi)
+        return undefined;
+    return (await _pi.emitExtensionEvent({
+        type: "before_verify",
+        ...args,
+    }));
+}
+export async function emitVerifyResult(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "verify_result", ...args });
+}
+// ─── Budget ────────────────────────────────────────────────────────────────
+export async function emitBudgetThreshold(args) {
+    if (!_pi)
+        return undefined;
+    return (await _pi.emitExtensionEvent({
+        type: "budget_threshold",
+        fraction: args.fraction,
+        spent: args.spent,
+        limit: args.limit,
+        currency: "USD",
+    }));
+}
+// ─── Orchestrator Boundaries ───────────────────────────────────────────────
+export async function emitMilestoneStart(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "milestone_start", ...args });
+}
+export async function emitMilestoneEnd(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "milestone_end", ...args });
+}
+export async function emitUnitStart(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "unit_start", ...args });
+}
+export async function emitUnitEnd(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "unit_end", ...args });
+}

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/key-manager.js

@@ -12,6 +12,12 @@ import { getErrorMessage } from "./error-utils.js";
 export const PROVIDER_REGISTRY = [
     // LLM Providers
     { id: "anthropic", label: "Anthropic (Claude)", category: "llm", envVar: "ANTHROPIC_API_KEY", prefixes: ["sk-ant-"], hasOAuth: true, dashboardUrl: "console.anthropic.com" },
+    // Claude Code CLI: routes through the local `claude` binary — no API key,
+    // authentication is handled by the CLI's own OAuth flow.
+    // Referenced by doctor-providers.ts, auto-model-selection.ts, and others;
+    // must be in the canonical registry so all consumers see the same catalog.
+    // See: https://github.com/gsd-build/gsd-2/issues/4541
+    { id: "claude-code", label: "Claude Code CLI", category: "llm", hasOAuth: true },
     { id: "openai", label: "OpenAI", category: "llm", envVar: "OPENAI_API_KEY", prefixes: ["sk-"], dashboardUrl: "platform.openai.com/api-keys" },
     { id: "github-copilot", label: "GitHub Copilot", category: "llm", envVar: "GITHUB_TOKEN", hasOAuth: true },
     { id: "openai-codex", label: "ChatGPT Plus/Pro (Codex)", category: "llm", hasOAuth: true },
@@ -22,6 +28,8 @@ export const PROVIDER_REGISTRY = [
     { id: "xai", label: "xAI (Grok)", category: "llm", envVar: "XAI_API_KEY", dashboardUrl: "console.x.ai" },
     { id: "openrouter", label: "OpenRouter", category: "llm", envVar: "OPENROUTER_API_KEY", dashboardUrl: "openrouter.ai/keys" },
     { id: "mistral", label: "Mistral", category: "llm", envVar: "MISTRAL_API_KEY", dashboardUrl: "console.mistral.ai" },
+    { id: "minimax", label: "MiniMax", category: "llm", envVar: "MINIMAX_API_KEY", dashboardUrl: "platform.minimax.io" },
+    { id: "minimax-cn", label: "MiniMax CN", category: "llm", envVar: "MINIMAX_CN_API_KEY", dashboardUrl: "platform.minimax.io" },
     { id: "ollama-cloud", label: "Ollama Cloud", category: "llm", envVar: "OLLAMA_API_KEY" },
     { id: "custom-openai", label: "Custom (OpenAI-compat)", category: "llm", envVar: "CUSTOM_OPENAI_API_KEY" },
     { id: "cerebras", label: "Cerebras", category: "llm", envVar: "CEREBRAS_API_KEY" },
@@ -387,6 +395,26 @@ const TEST_ENDPOINTS = {
         url: "https://api.mistral.ai/v1/models",
         headers: (key) => ({ Authorization: `Bearer ${key}` }),
     },
+    minimax: {
+        url: "https://api.minimax.io/anthropic/v1/messages",
+        method: "POST",
+        headers: (key) => ({
+            "x-api-key": key,
+            "anthropic-version": "2023-06-01",
+            "content-type": "application/json",
+        }),
+        body: JSON.stringify({ model: "MiniMax-M2.7", max_tokens: 1, messages: [{ role: "user", content: "hi" }] }),
+    },
+    "minimax-cn": {
+        url: "https://api.minimaxi.com/anthropic/v1/messages",
+        method: "POST",
+        headers: (key) => ({
+            "x-api-key": key,
+            "anthropic-version": "2023-06-01",
+            "content-type": "application/json",
+        }),
+        body: JSON.stringify({ model: "MiniMax-M2.7", max_tokens: 1, messages: [{ role: "user", content: "hi" }] }),
+    },
     openrouter: {
         url: "https://openrouter.ai/api/v1/models",
         headers: (key) => ({ Authorization: `Bearer ${key}` }),

package/dist/resources/extensions/gsd/memory-backfill.js

@@ -0,0 +1,126 @@
+// GSD2 — Decisions -> memories backfill (ADR-013 step 5)
+//
+// Idempotent one-shot migration that copies every active decisions row into
+// the memories table with category="architecture" and a structured_fields
+// payload preserving the original gsd_save_decision schema (when_context,
+// scope, decision, choice, rationale, made_by, revisable, sourceDecisionId).
+//
+// The backfill exists so the cutover in ADR-013 step 6 can drop the
+// decisions table without losing schema fidelity. Idempotency is enforced
+// by tagging each backfilled memory with structured_fields.sourceDecisionId
+// and skipping any decision whose ID already appears in the memories table.
+//
+// Triggered opportunistically by buildBeforeAgentStartResult so the cost
+// only ever fires once per project. Costs O(N) inserts on first run where
+// N is the active-decisions count; subsequent runs are an O(N) lookup that
+// finds existing markers and exits.
+import { isDbAvailable, _getAdapter } from "./gsd-db.js";
+import { createMemory } from "./memory-store.js";
+import { logWarning } from "./workflow-logger.js";
+/**
+ * Backfill active decisions rows into the memories table.
+ *
+ * - Idempotent (per-row): every row written carries
+ *   `structured_fields.sourceDecisionId = "<decisionId>"`. Each candidate
+ *   decision is checked individually; only decisions whose id is already
+ *   present in the memory store are skipped. A user-authored memory with
+ *   their own `sourceDecisionId` does NOT abort the backfill.
+ * - Best-effort: never throws. Logs and returns 0 on failure so a broken
+ *   backfill cannot block agent startup.
+ * - Active-only: skips rows where `superseded_by IS NOT NULL`. Superseded
+ *   decisions are historical record; the memory store is for active
+ *   knowledge.
+ *
+ * Returns the number of memories written (0 when already backfilled or
+ * when the DB has no decisions). Callers can log the result or surface it
+ * to the user.
+ */
+export function backfillDecisionsToMemories() {
+    if (!isDbAvailable())
+        return 0;
+    const adapter = _getAdapter();
+    if (!adapter)
+        return 0;
+    try {
+        const decisions = adapter
+            .prepare("SELECT id, when_context, scope, decision, choice, rationale, made_by, revisable, superseded_by FROM decisions WHERE superseded_by IS NULL")
+            .all();
+        if (decisions.length === 0)
+            return 0;
+        // Per-row idempotency: each memory backfilled from a decision carries
+        // structured_fields.sourceDecisionId="<decisionId>". Skipping is decided
+        // per row by matching that exact id, NOT by a global sentinel — a global
+        // sentinel would silently abort the backfill if a user manually called
+        // capture_thought with their own structuredFields.sourceDecisionId.
+        const checkExisting = adapter.prepare("SELECT 1 FROM memories WHERE structured_fields LIKE :pattern LIMIT 1");
+        let written = 0;
+        for (const raw of decisions) {
+            const row = {
+                id: String(raw["id"] ?? ""),
+                when_context: String(raw["when_context"] ?? ""),
+                scope: String(raw["scope"] ?? ""),
+                decision: String(raw["decision"] ?? ""),
+                choice: String(raw["choice"] ?? ""),
+                rationale: String(raw["rationale"] ?? ""),
+                made_by: String(raw["made_by"] ?? "agent"),
+                revisable: String(raw["revisable"] ?? ""),
+                superseded_by: raw["superseded_by"] == null ? null : String(raw["superseded_by"]),
+            };
+            if (!row.id)
+                continue;
+            // Pattern is anchored to the JSON-stringified shape and the exact
+            // decision id to avoid prefix collisions (e.g. "D1" vs "D10").
+            if (checkExisting.get({ ":pattern": `%"sourceDecisionId":"${row.id}"%` }))
+                continue;
+            const content = synthesizeContent(row);
+            const id = createMemory({
+                category: "architecture",
+                content,
+                scope: row.scope || "project",
+                confidence: 0.85,
+                structuredFields: {
+                    sourceDecisionId: row.id,
+                    when_context: row.when_context,
+                    scope: row.scope,
+                    decision: row.decision,
+                    choice: row.choice,
+                    rationale: row.rationale,
+                    made_by: row.made_by,
+                    revisable: row.revisable,
+                },
+            });
+            if (id)
+                written += 1;
+        }
+        return written;
+    }
+    catch (e) {
+        logWarning("memory-backfill", `decisions->memories backfill failed: ${e.message}`);
+        return 0;
+    }
+}
+/**
+ * Combine the decision's structured fields into a 1-3 sentence content
+ * string suitable for keyword retrieval and human review.
+ *
+ * Format: "<decision> Chose: <choice>. Rationale: <rationale>."
+ * Truncates each field to keep the synthesized line under ~600 chars so
+ * memory_query rendering stays readable.
+ */
+function synthesizeContent(row) {
+    const trim = (value, max) => {
+        const cleaned = value.replace(/\s+/g, " ").trim();
+        return cleaned.length > max ? cleaned.slice(0, max - 1) + "\u2026" : cleaned;
+    };
+    const parts = [];
+    const decision = trim(row.decision, 240);
+    const choice = trim(row.choice, 200);
+    const rationale = trim(row.rationale, 200);
+    if (decision)
+        parts.push(decision);
+    if (choice)
+        parts.push(`Chose: ${choice}.`);
+    if (rationale)
+        parts.push(`Rationale: ${rationale}.`);
+    return parts.join(" ");
+}

package/dist/resources/extensions/gsd/memory-store.js

@@ -29,8 +29,22 @@ function rowToMemory(row) {
         hit_count: row['hit_count'],
         scope: row['scope'] ?? 'project',
         tags: parseTags(row['tags']),
+        structured_fields: parseStructuredFields(row['structured_fields']),
     };
 }
+function parseStructuredFields(raw) {
+    if (typeof raw !== 'string' || raw.length === 0)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
 function parseTags(raw) {
     if (typeof raw !== 'string' || raw.length === 0)
         return [];
@@ -376,6 +390,7 @@ export function createMemory(fields) {
             updatedAt: now,
             scope: fields.scope ?? 'project',
             tags: fields.tags ?? [],
+            structuredFields: fields.structuredFields ?? null,
         });
         // Derive the real ID from the assigned seq (SELECT is still fine via adapter)
         const row = adapter.prepare('SELECT seq FROM memories WHERE id = :id').get({ ':id': placeholder });
@@ -553,6 +568,10 @@ export function applyMemoryActions(actions, unitType, unitId) {
                             source_unit_id: unitId,
                             scope: action.scope,
                             tags: action.tags,
+                            // ADR-013: forward structured payload through the action layer so
+                            // bulk applyMemoryActions callers (extraction, ingestion) don't
+                            // silently drop it.
+                            structuredFields: action.structuredFields ?? null,
                         });
                         break;
                     case 'UPDATE':

package/dist/resources/extensions/gsd/model-router.js

@@ -440,6 +440,20 @@ function getModelCost(modelId) {
 function bareModelId(modelId) {
     return modelId.includes("/") ? modelId.split("/").pop() : modelId;
 }
+// ─── Provider-specific Tool Limits ─────────────────────────────────────────
+/**
+ * Groq enforces a hard limit of 128 tools per request.
+ * Requests exceeding this limit receive a 400 error:
+ * "maximum number of items is 128"
+ * @see https://console.groq.com/docs/tool-use
+ */
+export const GROQ_MAX_TOOLS = 128;
+/**
+ * Provider IDs that map to the Groq API backend.
+ * Used to detect Groq at the GSD routing layer where only the provider string
+ * is available (the pi-ai openai-completions adapter is shared across providers).
+ */
+const GROQ_PROVIDER_IDS = new Set(["groq"]);
 // ─── Tool Compatibility Filter (ADR-005 Phase 3) ───────────────────────────
 /**
  * Check if a tool is compatible with a provider's capabilities.
@@ -461,8 +475,14 @@ export function isToolCompatibleWithProvider(toolName, providerCaps) {
 /**
  * Filter a list of tool names to only those compatible with a provider.
  * Used by the routing pipeline to adjust tool sets when switching providers.
+ *
+ * @param toolNames - The full list of active tool names to filter.
+ * @param providerApi - The pi-ai API string (e.g. "openai-completions").
+ * @param provider - Optional provider ID (e.g. "groq"). Used to apply
+ *   provider-specific limits that can't be expressed as API-level capabilities
+ *   (e.g. Groq's 128-tool hard limit on the shared openai-completions adapter).
  */
-export function filterToolsForProvider(toolNames, providerApi) {
+export function filterToolsForProvider(toolNames, providerApi, provider) {
     const providerCaps = getProviderCapabilities(providerApi);
     // Provider doesn't support tool calling at all
     if (!providerCaps.toolCalling) {
@@ -478,6 +498,14 @@ export function filterToolsForProvider(toolNames, providerApi) {
             filtered.push(name);
         }
     }
+    // Groq enforces a hard limit of 128 tools per request (#4376).
+    // Trim the compatible list to GROQ_MAX_TOOLS and move the excess to filtered.
+    if (provider && GROQ_PROVIDER_IDS.has(provider) && compatible.length > GROQ_MAX_TOOLS) {
+        const trimmed = compatible.splice(GROQ_MAX_TOOLS);
+        filtered.push(...trimmed);
+        console.warn(`[gsd] Groq tool limit: ${compatible.length + trimmed.length} tools active but Groq allows at most ${GROQ_MAX_TOOLS}. ` +
+            `Trimming to the first ${GROQ_MAX_TOOLS} tools. Removed: ${trimmed.join(", ")}`);
+    }
     return { compatible, filtered };
 }
 /**
@@ -486,8 +514,13 @@ export function filterToolsForProvider(toolNames, providerApi) {
  *
  * This is a hard filter only — it removes tools that would fail at the
  * provider level. It does NOT remove tools based on soft heuristics.
+ *
+ * @param activeToolNames - The full list of currently active tool names.
+ * @param selectedModelApi - The pi-ai API string for the selected model.
+ * @param provider - Optional provider ID (e.g. "groq") for provider-specific
+ *   limits beyond what the API-level capability profile expresses.
  */
-export function adjustToolSet(activeToolNames, selectedModelApi) {
-    const { compatible, filtered } = filterToolsForProvider(activeToolNames, selectedModelApi);
+export function adjustToolSet(activeToolNames, selectedModelApi, provider) {
+    const { compatible, filtered } = filterToolsForProvider(activeToolNames, selectedModelApi, provider);
     return { toolNames: compatible, removedTools: filtered };
 }

package/dist/resources/extensions/gsd/pre-execution-checks.js

@@ -68,8 +68,13 @@ export function extractPackageReferences(description) {
             }
         }
     }
-    // require('pkg') or import from 'pkg' in code blocks
-    const importPattern = /(?:require\s*\(\s*['"]|from\s+['"])([a-zA-Z0-9@/_-]+)['"\)]/g;
+    // require('pkg') or `import ... from 'pkg'` in code blocks.
+    // The `from\s+['"]` branch MUST be preceded by an `import` keyword so that
+    // natural-language prose like `from "What's Next"` or `from 'master'` does
+    // not produce false package-existence failures.  Requiring the leading import
+    // keyword anchors the match to JavaScript/TypeScript syntax.
+    // See: https://github.com/gsd-build/gsd-2/issues/4388
+    const importPattern = /(?:require\s*\(\s*['"]|import\b[\s\S]*?\bfrom\s+['"])([a-zA-Z0-9@/_-]+)['"\)]/g;
     let importMatch;
     while ((importMatch = importPattern.exec(description)) !== null) {
         // Skip relative imports and node builtins
@@ -276,9 +281,23 @@ function extractPathFromAnnotation(raw) {
     if (backtickMatch) {
         return backtickMatch[2].trim();
     }
+    // Strip leading/trailing double or single quotes wrapping the whole value.
+    // Plan documents sometimes emit `"src/foo.ts"` or `'src/bar.ts'` as input
+    // annotations. Stripping the wrapper allows the inner path to be checked
+    // correctly instead of producing a false-positive "file not found" error
+    // for a literal string with quote characters in it (#3747).
+    const quoteMatch = trimmed.match(/^(["'])([^"']+)\1$/);
+    if (quoteMatch) {
+        return quoteMatch[2].trim();
+    }
     const annotatedMatch = trimmed.match(/^(.+?)\s+[—–-]\s+.+$/);
     if (annotatedMatch) {
-        return annotatedMatch[1].trim();
+        const prefix = annotatedMatch[1].trim();
+        const prefixBacktickMatch = prefix.match(/`([^`]+)`/);
+        if (prefixBacktickMatch && looksLikePathOrUrl(prefixBacktickMatch[1].trim())) {
+            return prefixBacktickMatch[1].trim();
+        }
+        return prefix.replace(/`/g, "").trim();
     }
     // Fallback: scan all backticked tokens and return the first one that looks
     // like a path or URL. Handles prose-annotated bullets such as:
@@ -333,13 +352,19 @@ function containsGlobPattern(candidate) {
 }
 /**
  * Build a set of files that will be created by tasks up to (but not including) taskIndex.
+ * Also includes outputs of completed tasks at any position — a completed task has already
+ * run and its outputs are available regardless of sequence position or disk state (#4071).
  * All paths are normalized for consistent comparison.
  */
 function getExpectedOutputsUpTo(tasks, taskIndex) {
     const outputs = new Set();
-    for (let i = 0; i < taskIndex; i++) {
-        for (const file of tasks[i].expected_output) {
-            outputs.add(normalizeFilePath(file));
+    for (let i = 0; i < tasks.length; i++) {
+        const task = tasks[i];
+        // Include prior tasks (i < taskIndex) OR completed tasks at any position
+        if (i < taskIndex || task.status === "completed") {
+            for (const file of task.expected_output) {
+                outputs.add(normalizeFilePath(file));
+            }
         }
     }
     return outputs;
@@ -416,8 +441,14 @@ export function checkTaskOrdering(tasks, basePath) {
         const task = tasks[i];
         for (const file of task.expected_output) {
             const normalizedFile = normalizeFilePath(file);
-            if (!fileCreators.has(normalizedFile)) {
-                fileCreators.set(normalizedFile, { taskId: task.id, index: i, originalPath: file });
+            const existing = fileCreators.get(normalizedFile);
+            if (!existing || (!existing.completed && task.status === "completed")) {
+                fileCreators.set(normalizedFile, {
+                    taskId: task.id,
+                    index: i,
+                    originalPath: file,
+                    completed: task.status === "completed",
+                });
             }
         }
     }
@@ -441,7 +472,11 @@ export function checkTaskOrdering(tasks, basePath) {
             const creator = fileCreators.get(normalizedFile);
             const absolutePath = resolve(basePath, normalizedFile);
             const existsOnDisk = existsSync(absolutePath);
-            if (creator && creator.index > i && !existsOnDisk) {
+            // Skip if the creating task has already completed — its output is available
+            // regardless of disk state (e.g. file was a temp artifact cleaned up after
+            // the task ran, or a replan introduced a new earlier-sequence task that
+            // reads this pre-execution output). (#4071)
+            if (creator && creator.index > i && !existsOnDisk && !creator.completed) {
                 // Task reads file that is created later — impossible ordering
                 results.push({
                     category: "file",

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

@@ -5,6 +5,14 @@
  * both the validation and runtime modules can import them without pulling
  * in filesystem or loading logic.
  */
+/**
+ * Resolve whether context-mode features (gsd_exec sandbox + compaction
+ * snapshot) should be active. Default is ON: missing config or missing
+ * `enabled` is treated as true. Only `enabled: false` disables.
+ */
+export function isContextModeEnabled(prefs) {
+    return prefs?.context_mode?.enabled !== false;
+}
 /** Default preference values for each workflow mode. */
 export const MODE_DEFAULTS = {
     solo: {
@@ -87,6 +95,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "flat_rate_providers",
     "language",
     "context_window_override",
+    "context_mode",
 ]);
 /** Canonical list of all dispatch unit types. */
 export const KNOWN_UNIT_TYPES = [

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

@@ -660,6 +660,55 @@ export function validatePreferences(preferences) {
             errors.push("context_management must be an object");
         }
     }
+    // ─── Context Mode (gsd_exec sandbox) ────────────────────────────────────
+    if (preferences.context_mode !== undefined) {
+        if (typeof preferences.context_mode === "object" && preferences.context_mode !== null) {
+            const cmode = preferences.context_mode;
+            const validCmode = {};
+            if (cmode.enabled !== undefined) {
+                if (typeof cmode.enabled === "boolean")
+                    validCmode.enabled = cmode.enabled;
+                else
+                    errors.push("context_mode.enabled must be a boolean");
+            }
+            if (cmode.exec_timeout_ms !== undefined) {
+                const t = cmode.exec_timeout_ms;
+                if (typeof t === "number" && t >= 1000 && t <= 600_000)
+                    validCmode.exec_timeout_ms = Math.floor(t);
+                else
+                    errors.push("context_mode.exec_timeout_ms must be a number between 1000 and 600000");
+            }
+            if (cmode.exec_stdout_cap_bytes !== undefined) {
+                const b = cmode.exec_stdout_cap_bytes;
+                if (typeof b === "number" && b >= 4096 && b <= 16_777_216)
+                    validCmode.exec_stdout_cap_bytes = Math.floor(b);
+                else
+                    errors.push("context_mode.exec_stdout_cap_bytes must be a number between 4096 and 16777216");
+            }
+            if (cmode.exec_digest_chars !== undefined) {
+                const c = cmode.exec_digest_chars;
+                if (typeof c === "number" && c >= 0 && c <= 4000)
+                    validCmode.exec_digest_chars = Math.floor(c);
+                else
+                    errors.push("context_mode.exec_digest_chars must be a number between 0 and 4000");
+            }
+            if (cmode.exec_env_allowlist !== undefined) {
+                if (Array.isArray(cmode.exec_env_allowlist) &&
+                    cmode.exec_env_allowlist.every((v) => typeof v === "string" && /^[A-Z_][A-Z0-9_]*$/i.test(v))) {
+                    validCmode.exec_env_allowlist = cmode.exec_env_allowlist;
+                }
+                else {
+                    errors.push("context_mode.exec_env_allowlist must be an array of valid env var names");
+                }
+            }
+            if (Object.keys(validCmode).length > 0) {
+                validated.context_mode = validCmode;
+            }
+        }
+        else {
+            errors.push("context_mode must be an object");
+        }
+    }
     // ─── Parallel Config ────────────────────────────────────────────────────
     if (preferences.parallel && typeof preferences.parallel === "object") {
         const p = preferences.parallel;
@@ -716,6 +765,40 @@ export function validatePreferences(preferences) {
             validated.parallel = parallel;
         }
     }
+    // ─── Slice Parallel Config ───────────────────────────────────────────────
+    if (preferences.slice_parallel !== undefined) {
+        if (typeof preferences.slice_parallel === "object" && preferences.slice_parallel !== null) {
+            const sp = preferences.slice_parallel;
+            const validSp = {};
+            if (sp.enabled !== undefined) {
+                if (typeof sp.enabled === "boolean")
+                    validSp.enabled = sp.enabled;
+                else
+                    errors.push("slice_parallel.enabled must be a boolean");
+            }
+            if (sp.max_workers !== undefined) {
+                const maxWorkers = typeof sp.max_workers === "number" ? sp.max_workers : Number(sp.max_workers);
+                if (Number.isFinite(maxWorkers) && maxWorkers >= 1 && maxWorkers <= 8) {
+                    validSp.max_workers = Math.floor(maxWorkers);
+                }
+                else {
+                    errors.push("slice_parallel.max_workers must be a number between 1 and 8");
+                }
+            }
+            const knownSliceParallelKeys = new Set(["enabled", "max_workers"]);
+            for (const key of Object.keys(sp)) {
+                if (!knownSliceParallelKeys.has(key)) {
+                    warnings.push(`unknown slice_parallel key "${key}" — ignored`);
+                }
+            }
+            if (Object.keys(validSp).length > 0) {
+                validated.slice_parallel = validSp;
+            }
+        }
+        else {
+            errors.push("slice_parallel must be an object");
+        }
+    }
     // ─── Reactive Execution ─────────────────────────────────────────────────
     if (preferences.reactive_execution !== undefined) {
         if (typeof preferences.reactive_execution === "object" && preferences.reactive_execution !== null) {