gsd-pi 2.74.0 → 2.75.0-dev.063e5a3

package/src/resources/extensions/gsd/commands-session-report.ts

@@ -0,0 +1,101 @@
+/**
+ * GSD Command — /gsd session-report
+ *
+ * Summarizes the current session: tasks completed, cost, tokens,
+ * duration, model usage breakdown.
+ */
+
+import type { ExtensionCommandContext } from "@gsd/pi-coding-agent";
+
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { getLedger, getProjectTotals, aggregateByModel, formatCost, formatTokenCount, loadLedgerFromDisk } from "./metrics.js";
+import type { UnitMetrics } from "./metrics.js";
+import { gsdRoot } from "./paths.js";
+import { formatDuration } from "../shared/format-utils.js";
+
+function formatSessionReport(units: UnitMetrics[]): string {
+  const totals = getProjectTotals(units);
+  const byModel = aggregateByModel(units);
+
+  const lines: string[] = [];
+  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: string,
+  ctx: ExtensionCommandContext,
+): Promise<void> {
+  const basePath = process.cwd();
+
+  // Get units from in-memory ledger or disk
+  const ledger = getLedger();
+  let units: UnitMetrics[];
+
+  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/src/resources/extensions/gsd/commands-ship.ts

@@ -0,0 +1,219 @@
+/**
+ * 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 type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
+
+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: string, args: readonly string[]): string {
+  return execFileSync("git", args, { cwd: basePath, encoding: "utf-8" }).trim();
+}
+
+function isValidRefName(name: string): boolean {
+  try {
+    execFileSync("git", ["check-ref-format", "--branch", name], { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+interface PRContent {
+  title: string;
+  body: string;
+}
+
+function listSliceIds(basePath: string, milestoneId: string): string[] {
+  // 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: string | null = 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: string, milestoneId: string): string[] {
+  const summaries: string[] = [];
+  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: string, milestoneId: string, milestoneTitle: string): PRContent {
+  const title = `feat: ${milestoneTitle || milestoneId}`;
+
+  const sections: string[] = [];
+
+  // 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: string,
+  ctx: ExtensionCommandContext,
+  _pi: ExtensionAPI,
+): Promise<void> {
+  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/src/resources/extensions/gsd/db-writer.ts

@@ -346,8 +346,7 @@ export async function saveRequirementToDb(
     } catch (diskErr) {
       logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveRequirementToDb', error: String((diskErr as Error).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 as Error).message) });
       }
@@ -471,7 +470,7 @@ export async function saveDecisionToDb(
     } catch (diskErr) {
       logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveDecisionToDb', error: String((diskErr as Error).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 as Error).message) });
       }
@@ -714,8 +713,7 @@ export async function saveArtifactToDb(
         await saveFile(fullPath, opts.content);
       } catch (diskErr) {
         logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveArtifactToDb', error: String((diskErr as Error).message) });
-        const rollbackAdapter = db._getAdapter();
-        rollbackAdapter?.prepare('DELETE FROM artifacts WHERE path = :path').run({ ':path': opts.path });
+        db.deleteArtifactByPath(opts.path);
         throw diskErr;
       }
     }

package/src/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/src/resources/extensions/gsd/ecosystem/gsd-extension-api.ts

@@ -0,0 +1,228 @@
+// 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 type {
+  BeforeAgentStartEvent,
+  ExtensionAPI,
+  ExtensionHandler,
+} from "@gsd/pi-coding-agent";
+
+// Structural mirror of pi's internal BeforeAgentStartEventResult. The internal
+// type is not re-exported from the package root, and constraint #3 forbids
+// changes to packages/pi-coding-agent/, so we mirror the public shape here.
+// `any` on inner fields keeps assignability bidirectional with pi's stricter
+// `Pick<CustomMessage, ...>` shape (CustomMessage is also not re-exported).
+// Source of truth: packages/pi-coding-agent/src/core/extensions/types.ts
+export interface BeforeAgentStartEventResult {
+  message?: {
+    customType: string;
+    content?: any;
+    display?: any;
+    details?: any;
+  };
+  systemPrompt?: string;
+}
+
+import type { GSDActiveUnit, GSDState, Phase } from "../types.js";
+import { isGSDActive, getCurrentPhase } from "../../shared/gsd-phase-state.js";
+import { logWarning } from "../workflow-logger.js";
+
+// ─── Public Interface ───────────────────────────────────────────────────
+
+export interface GSDExtensionAPI extends ExtensionAPI {
+  /** Current GSD workflow phase, or null if no project state. */
+  getPhase(): Phase | null;
+  /** Currently active milestone/slice/task triple, or null if none. */
+  getActiveUnit(): GSDActiveUnit | null;
+}
+
+export type GSDEcosystemBeforeAgentStartHandler = ExtensionHandler<
+  BeforeAgentStartEvent,
+  BeforeAgentStartEventResult
+>;
+
+// ─── Auto-loop phase mapping ────────────────────────────────────────────
+
+const AUTO_LOOP_PHASE_MAP: Record<string, Phase> = {
+  "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: string): Phase | null {
+  return AUTO_LOOP_PHASE_MAP[raw] ?? null;
+}
+
+function resolvePhase(state: GSDState | null): Phase | null {
+  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: GSDState | null): GSDActiveUnit | null {
+  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,
+  };
+}
+
+// ─── Module-level snapshot ──────────────────────────────────────────────
+
+interface Snapshot {
+  phase: Phase | null;
+  activeUnit: GSDActiveUnit | null;
+}
+
+let _snapshot: Snapshot = { phase: null, activeUnit: null };
+
+/** Refresh the snapshot from a freshly derived GSDState (or null on failure). */
+export function updateSnapshot(state: GSDState | null): void {
+  _snapshot = {
+    phase: resolvePhase(state),
+    activeUnit: resolveActiveUnit(state),
+  };
+}
+
+export function getSnapshotPhase(): Phase | null {
+  return _snapshot.phase;
+}
+
+export function getSnapshotActiveUnit(): GSDActiveUnit | null {
+  return _snapshot.activeUnit;
+}
+
+/** Test-only: reset the snapshot to its initial empty state. */
+export function _resetSnapshot(): void {
+  _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: ExtensionAPI,
+  sharedHandlers: GSDEcosystemBeforeAgentStartHandler[],
+): GSDExtensionAPI {
+  const wrapper = {
+    // ── Event subscription (single intercept point) ────────────────────
+    on(event: any, handler: any): void {
+      if (event === "before_agent_start") {
+        sharedHandlers.push(handler as GSDEcosystemBeforeAgentStartHandler);
+        return;
+      }
+      (pi.on as (e: any, h: any) => void)(event, handler);
+    },
+
+    // ── Event emission ─────────────────────────────────────────────────
+    emitBeforeModelSelect: (...args: Parameters<ExtensionAPI["emitBeforeModelSelect"]>) =>
+      pi.emitBeforeModelSelect(...args),
+    emitAdjustToolSet: (...args: Parameters<ExtensionAPI["emitAdjustToolSet"]>) =>
+      pi.emitAdjustToolSet(...args),
+
+    // ── Tool / command / shortcut / flag registration ──────────────────
+    registerTool: ((tool: any) => pi.registerTool(tool)) as ExtensionAPI["registerTool"],
+    registerCommand: (...args: Parameters<ExtensionAPI["registerCommand"]>) =>
+      pi.registerCommand(...args),
+    registerBeforeInstall: (...args: Parameters<ExtensionAPI["registerBeforeInstall"]>) =>
+      pi.registerBeforeInstall(...args),
+    registerAfterInstall: (...args: Parameters<ExtensionAPI["registerAfterInstall"]>) =>
+      pi.registerAfterInstall(...args),
+    registerBeforeRemove: (...args: Parameters<ExtensionAPI["registerBeforeRemove"]>) =>
+      pi.registerBeforeRemove(...args),
+    registerAfterRemove: (...args: Parameters<ExtensionAPI["registerAfterRemove"]>) =>
+      pi.registerAfterRemove(...args),
+    registerShortcut: (...args: Parameters<ExtensionAPI["registerShortcut"]>) =>
+      pi.registerShortcut(...args),
+    registerFlag: (...args: Parameters<ExtensionAPI["registerFlag"]>) =>
+      pi.registerFlag(...args),
+    getFlag: (...args: Parameters<ExtensionAPI["getFlag"]>) => pi.getFlag(...args),
+
+    // ── Message rendering ──────────────────────────────────────────────
+    registerMessageRenderer: ((customType: string, renderer: any) =>
+      pi.registerMessageRenderer(customType, renderer)) as ExtensionAPI["registerMessageRenderer"],
+
+    // ── Actions ────────────────────────────────────────────────────────
+    sendMessage: ((message: any, options?: any) =>
+      pi.sendMessage(message, options)) as ExtensionAPI["sendMessage"],
+    sendUserMessage: (...args: Parameters<ExtensionAPI["sendUserMessage"]>) =>
+      pi.sendUserMessage(...args),
+    retryLastTurn: () => pi.retryLastTurn(),
+    appendEntry: ((customType: string, data?: any) =>
+      pi.appendEntry(customType, data)) as ExtensionAPI["appendEntry"],
+
+    // ── Session metadata ───────────────────────────────────────────────
+    setSessionName: (...args: Parameters<ExtensionAPI["setSessionName"]>) =>
+      pi.setSessionName(...args),
+    getSessionName: () => pi.getSessionName(),
+    setLabel: (...args: Parameters<ExtensionAPI["setLabel"]>) => pi.setLabel(...args),
+    exec: (...args: Parameters<ExtensionAPI["exec"]>) => pi.exec(...args),
+    getActiveTools: () => pi.getActiveTools(),
+    getAllTools: () => pi.getAllTools(),
+    setActiveTools: (...args: Parameters<ExtensionAPI["setActiveTools"]>) =>
+      pi.setActiveTools(...args),
+    getCommands: () => pi.getCommands(),
+
+    // ── Model & thinking ───────────────────────────────────────────────
+    setModel: (...args: Parameters<ExtensionAPI["setModel"]>) => pi.setModel(...args),
+    getThinkingLevel: () => pi.getThinkingLevel(),
+    setThinkingLevel: (...args: Parameters<ExtensionAPI["setThinkingLevel"]>) =>
+      pi.setThinkingLevel(...args),
+
+    // ── Provider registration ──────────────────────────────────────────
+    registerProvider: (...args: Parameters<ExtensionAPI["registerProvider"]>) =>
+      pi.registerProvider(...args),
+    unregisterProvider: (...args: Parameters<ExtensionAPI["unregisterProvider"]>) =>
+      pi.unregisterProvider(...args),
+
+    // ── Shared event bus (passthrough property) ────────────────────────
+    events: pi.events,
+
+    // ── GSD-specific additions ─────────────────────────────────────────
+    getPhase: (): Phase | null => _snapshot.phase,
+    getActiveUnit: (): GSDActiveUnit | null => _snapshot.activeUnit,
+  } satisfies GSDExtensionAPI;
+
+  return wrapper;
+}