gsd-pi 2.74.0 → 2.75.0-dev.063e5a3

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

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

package/dist/resources/extensions/gsd/commands-session-report.js

@@ -0,0 +1,82 @@
+/**
+ * GSD Command — /gsd session-report
+ *
+ * Summarizes the current session: tasks completed, cost, tokens,
+ * duration, model usage breakdown.
+ */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { getLedger, getProjectTotals, aggregateByModel, formatCost, formatTokenCount, loadLedgerFromDisk } from "./metrics.js";
+import { gsdRoot } from "./paths.js";
+import { formatDuration } from "../shared/format-utils.js";
+function formatSessionReport(units) {
+    const totals = getProjectTotals(units);
+    const byModel = aggregateByModel(units);
+    const lines = [];
+    lines.push("╭─ Session Report ──────────────────────────────────────╮");
+    if (totals.duration > 0) {
+        lines.push(`│ Duration:    ${formatDuration(totals.duration).padEnd(40)}│`);
+    }
+    lines.push(`│ Units:       ${String(units.length).padEnd(40)}│`);
+    lines.push(`│ Cost:        ${formatCost(totals.cost).padEnd(40)}│`);
+    lines.push(`│ Tokens:      ${`${formatTokenCount(totals.tokens.input)} in / ${formatTokenCount(totals.tokens.output)} out`.padEnd(40)}│`);
+    lines.push("│                                                       │");
+    // Work completed
+    if (units.length > 0) {
+        lines.push("│ Work Completed:                                       │");
+        for (const unit of units) {
+            const finished = unit.finishedAt > 0;
+            const status = finished ? "✓" : "•";
+            const label = `  ${status} ${unit.id ?? "unknown"}`;
+            lines.push(`│ ${label.padEnd(53)}│`);
+        }
+        lines.push("│                                                       │");
+    }
+    // Model usage
+    if (byModel.length > 0) {
+        lines.push("│ Model Usage:                                          │");
+        for (const m of byModel) {
+            const label = `  ${m.model}: ${m.units} units (${formatCost(m.cost)})`;
+            lines.push(`│ ${label.padEnd(53)}│`);
+        }
+    }
+    lines.push("╰───────────────────────────────────────────────────────╯");
+    return lines.join("\n");
+}
+export async function handleSessionReport(args, ctx) {
+    const basePath = process.cwd();
+    // Get units from in-memory ledger or disk
+    const ledger = getLedger();
+    let units;
+    if (ledger && ledger.units.length > 0) {
+        units = ledger.units;
+    }
+    else {
+        const diskLedger = loadLedgerFromDisk(basePath);
+        if (!diskLedger || diskLedger.units.length === 0) {
+            ctx.ui.notify("No session data — no units have been executed yet.", "info");
+            return;
+        }
+        units = diskLedger.units;
+    }
+    // JSON output
+    if (args.includes("--json")) {
+        const totals = getProjectTotals(units);
+        const byModel = aggregateByModel(units);
+        ctx.ui.notify(JSON.stringify({ units: units.length, totals, byModel }, null, 2), "info");
+        return;
+    }
+    // Save to file
+    if (args.includes("--save")) {
+        const report = formatSessionReport(units);
+        const reportsDir = join(gsdRoot(basePath), "reports");
+        mkdirSync(reportsDir, { recursive: true });
+        const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+        const outPath = join(reportsDir, `session-${timestamp}.md`);
+        writeFileSync(outPath, `\`\`\`\n${report}\n\`\`\`\n`, "utf-8");
+        ctx.ui.notify(`Report saved: ${outPath}`, "success");
+        return;
+    }
+    // Display
+    ctx.ui.notify(formatSessionReport(units), "info");
+}

package/dist/resources/extensions/gsd/commands-ship.js

