gsd-pi 2.76.0-dev.82e249f7b → 2.76.0-dev.fe143342a

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

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) {

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

@@ -26,12 +26,12 @@ export { resolveAllSkillReferences } from "./preferences-skills.js";
 // These lived in preferences-skills.ts but imported loadEffectiveGSDPreferences
 // back from this file, creating a circular dependency. Moved here since they
 // are trivial wrappers over loadEffectiveGSDPreferences.
-export function resolveSkillDiscoveryMode() {
-    const prefs = loadEffectiveGSDPreferences();
+export function resolveSkillDiscoveryMode(basePath) {
+    const prefs = loadEffectiveGSDPreferences(basePath);
     return prefs?.preferences.skill_discovery ?? "suggest";
 }
-export function resolveSkillStalenessDays() {
-    const prefs = loadEffectiveGSDPreferences();
+export function resolveSkillStalenessDays(basePath) {
+    const prefs = loadEffectiveGSDPreferences(basePath);
     return prefs?.preferences.skill_staleness_days ?? 60;
 }
 // ─── Re-exports: models ─────────────────────────────────────────────────────
@@ -46,16 +46,16 @@ function globalPreferencesPath() {
 function legacyGlobalPreferencesPath() {
     return join(homedir(), ".pi", "agent", "gsd-preferences.md");
 }
-function projectPreferencesPath() {
-    return join(gsdRoot(process.cwd()), "PREFERENCES.md");
+function projectPreferencesPath(basePath = process.cwd()) {
+    return join(gsdRoot(basePath), "PREFERENCES.md");
 }
 // Legacy lowercase files can still exist in older projects. Keep them as a
 // compatibility-only fallback, but route new reads/writes through PREFERENCES.md.
 function legacyGlobalPreferencesPathLowercase() {
     return join(gsdHome(), "preferences.md");
 }
-function legacyProjectPreferencesPathLowercase() {
-    return join(gsdRoot(process.cwd()), "preferences.md");
+function legacyProjectPreferencesPathLowercase(basePath = process.cwd()) {
+    return join(gsdRoot(basePath), "preferences.md");
 }
 export function getGlobalGSDPreferencesPath() {
     return globalPreferencesPath();
@@ -63,8 +63,8 @@ export function getGlobalGSDPreferencesPath() {
 export function getLegacyGlobalGSDPreferencesPath() {
     return legacyGlobalPreferencesPath();
 }
-export function getProjectGSDPreferencesPath() {
-    return projectPreferencesPath();
+export function getProjectGSDPreferencesPath(basePath) {
+    return projectPreferencesPath(basePath);
 }
 // ─── Loading ────────────────────────────────────────────────────────────────
 export function loadGlobalGSDPreferences() {
@@ -72,13 +72,13 @@ export function loadGlobalGSDPreferences() {
         ?? loadPreferencesFile(legacyGlobalPreferencesPathLowercase(), "global")
         ?? loadPreferencesFile(legacyGlobalPreferencesPath(), "global");
 }
-export function loadProjectGSDPreferences() {
-    return loadPreferencesFile(projectPreferencesPath(), "project")
-        ?? loadPreferencesFile(legacyProjectPreferencesPathLowercase(), "project");
+export function loadProjectGSDPreferences(basePath) {
+    return loadPreferencesFile(projectPreferencesPath(basePath), "project")
+        ?? loadPreferencesFile(legacyProjectPreferencesPathLowercase(basePath), "project");
 }
-export function loadEffectiveGSDPreferences() {
+export function loadEffectiveGSDPreferences(basePath) {
     const globalPreferences = loadGlobalGSDPreferences();
-    const projectPreferences = loadProjectGSDPreferences();
+    const projectPreferences = loadProjectGSDPreferences(basePath);
     if (!globalPreferences && !projectPreferences)
         return null;
     let result;
@@ -489,8 +489,8 @@ export function resolvePreDispatchHooks() {
  * Worktree isolation requires explicit opt-in because it depends on git
  * branch infrastructure that must be set up before use.
  */
-export function getIsolationMode() {
-    const prefs = loadEffectiveGSDPreferences()?.preferences?.git;
+export function getIsolationMode(basePath) {
+    const prefs = loadEffectiveGSDPreferences(basePath)?.preferences?.git;
     if (prefs?.isolation === "worktree")
         return "worktree";
     if (prefs?.isolation === "branch")

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

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

package/dist/resources/extensions/gsd/tools/exec-search-tool.js

@@ -0,0 +1,59 @@
+// GSD Exec Search Tool — lists and filters prior gsd_exec runs.
+//
+// Scans .gsd/exec/*.meta.json and returns a ranked summary so agents can
+// re-discover past runs without re-executing. Read-only; no DB writes.
+import { searchExecHistory } from "../exec-history.js";
+export function executeExecSearch(params, opts) {
+    const searchOpts = {
+        query: typeof params.query === "string" ? params.query : undefined,
+        runtime: params.runtime,
+        failing_only: params.failing_only === true,
+        limit: typeof params.limit === "number" ? params.limit : undefined,
+    };
+    const hits = searchExecHistory(opts.baseDir, searchOpts);
+    if (hits.length === 0) {
+        return {
+            content: [{ type: "text", text: "No prior gsd_exec runs match those filters." }],
+            details: { operation: "gsd_exec_search", matches: 0 },
+        };
+    }
+    const lines = [`Found ${hits.length} exec run(s), most recent first:`];
+    for (const hit of hits) {
+        const e = hit.entry;
+        const status = formatStatus(e);
+        const purpose = e.purpose ? ` — ${e.purpose}` : "";
+        const truncated = e.stdout_truncated ? " (stdout truncated)" : "";
+        lines.push(`- [${e.id}] ${e.runtime} ${status} ${e.duration_ms}ms${truncated}${purpose}`, `    stdout: ${e.stdout_path}`);
+        if (hit.digest_preview) {
+            const preview = hit.digest_preview.replace(/\n/g, "\n      ");
+            lines.push(`    preview:\n      ${preview}`);
+        }
+    }
+    return {
+        content: [{ type: "text", text: lines.join("\n") }],
+        details: {
+            operation: "gsd_exec_search",
+            matches: hits.length,
+            results: hits.map((hit) => ({
+                id: hit.entry.id,
+                runtime: hit.entry.runtime,
+                exit_code: hit.entry.exit_code,
+                timed_out: hit.entry.timed_out,
+                duration_ms: hit.entry.duration_ms,
+                purpose: hit.entry.purpose,
+                stdout_path: hit.entry.stdout_path,
+                stderr_path: hit.entry.stderr_path,
+                meta_path: hit.entry.meta_path,
+            })),
+        },
+    };
+}
+function formatStatus(entry) {
+    if (entry.timed_out)
+        return "timeout";
+    if (entry.signal)
+        return `signal:${entry.signal}`;
+    if (entry.exit_code === null)
+        return "exit:null";
+    return `exit:${entry.exit_code}`;
+}

package/dist/resources/extensions/gsd/tools/exec-tool.js

@@ -0,0 +1,126 @@
+// GSD Exec Tool — executor for the gsd_exec MCP tool.
+//
+// Thin wrapper around exec-sandbox.ts that reads effective options from
+// the project preferences (context_mode block) and formats the result
+// for MCP return.
+import { EXEC_DEFAULTS, runExecSandbox, } from "../exec-sandbox.js";
+import { isContextModeEnabled } from "../preferences-types.js";
+export function buildExecOptions(baseDir, cfg, extras) {
+    const allowlist = Array.isArray(cfg?.exec_env_allowlist) ? cfg.exec_env_allowlist : EXEC_DEFAULTS.envAllowlist;
+    const stdoutCap = clampNumber(cfg?.exec_stdout_cap_bytes, EXEC_DEFAULTS.stdoutCapBytes, 4_096, 16_777_216);
+    const defaultTimeout = clampNumber(cfg?.exec_timeout_ms, EXEC_DEFAULTS.defaultTimeoutMs, 1_000, EXEC_DEFAULTS.clampTimeoutMs);
+    const digestChars = clampNumber(cfg?.exec_digest_chars, EXEC_DEFAULTS.digestChars, 0, 4_000);
+    return {
+        baseDir,
+        clamp_timeout_ms: EXEC_DEFAULTS.clampTimeoutMs,
+        default_timeout_ms: defaultTimeout,
+        stdout_cap_bytes: stdoutCap,
+        stderr_cap_bytes: EXEC_DEFAULTS.stderrCapBytes,
+        digest_chars: digestChars,
+        env_allowlist: allowlist,
+        ...extras,
+    };
+}
+function clampNumber(value, fallback, min, max) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return fallback;
+    if (value < min)
+        return min;
+    if (value > max)
+        return max;
+    return Math.floor(value);
+}
+function isEnabled(prefs) {
+    return isContextModeEnabled(prefs);
+}
+function disabledResult() {
+    return {
+        content: [
+            {
+                type: "text",
+                text: "gsd_exec is disabled by `context_mode.enabled: false` in preferences. Remove that " +
+                    "override (or set it to true) to re-enable sandboxed tool-output execution.",
+            },
+        ],
+        details: { operation: "gsd_exec", error: "context_mode_disabled" },
+        isError: true,
+    };
+}
+function paramError(message) {
+    return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        details: { operation: "gsd_exec", error: "invalid_params", detail: message },
+        isError: true,
+    };
+}
+export async function executeGsdExec(params, deps) {
+    if (!isEnabled(deps.preferences))
+        return disabledResult();
+    const runtime = params.runtime;
+    if (runtime !== "bash" && runtime !== "node" && runtime !== "python") {
+        return paramError(`invalid runtime "${String(runtime)}" — must be bash | node | python`);
+    }
+    const script = typeof params.script === "string" ? params.script : "";
+    if (script.trim().length === 0) {
+        return paramError("script is required and must be a non-empty string");
+    }
+    if (Buffer.byteLength(script, "utf8") > 200_000) {
+        return paramError("script exceeds the 200 KB length limit");
+    }
+    const opts = buildExecOptions(deps.baseDir, deps.preferences?.context_mode, { now: deps.now, generateId: deps.generateId });
+    const run = deps.run ?? runExecSandbox;
+    try {
+        const result = await run({
+            runtime,
+            script,
+            ...(typeof params.purpose === "string" ? { purpose: params.purpose } : {}),
+            ...(typeof params.timeout_ms === "number" ? { timeout_ms: params.timeout_ms } : {}),
+        }, opts);
+        return formatResult(result);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: "text", text: `Error: gsd_exec failed — ${message}` }],
+            details: { operation: "gsd_exec", error: message },
+            isError: true,
+        };
+    }
+}
+function formatResult(result) {
+    const headerLines = [
+        `gsd_exec[${result.id}] runtime=${result.runtime} exit=${formatExit(result)} duration=${result.duration_ms}ms`,
+        `  stdout: ${result.stdout_bytes}B${result.stdout_truncated ? " (truncated)" : ""} → ${result.stdout_path}`,
+        `  stderr: ${result.stderr_bytes}B${result.stderr_truncated ? " (truncated)" : ""} → ${result.stderr_path}`,
+    ];
+    const summary = `${headerLines.join("\n")}\n--- digest ---\n${result.digest}`.trimEnd();
+    return {
+        content: [{ type: "text", text: summary }],
+        details: {
+            operation: "gsd_exec",
+            id: result.id,
+            runtime: result.runtime,
+            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,
+            meta_path: result.meta_path,
+        },
+        isError: result.timed_out || result.signal !== null || result.exit_code !== 0,
+    };
+}
+function formatExit(result) {
+    if (result.timed_out)
+        return "timeout";
+    if (result.signal)
+        return `signal:${result.signal}`;
+    if (result.exit_code === null)
+        return "null";
+    return String(result.exit_code);
+}

package/dist/resources/extensions/gsd/tools/resume-tool.js

@@ -0,0 +1,23 @@
+// GSD Resume Tool — returns the contents of .gsd/last-snapshot.md so
+// agents can re-orient after compaction or session resume without
+// re-deriving project memory state.
+import { readCompactionSnapshot } from "../compaction-snapshot.js";
+export function executeResume(_params, opts) {
+    const snapshot = readCompactionSnapshot(opts.baseDir);
+    if (snapshot == null) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "No snapshot found at .gsd/last-snapshot.md. The snapshot is written automatically " +
+                        "on session_before_compact (enabled by default; set context_mode.enabled=false to opt out).",
+                },
+            ],
+            details: { operation: "gsd_resume", found: false },
+        };
+    }
+    return {
+        content: [{ type: "text", text: snapshot }],
+        details: { operation: "gsd_resume", found: true, bytes: Buffer.byteLength(snapshot, "utf-8") },
+    };
+}

package/dist/resources/extensions/gsd/workflow-mcp.js

@@ -5,6 +5,9 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 const MCP_WORKFLOW_TOOL_SURFACE = new Set([
     "ask_user_questions",
     "gsd_decision_save",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
     "gsd_complete_milestone",
     "gsd_complete_task",
     "gsd_complete_slice",