gsd-pi 2.76.0-dev.b072ebb73 → 2.76.0-dev.fe143342a

package/dist/resources/extensions/gsd/exec-history.js

@@ -0,0 +1,120 @@
+// GSD Exec History — read-side helpers for the exec sandbox.
+//
+// Pure I/O: scans `.gsd/exec/*.meta.json` under a base directory and
+// returns lightweight records. Used by the gsd_exec_search tool and
+// any future compaction-snapshot enrichment.
+import { closeSync, openSync, readdirSync, readFileSync, readSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+function listMetaFiles(baseDir) {
+    const dir = resolve(baseDir, ".gsd", "exec");
+    try {
+        return readdirSync(dir)
+            .filter((name) => name.endsWith(".meta.json"))
+            .map((name) => join(dir, name));
+    }
+    catch {
+        return [];
+    }
+}
+function safeReadMeta(path) {
+    try {
+        const raw = readFileSync(path, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.id !== "string" || typeof parsed.runtime !== "string")
+            return null;
+        return {
+            id: parsed.id,
+            runtime: parsed.runtime,
+            purpose: typeof parsed.purpose === "string" ? parsed.purpose : null,
+            started_at: typeof parsed.started_at === "string" ? parsed.started_at : "",
+            finished_at: typeof parsed.finished_at === "string" ? parsed.finished_at : "",
+            duration_ms: typeof parsed.duration_ms === "number" ? parsed.duration_ms : 0,
+            exit_code: typeof parsed.exit_code === "number" ? parsed.exit_code : null,
+            signal: typeof parsed.signal === "string" ? parsed.signal : null,
+            timed_out: parsed.timed_out === true,
+            stdout_bytes: typeof parsed.stdout_bytes === "number" ? parsed.stdout_bytes : 0,
+            stderr_bytes: typeof parsed.stderr_bytes === "number" ? parsed.stderr_bytes : 0,
+            stdout_truncated: parsed.stdout_truncated === true,
+            stderr_truncated: parsed.stderr_truncated === true,
+            stdout_path: path.replace(/\.meta\.json$/, ".stdout"),
+            stderr_path: path.replace(/\.meta\.json$/, ".stderr"),
+            meta_path: path,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function listExecHistory(baseDir) {
+    const metas = listMetaFiles(baseDir)
+        .map((path) => {
+        let mtime = 0;
+        try {
+            mtime = statSync(path).mtimeMs;
+        }
+        catch {
+            /* ignore */
+        }
+        const entry = safeReadMeta(path);
+        return entry ? { entry, mtime } : null;
+    })
+        .filter((value) => value !== null);
+    metas.sort((a, b) => b.mtime - a.mtime);
+    return metas.map((m) => m.entry);
+}
+function matchesFilters(entry, opts) {
+    if (opts.runtime && entry.runtime !== opts.runtime)
+        return false;
+    if (opts.failing_only) {
+        const failed = entry.timed_out || (entry.exit_code !== 0 && entry.exit_code !== null);
+        if (!failed)
+            return false;
+    }
+    const query = (opts.query ?? "").trim().toLowerCase();
+    if (!query)
+        return true;
+    const haystack = `${entry.id} ${entry.purpose ?? ""}`.toLowerCase();
+    return haystack.includes(query);
+}
+function readDigestPreview(entry, maxChars) {
+    if (!entry.stdout_path || maxChars <= 0)
+        return undefined;
+    try {
+        const size = statSync(entry.stdout_path).size;
+        if (size === 0)
+            return undefined;
+        const readBytes = Math.min(size, maxChars * 4); // 4 bytes/char upper bound for UTF-8
+        const buf = Buffer.allocUnsafe(readBytes);
+        const fd = openSync(entry.stdout_path, "r");
+        try {
+            const bytesRead = readSync(fd, buf, 0, readBytes, Math.max(0, size - readBytes));
+            const text = buf.subarray(0, bytesRead).toString("utf-8");
+            const trimmed = text.trimEnd();
+            return trimmed.length <= maxChars ? trimmed : trimmed.slice(trimmed.length - maxChars);
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+export function searchExecHistory(baseDir, opts = {}) {
+    const limit = clampLimit(opts.limit, 20, 200);
+    const entries = listExecHistory(baseDir);
+    const filtered = entries.filter((entry) => matchesFilters(entry, opts));
+    return filtered.slice(0, limit).map((entry) => ({
+        entry,
+        digest_preview: readDigestPreview(entry, 300),
+    }));
+}
+function clampLimit(value, fallback, max) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return fallback;
+    if (value < 1)
+        return 1;
+    if (value > max)
+        return max;
+    return Math.floor(value);
+}

package/dist/resources/extensions/gsd/exec-sandbox.js

@@ -0,0 +1,258 @@
+// GSD Exec Sandbox — tool-output sandboxing for sub-sessions.
+//
+// Runs a script in a subprocess and persists stdout/stderr to
+// `.gsd/exec/<id>.{stdout,stderr,meta.json}`. Only a short digest is
+// returned to the calling agent's context, keeping large outputs
+// (e.g. Playwright snapshots, issue dumps) out of the window.
+//
+// Inspired by mksglu/context-mode (Elastic License 2.0). Independent
+// implementation — no upstream code incorporated.
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { resolve } from "node:path";
+const ALWAYS_FORWARD_ENV = ["PATH", "HOME"];
+export const EXEC_DEFAULTS = {
+    clampTimeoutMs: 600_000,
+    defaultTimeoutMs: 30_000,
+    stdoutCapBytes: 1_048_576,
+    stderrCapBytes: 262_144,
+    digestChars: 300,
+    envAllowlist: [
+        "LANG",
+        "LC_ALL",
+        "TERM",
+        "TZ",
+        "SHELL",
+        "USER",
+        "LOGNAME",
+        "TMPDIR",
+        "NODE_OPTIONS",
+        "PYTHONPATH",
+        "PYTHONIOENCODING",
+    ],
+};
+function buildChildEnv(opts) {
+    const source = opts.env ?? process.env;
+    const out = {};
+    const allowed = new Set([...ALWAYS_FORWARD_ENV, ...opts.env_allowlist]);
+    for (const key of allowed) {
+        const value = source[key];
+        if (typeof value === "string")
+            out[key] = value;
+    }
+    return out;
+}
+function clampTimeout(request, opts) {
+    const requested = typeof request.timeout_ms === "number" && Number.isFinite(request.timeout_ms)
+        ? Math.floor(request.timeout_ms)
+        : opts.default_timeout_ms;
+    if (requested < 1)
+        return 1;
+    if (requested > opts.clamp_timeout_ms)
+        return opts.clamp_timeout_ms;
+    return requested;
+}
+function resolveCommand(runtime) {
+    switch (runtime) {
+        case "bash":
+            return { cmd: "bash", args: ["-c"] };
+        case "node":
+            return { cmd: process.execPath, args: ["-e"] };
+        case "python":
+            return { cmd: "python3", args: ["-c"] };
+    }
+}
+function tail(buf, chars) {
+    if (chars <= 0)
+        return "";
+    const text = buf.toString("utf-8");
+    return text.length <= chars ? text : text.slice(text.length - chars);
+}
+/**
+ * Run a script in a subprocess, capture stdout/stderr to files under
+ * `.gsd/exec/<id>.{stdout,stderr,meta.json}`, and return an `ExecSandboxResult`
+ * containing the digest plus metadata.
+ *
+ * Errors from spawn failures resolve (not reject) with `exit_code=null`.
+ * The function is pure with respect to its inputs — no global state beyond
+ * filesystem writes under `baseDir`.
+ */
+export function runExecSandbox(request, opts) {
+    return new Promise((resolveP) => {
+        const id = (opts.generateId ?? defaultGenerateId)();
+        const now = (opts.now ?? (() => new Date()))();
+        const execDir = resolve(opts.baseDir, ".gsd", "exec");
+        if (!existsSync(execDir))
+            mkdirSync(execDir, { recursive: true });
+        const stdoutPath = resolve(execDir, `${id}.stdout`);
+        const stderrPath = resolve(execDir, `${id}.stderr`);
+        const metaPath = resolve(execDir, `${id}.meta.json`);
+        const timeoutMs = clampTimeout(request, opts);
+        const { cmd, args } = resolveCommand(request.runtime);
+        const env = buildChildEnv(opts);
+        const useProcessGroup = process.platform !== "win32";
+        const started = Date.now();
+        let child;
+        try {
+            child = spawn(cmd, [...args, request.script], {
+                cwd: opts.baseDir,
+                env,
+                stdio: ["ignore", "pipe", "pipe"],
+                ...(useProcessGroup ? { detached: true } : {}),
+            });
+        }
+        catch (err) {
+            const duration = Date.now() - started;
+            const message = err instanceof Error ? err.message : String(err);
+            writeFileSync(stdoutPath, "");
+            writeFileSync(stderrPath, `spawn error: ${message}\n`);
+            const result = {
+                id,
+                runtime: request.runtime,
+                exit_code: null,
+                signal: null,
+                timed_out: false,
+                duration_ms: duration,
+                stdout_bytes: 0,
+                stderr_bytes: Buffer.byteLength(`spawn error: ${message}\n`),
+                stdout_truncated: false,
+                stderr_truncated: false,
+                stdout_path: stdoutPath,
+                stderr_path: stderrPath,
+                meta_path: metaPath,
+                digest: `[spawn error: ${message}]`,
+            };
+            writeMeta(metaPath, result, request, now);
+            resolveP(result);
+            return;
+        }
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        let stdoutBytes = 0;
+        let stderrBytes = 0;
+        let stdoutTruncated = false;
+        let stderrTruncated = false;
+        child.stdout?.on("data", (chunk) => {
+            const remaining = opts.stdout_cap_bytes - stdoutBytes;
+            if (remaining <= 0) {
+                stdoutTruncated = true;
+                return;
+            }
+            if (chunk.length <= remaining) {
+                stdoutChunks.push(chunk);
+                stdoutBytes += chunk.length;
+            }
+            else {
+                stdoutChunks.push(chunk.subarray(0, remaining));
+                stdoutBytes += remaining;
+                stdoutTruncated = true;
+            }
+        });
+        child.stderr?.on("data", (chunk) => {
+            const remaining = opts.stderr_cap_bytes - stderrBytes;
+            if (remaining <= 0) {
+                stderrTruncated = true;
+                return;
+            }
+            if (chunk.length <= remaining) {
+                stderrChunks.push(chunk);
+                stderrBytes += chunk.length;
+            }
+            else {
+                stderrChunks.push(chunk.subarray(0, remaining));
+                stderrBytes += remaining;
+                stderrTruncated = true;
+            }
+        });
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            if (useProcessGroup && child.pid != null) {
+                try {
+                    process.kill(-child.pid, "SIGKILL");
+                }
+                catch {
+                    child.kill("SIGKILL");
+                }
+            }
+            else {
+                child.kill("SIGKILL");
+            }
+        }, timeoutMs);
+        timer.unref?.();
+        const finalize = (exitCode, signal) => {
+            clearTimeout(timer);
+            const duration = Date.now() - started;
+            const stdoutBuf = Buffer.concat(stdoutChunks);
+            const stderrBuf = Buffer.concat(stderrChunks);
+            const stdoutSuffix = stdoutTruncated ? "\n[truncated: stdout cap reached]\n" : "";
+            const stderrSuffix = stderrTruncated ? "\n[truncated: stderr cap reached]\n" : "";
+            writeFileSync(stdoutPath, Buffer.concat([stdoutBuf, Buffer.from(stdoutSuffix, "utf-8")]));
+            writeFileSync(stderrPath, Buffer.concat([stderrBuf, Buffer.from(stderrSuffix, "utf-8")]));
+            const digestBody = tail(stdoutBuf, opts.digest_chars);
+            const digest = digestBody.length > 0
+                ? digestBody
+                : timedOut
+                    ? "[no stdout — timed out]"
+                    : stderrBuf.length > 0
+                        ? `[no stdout — tail of stderr]\n${tail(stderrBuf, opts.digest_chars)}`
+                        : "[no output]";
+            const result = {
+                id,
+                runtime: request.runtime,
+                exit_code: exitCode,
+                signal,
+                timed_out: timedOut,
+                duration_ms: duration,
+                stdout_bytes: stdoutBytes,
+                stderr_bytes: stderrBytes,
+                stdout_truncated: stdoutTruncated,
+                stderr_truncated: stderrTruncated,
+                stdout_path: stdoutPath,
+                stderr_path: stderrPath,
+                meta_path: metaPath,
+                digest,
+            };
+            writeMeta(metaPath, result, request, now);
+            resolveP(result);
+        };
+        child.on("error", (err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            const line = `child error: ${message}\n`;
+            const remaining = opts.stderr_cap_bytes - stderrBytes;
+            if (remaining > 0) {
+                const chunk = Buffer.from(line, "utf-8").subarray(0, remaining);
+                stderrChunks.push(chunk);
+                stderrBytes += chunk.length;
+                if (chunk.length < Buffer.byteLength(line, "utf-8"))
+                    stderrTruncated = true;
+            }
+        });
+        child.on("close", (code, signal) => finalize(code, signal));
+    });
+}
+function defaultGenerateId() {
+    return randomUUID();
+}
+function writeMeta(path, result, request, now) {
+    const meta = {
+        id: result.id,
+        runtime: result.runtime,
+        purpose: request.purpose ?? null,
+        script_chars: request.script.length,
+        started_at: now.toISOString(),
+        finished_at: new Date(now.getTime() + result.duration_ms).toISOString(),
+        exit_code: result.exit_code,
+        signal: result.signal,
+        timed_out: result.timed_out,
+        duration_ms: result.duration_ms,
+        stdout_bytes: result.stdout_bytes,
+        stderr_bytes: result.stderr_bytes,
+        stdout_truncated: result.stdout_truncated,
+        stderr_truncated: result.stderr_truncated,
+        stdout_path: result.stdout_path,
+        stderr_path: result.stderr_path,
+    };
+    writeFileSync(path, `${JSON.stringify(meta, null, 2)}\n`);
+}

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

@@ -495,7 +495,9 @@ function initSchema(db, fileBacked) {
         // that fresh installs already have. Add only columns needed by bootstrap
         // indexes so old DBs can open far enough for the normal migration chain.
         ensureBootstrapIndexColumns(db);
-        db.exec("CREATE INDEX IF NOT EXISTS idx_memories_scope ON memories(scope)");
+        if (columnExists(db, "memories", "scope")) {
+            db.exec("CREATE INDEX IF NOT EXISTS idx_memories_scope ON memories(scope)");
+        }
         db.exec("CREATE INDEX IF NOT EXISTS idx_memory_sources_kind ON memory_sources(kind)");
         db.exec("CREATE INDEX IF NOT EXISTS idx_memory_sources_scope ON memory_sources(scope)");
         db.exec("CREATE INDEX IF NOT EXISTS idx_memory_relations_from ON memory_relations(from_id)");
@@ -1097,6 +1099,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 +1117,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 +1182,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 +1194,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 +1248,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/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 },

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
@@ -278,7 +283,12 @@ function extractPathFromAnnotation(raw) {
     }
     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:

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 = [