@@ -0,0 +1,187 @@
+/**
+ * GSD Command — /gsd ship
+ *
+ * Creates a PR from milestone artifacts: generates title + body from
+ * roadmap, slice summaries, and metrics, then opens via `gh pr create`.
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { deriveState } from "./state.js";
+import { resolveMilestoneFile, resolveSlicePath, resolveSliceFile } from "./paths.js";
+import { getLedger, getProjectTotals, aggregateByModel, formatCost, formatTokenCount, loadLedgerFromDisk } from "./metrics.js";
+import { nativeGetCurrentBranch, nativeDetectMainBranch } from "./native-git-bridge.js";
+import { formatDuration } from "../shared/format-utils.js";
+function git(basePath, args) {
+    return execFileSync("git", args, { cwd: basePath, encoding: "utf-8" }).trim();
+}
+function isValidRefName(name) {
+    try {
+        execFileSync("git", ["check-ref-format", "--branch", name], { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function listSliceIds(basePath, milestoneId) {
+    // Slices live at <milestoneDir>/slices/<sliceId>/ with canonical S\d+ IDs.
+    // Use resolveSlicePath with a probe to find the real slices directory root.
+    const probe = resolveSlicePath(basePath, milestoneId, "S01");
+    let slicesDir = null;
+    if (probe) {
+        // probe looks like <milestoneDir>/slices/S01 — parent is slices dir.
+        slicesDir = probe.replace(/[\\/][^\\/]+$/, "");
+    }
+    else {
+        // Fall back to scanning the milestones roadmap file's sibling slices dir.
+        const roadmap = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
+        if (roadmap) {
+            slicesDir = roadmap.replace(/[\\/][^\\/]+$/, "") + "/slices";
+        }
+    }
+    if (!slicesDir || !existsSync(slicesDir))
+        return [];
+    try {
+        return readdirSync(slicesDir, { withFileTypes: true })
+            .filter((e) => e.isDirectory() && /^S\d+$/.test(e.name))
+            .map((e) => e.name)
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+function collectSliceSummaries(basePath, milestoneId) {
+    const summaries = [];
+    for (const sliceId of listSliceIds(basePath, milestoneId)) {
+        const summaryPath = resolveSliceFile(basePath, milestoneId, sliceId, "SUMMARY");
+        if (!summaryPath || !existsSync(summaryPath))
+            continue;
+        try {
+            const content = readFileSync(summaryPath, "utf-8").trim();
+            if (content)
+                summaries.push(`### ${sliceId}\n${content}`);
+        }
+        catch {
+            // non-fatal
+        }
+    }
+    return summaries;
+}
+function generatePRContent(basePath, milestoneId, milestoneTitle) {
+    const title = `feat: ${milestoneTitle || milestoneId}`;
+    const sections = [];
+    // TL;DR
+    sections.push("## TL;DR\n");
+    sections.push(`**What:** Ship milestone ${milestoneId} — ${milestoneTitle || "(untitled)"}`);
+    sections.push(`**Why:** Milestone work complete, ready for review.`);
+    sections.push(`**How:** See slice summaries below.\n`);
+    // What — slice summaries
+    const summaries = collectSliceSummaries(basePath, milestoneId);
+    if (summaries.length > 0) {
+        sections.push("## What\n");
+        sections.push(summaries.join("\n\n"));
+        sections.push("");
+    }
+    // Roadmap status
+    const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
+    if (roadmapPath && existsSync(roadmapPath)) {
+        try {
+            const roadmap = readFileSync(roadmapPath, "utf-8");
+            const checkboxLines = roadmap.split("\n").filter((l) => /^\s*-\s*\[[ x]\]/.test(l));
+            if (checkboxLines.length > 0) {
+                sections.push("## Roadmap\n");
+                sections.push(checkboxLines.join("\n"));
+                sections.push("");
+            }
+        }
+        catch {
+            // non-fatal
+        }
+    }
+    // Metrics
+    const ledger = getLedger();
+    const units = ledger?.units ?? loadLedgerFromDisk(basePath)?.units ?? [];
+    if (units.length > 0) {
+        const totals = getProjectTotals(units);
+        const byModel = aggregateByModel(units);
+        sections.push("## Metrics\n");
+        sections.push(`- **Units executed:** ${units.length}`);
+        sections.push(`- **Total cost:** ${formatCost(totals.cost)}`);
+        sections.push(`- **Tokens:** ${formatTokenCount(totals.tokens.input)} input / ${formatTokenCount(totals.tokens.output)} output`);
+        if (totals.duration > 0) {
+            sections.push(`- **Duration:** ${formatDuration(totals.duration)}`);
+        }
+        if (byModel.length > 0) {
+            sections.push(`- **Models:** ${byModel.map((m) => `${m.model} (${m.units} units)`).join(", ")}`);
+        }
+        sections.push("");
+    }
+    // Change type checklist
+    sections.push("## Change type\n");
+    sections.push("- [x] `feat` — New feature or capability");
+    sections.push("- [ ] `fix` — Bug fix");
+    sections.push("- [ ] `refactor` — Code restructuring");
+    sections.push("- [ ] `test` — Adding or updating tests");
+    sections.push("- [ ] `docs` — Documentation only");
+    sections.push("- [ ] `chore` — Build, CI, or tooling changes\n");
+    // AI disclosure
+    sections.push("---\n");
+    sections.push("*This PR was prepared with AI assistance (GSD auto-mode).*");
+    return { title, body: sections.join("\n") };
+}
+export async function handleShip(args, ctx, _pi) {
+    const basePath = process.cwd();
+    const dryRun = args.includes("--dry-run");
+    const draft = args.includes("--draft");
+    const force = args.includes("--force");
+    const baseMatch = args.match(/--base\s+(\S+)/);
+    const base = baseMatch?.[1] ?? nativeDetectMainBranch(basePath);
+    if (!isValidRefName(base)) {
+        ctx.ui.notify(`Invalid base branch name: ${base}`, "error");
+        return;
+    }
+    // 1. Validate milestone state
+    const state = await deriveState(basePath);
+    if (!state.activeMilestone) {
+        ctx.ui.notify("No active milestone to ship. Complete milestone work first.", "warning");
+        return;
+    }
+    const milestoneId = state.activeMilestone.id;
+    const milestoneTitle = state.activeMilestone.title ?? "";
+    // 2. Check for incomplete work (use GSD phase as proxy — no phase field on ActiveRef)
+    if (state.phase !== "complete" && !force) {
+        ctx.ui.notify(`Milestone ${milestoneId} may not be complete (phase: ${state.phase}). Use --force to ship anyway.`, "warning");
+        return;
+    }
+    // 3. Generate PR content
+    const { title, body } = generatePRContent(basePath, milestoneId, milestoneTitle);
+    // 4. Dry-run — just show the PR content
+    if (dryRun) {
+        ctx.ui.notify(`--- PR Preview ---\n\nTitle: ${title}\n\n${body}`, "info");
+        return;
+    }
+    // 5. Check git state
+    const currentBranch = nativeGetCurrentBranch(basePath);
+    if (!isValidRefName(currentBranch)) {
+        ctx.ui.notify(`Current branch name is invalid for git: ${currentBranch}`, "error");
+        return;
+    }
+    if (currentBranch === base) {
+        ctx.ui.notify(`You're on ${base} — create a feature branch first.`, "warning");
+        return;
+    }
+    // 6. Push and create PR (all argv-safe, no shell interpolation)
+    try {
+        git(basePath, ["push", "-u", "origin", currentBranch]);
+        const ghArgs = ["pr", "create", "--base", base, "--title", title, "--body", body];
+        if (draft)
+            ghArgs.push("--draft");
+        const prUrl = execFileSync("gh", ghArgs, { cwd: basePath, encoding: "utf-8" }).trim();
+        ctx.ui.notify(`PR created: ${prUrl}`, "success");
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        ctx.ui.notify(`Failed to create PR: ${msg}`, "error");
+    }
+}

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

@@ -301,8 +301,7 @@ export async function saveRequirementToDb(fields, basePath) {
         catch (diskErr) {
             logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveRequirementToDb', error: String(diskErr.message) });
             try {
-                const rollbackAdapter = db._getAdapter();
-                rollbackAdapter?.prepare('DELETE FROM requirements WHERE id = :id').run({ ':id': id });
+                db.deleteRequirementById(id);
             }
             catch (rollbackErr) {
                 logError('manifest', 'SPLIT BRAIN: disk write failed AND DB rollback failed — DB has orphaned row', { fn: 'saveRequirementToDb', id, error: String(rollbackErr.message) });
@@ -405,7 +404,7 @@ export async function saveDecisionToDb(fields, basePath) {
         catch (diskErr) {
             logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveDecisionToDb', error: String(diskErr.message) });
             try {
-                adapter?.prepare('DELETE FROM decisions WHERE id = :id').run({ ':id': id });
+                db.deleteDecisionById(id);
             }
             catch (rollbackErr) {
                 logError('manifest', 'SPLIT BRAIN: disk write failed AND DB rollback failed — DB has orphaned row', { fn: 'saveDecisionToDb', id, error: String(rollbackErr.message) });
@@ -614,8 +613,7 @@ export async function saveArtifactToDb(opts, basePath) {
             }
             catch (diskErr) {
                 logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveArtifactToDb', error: String(diskErr.message) });
-                const rollbackAdapter = db._getAdapter();
-                rollbackAdapter?.prepare('DELETE FROM artifacts WHERE path = :path').run({ ':path': opts.path });
+                db.deleteArtifactByPath(opts.path);
                 throw diskErr;
             }
         }

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

@@ -102,6 +102,8 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
 
 - `custom_instructions`: extra durable instructions related to skill use. For operational project knowledge (recurring rules, gotchas, patterns), use `.gsd/KNOWLEDGE.md` instead — it's injected into every agent prompt automatically and agents can append to it during execution.
 
+- `language`: preferred response language for all GSD interactions. Accepts any language name or code — `"Chinese"`, `"zh"`, `"German"`, `"de"`, `"日本語"`, etc. When set, GSD injects "Always respond in \<language\>" into every agent's system prompt, including after `/clear`. Quickest way to set it: `/gsd language <name>`. To clear: `/gsd language off`.
+
 - `models`: per-stage model selection (applies to both auto-mode and guided-flow dispatches). Keys: `research`, `planning`, `discuss`, `execution`, `execution_simple`, `completion`, `validation`, `subagent`. Values can be:
   - Simple string: `"claude-sonnet-4-6"` — single model, no fallbacks
   - Provider-qualified string: `"bedrock/claude-sonnet-4-6"` — targets a specific provider when the same model ID exists across multiple providers
@@ -153,7 +155,7 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
 
 - `context_pause_threshold`: number (0-100) — context window usage percentage at which auto-mode should pause to suggest checkpointing. Set to `0` to disable. Default: `0` (disabled).
 
-- `token_profile`: `"budget"`, `"balanced"`, or `"quality"` — coordinates model selection, phase skipping, and context compression. `budget` skips research/reassessment and uses cheaper models; `balanced` (default) skips research/reassessment to reduce token burn; `quality` prefers higher-quality models. See token-optimization docs.
+- `token_profile`: `"budget"`, `"balanced"`, `"quality"`, or `"burn-max"` — coordinates model selection, phase skipping, and context compression. `budget` skips research/reassessment and uses cheaper models; `balanced` (default) skips research/reassessment to reduce token burn; `quality` prefers higher-quality models; `burn-max` keeps full-context defaults, disables downgrade routing, and keeps phase skips off.
 
 - `phases`: fine-grained control over which phases run. Usually set by `token_profile`, but can be overridden. Keys:
   - `skip_research`: boolean — skip milestone-level research. Default: `false`.
@@ -191,6 +193,19 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
   - `hooks`: boolean — enable routing hooks. Default: `true`.
   - `capability_routing`: boolean — enable capability-profile scoring for model selection within a tier. Requires `enabled: true`. Default: `false`.
 
+- `uok`: Unified Orchestration Kernel controls. Keys:
+  - `enabled`: boolean — enable kernel wrappers and contract observers. Default: `true`.
+  - `legacy_fallback.enabled`: boolean — emergency release fallback that forces legacy orchestration behavior even when `uok.enabled` is `true`. Default: `false`.
+    - Runtime override: set `GSD_UOK_FORCE_LEGACY=1` (or `GSD_UOK_LEGACY_FALLBACK=1`) to force legacy behavior for the current process.
+  - `gates.enabled`: boolean — route checks through the unified gate runner and persist `gate_runs`.
+  - `model_policy.enabled`: boolean — enforce policy filtering before model capability scoring.
+  - `execution_graph.enabled`: boolean — enable DAG scheduler facade/adapters for execution.
+  - `gitops.enabled`: boolean — persist turn-level git transaction records.
+  - `gitops.turn_action`: `"commit"` | `"snapshot"` | `"status-only"` — turn transaction mode.
+  - `gitops.turn_push`: boolean — whether turn transactions should include push intent metadata.
+  - `audit_unified.enabled`: boolean — dual-write unified audit envelope events.
+  - `plan_v2.enabled`: boolean — enable bounded clarify/research/draft/compile planning flow.
+
 - `context_management`: configures context hygiene for auto-mode sessions. Keys:
   - `observation_masking`: boolean — mask old tool results to reduce context bloat. Default: `true`.
   - `observation_mask_turns`: number — keep this many recent turns verbatim (1-50). Default: `8`.

package/dist/resources/extensions/gsd/ecosystem/gsd-extension-api.js

@@ -0,0 +1,144 @@
+// GSD2 — Ecosystem Extension API wrapper
+// Wraps pi's ExtensionAPI to expose typed GSD context (phase + active unit)
+// to extensions loaded from `./.gsd/extensions/`. The wrapper intercepts only
+// `on("before_agent_start", ...)` so GSD can dispatch ecosystem handlers AFTER
+// refreshing state — fixing the load-order race where third-party
+// `.pi/extensions/` handlers see a stale module-level snapshot (#3338).
+//
+// SINGLE-SESSION INVARIANT: the module-level `_snapshot` is per-process.
+// Worktree or project switches do NOT reload extensions, matching pi's
+// `.pi/extensions/` behavior. Only re-launching the CLI rebinds the snapshot.
+import { isGSDActive, getCurrentPhase } from "../../shared/gsd-phase-state.js";
+import { logWarning } from "../workflow-logger.js";
+// ─── Auto-loop phase mapping ────────────────────────────────────────────
+const AUTO_LOOP_PHASE_MAP = {
+    "plan-milestone": "planning",
+    "plan-slice": "planning",
+    "research": "researching",
+    "discuss": "discussing",
+    "execute-task": "executing",
+    "verify": "verifying",
+    "summarize-task": "summarizing",
+    "summarize-slice": "summarizing",
+    "advance": "advancing",
+    "validate-milestone": "validating-milestone",
+    "complete-milestone": "completing-milestone",
+    "replan-slice": "replanning-slice",
+};
+/** Exposed for unit tests. Returns null for unknown keys (does NOT default). */
+export function mapAutoLoopPhase(raw) {
+    return AUTO_LOOP_PHASE_MAP[raw] ?? null;
+}
+function resolvePhase(state) {
+    if (!state)
+        return null;
+    if (isGSDActive()) {
+        const raw = getCurrentPhase();
+        if (raw != null) {
+            const mapped = AUTO_LOOP_PHASE_MAP[raw];
+            if (mapped)
+                return mapped;
+            logWarning("ecosystem", `unknown auto-loop phase: ${raw}`);
+            // FALL THROUGH to state.phase rather than defaulting to "executing".
+        }
+    }
+    return state.phase;
+}
+function resolveActiveUnit(state) {
+    if (!state)
+        return null;
+    const m = state.activeMilestone;
+    const s = state.activeSlice;
+    const t = state.activeTask;
+    if (!m || !s || !t)
+        return null;
+    return {
+        milestoneId: m.id,
+        milestoneTitle: m.title,
+        sliceId: s.id,
+        sliceTitle: s.title,
+        taskId: t.id,
+        taskTitle: t.title,
+    };
+}
+let _snapshot = { phase: null, activeUnit: null };
+/** Refresh the snapshot from a freshly derived GSDState (or null on failure). */
+export function updateSnapshot(state) {
+    _snapshot = {
+        phase: resolvePhase(state),
+        activeUnit: resolveActiveUnit(state),
+    };
+}
+export function getSnapshotPhase() {
+    return _snapshot.phase;
+}
+export function getSnapshotActiveUnit() {
+    return _snapshot.activeUnit;
+}
+/** Test-only: reset the snapshot to its initial empty state. */
+export function _resetSnapshot() {
+    _snapshot = { phase: null, activeUnit: null };
+}
+// ─── Wrapper factory ────────────────────────────────────────────────────
+/**
+ * Build a GSDExtensionAPI by manually delegating every ExtensionAPI method
+ * to the underlying pi instance, except `on("before_agent_start", ...)`
+ * which is captured into `sharedHandlers` for GSD-owned dispatch.
+ *
+ * Uses `satisfies GSDExtensionAPI` (NOT `as`) so TypeScript catches drift
+ * when pi adds new ExtensionAPI methods.
+ */
+export function createGSDExtensionAPI(pi, sharedHandlers) {
+    const wrapper = {
+        // ── Event subscription (single intercept point) ────────────────────
+        on(event, handler) {
+            if (event === "before_agent_start") {
+                sharedHandlers.push(handler);
+                return;
+            }
+            pi.on(event, handler);
+        },
+        // ── Event emission ─────────────────────────────────────────────────
+        emitBeforeModelSelect: (...args) => pi.emitBeforeModelSelect(...args),
+        emitAdjustToolSet: (...args) => pi.emitAdjustToolSet(...args),
+        // ── Tool / command / shortcut / flag registration ──────────────────
+        registerTool: ((tool) => pi.registerTool(tool)),
+        registerCommand: (...args) => pi.registerCommand(...args),
+        registerBeforeInstall: (...args) => pi.registerBeforeInstall(...args),
+        registerAfterInstall: (...args) => pi.registerAfterInstall(...args),
+        registerBeforeRemove: (...args) => pi.registerBeforeRemove(...args),
+        registerAfterRemove: (...args) => pi.registerAfterRemove(...args),
+        registerShortcut: (...args) => pi.registerShortcut(...args),
+        registerFlag: (...args) => pi.registerFlag(...args),
+        getFlag: (...args) => pi.getFlag(...args),
+        // ── Message rendering ──────────────────────────────────────────────
+        registerMessageRenderer: ((customType, renderer) => pi.registerMessageRenderer(customType, renderer)),
+        // ── Actions ────────────────────────────────────────────────────────
+        sendMessage: ((message, options) => pi.sendMessage(message, options)),
+        sendUserMessage: (...args) => pi.sendUserMessage(...args),
+        retryLastTurn: () => pi.retryLastTurn(),
+        appendEntry: ((customType, data) => pi.appendEntry(customType, data)),
+        // ── Session metadata ───────────────────────────────────────────────
+        setSessionName: (...args) => pi.setSessionName(...args),
+        getSessionName: () => pi.getSessionName(),
+        setLabel: (...args) => pi.setLabel(...args),
+        exec: (...args) => pi.exec(...args),
+        getActiveTools: () => pi.getActiveTools(),
+        getAllTools: () => pi.getAllTools(),
+        setActiveTools: (...args) => pi.setActiveTools(...args),
+        getCommands: () => pi.getCommands(),
+        // ── Model & thinking ───────────────────────────────────────────────
+        setModel: (...args) => pi.setModel(...args),
+        getThinkingLevel: () => pi.getThinkingLevel(),
+        setThinkingLevel: (...args) => pi.setThinkingLevel(...args),
+        // ── Provider registration ──────────────────────────────────────────
+        registerProvider: (...args) => pi.registerProvider(...args),
+        unregisterProvider: (...args) => pi.unregisterProvider(...args),
+        // ── Shared event bus (passthrough property) ────────────────────────
+        events: pi.events,
+        // ── GSD-specific additions ─────────────────────────────────────────
+        getPhase: () => _snapshot.phase,
+        getActiveUnit: () => _snapshot.activeUnit,
+    };
+    return wrapper;
+}