gsd-pi 2.81.0 → 2.82.0-dev.ed17d078d

package/dist/welcome-screen.js

@@ -1,8 +1,10 @@
+// Project/App: GSD-2
+// File Purpose: Startup welcome screen rendering for the GSD terminal experience.
 /**
  * GSD Welcome Screen
  *
- * Two-panel bar layout: full-width accent bars at top/bottom (matching the
- * auto-mode progress widget style), logo left (fixed width), info right.
+ * Command-center layout: rounded terminal card with compact logo, project
+ * state, primary action, branch/workspace, and secondary hints.
  * Falls back to simple text on narrow terminals (<70 cols) or non-TTY.
  */
 import { readFileSync } from 'node:fs';
@@ -70,7 +72,27 @@ function visLen(s) {
 }
 /** Right-pad a string to the given visible width. */
 function rpad(s, w) {
-    return s + ' '.repeat(Math.max(0, w - visLen(s)));
+    const clamped = clampVisible(s, w);
+    return clamped + ' '.repeat(Math.max(0, w - visLen(clamped)));
+}
+function rightAlign(left, right, width) {
+    if (!right)
+        return clampVisible(left, width);
+    const gap = Math.max(1, width - visLen(left) - visLen(right));
+    return clampVisible(left + ' '.repeat(gap) + right, width);
+}
+function frameLine(content, width) {
+    const inner = Math.max(1, width - 2);
+    return chalk.hex('#a7ba78')('│') + rpad(content, inner) + chalk.hex('#a7ba78')('│');
+}
+/** Clamp rendered terminal output by visible columns. Falls back to plain text only when truncating. */
+function clampVisible(s, w) {
+    if (w <= 0)
+        return '';
+    if (visLen(s) <= w)
+        return s;
+    const plain = stripAnsi(s);
+    return plain.slice(0, Math.max(0, w - 1)) + '…';
 }
 export function buildWelcomeScreenLines(opts) {
     const { version, remoteChannel } = opts;
@@ -80,20 +102,6 @@ export function buildWelcomeScreenLines(opts) {
     if (termWidth < 70) {
         return ['', `  Get Shit Done v${version}`, `  ${shortCwd}`, ''];
     }
-    // ── Panel widths ────────────────────────────────────────────────────────────
-    // Layout: 1 leading space + LEFT_INNER logo content + 1 inner divider + RIGHT_INNER info
-    // Total: 1 + LEFT_INNER + 1 + RIGHT_INNER = termWidth
-    const LEFT_INNER = 34;
-    const RIGHT_INNER = termWidth - LEFT_INNER - 2; // 2 = leading space + inner divider
-    // ── Bar/divider chars (matching GLYPH.separator + widget ui.bar() style) ────
-    const H = '─', DV = '│', DS = '├';
-    // ── Left rows: blank + 6 logo lines + blank (8 total) ───────────────────────
-    const leftRows = ['', ...GSD_LOGO, ''];
-    // ── Right rows (8 total, null = divider) ────────────────────────────────────
-    const titleLeft = `  ${chalk.bold('Get Shit Done')}`;
-    const titleRight = chalk.dim(`v${version}`);
-    const titleFill = RIGHT_INNER - visLen(titleLeft) - visLen(titleRight);
-    const titleRow = titleLeft + ' '.repeat(Math.max(1, titleFill)) + titleRight;
     const toolParts = [];
     if (process.env.BRAVE_API_KEY)
         toolParts.push('Brave ✓');
@@ -107,71 +115,54 @@ export function buildWelcomeScreenLines(opts) {
         toolParts.push('Context7 ✓');
     if (remoteChannel)
         toolParts.push(`${remoteChannel.charAt(0).toUpperCase() + remoteChannel.slice(1)} ✓`);
-    // Tools left, hint right-aligned on the same row
-    const toolsLeft = toolParts.length > 0 ? chalk.dim('  ' + toolParts.join('  ·  ')) : '';
-    const hintRight = chalk.dim('/gsd to begin  ·  /gsd help');
-    const footerFill = RIGHT_INNER - visLen(toolsLeft) - visLen(hintRight);
-    const footerRow = toolsLeft + ' '.repeat(Math.max(1, footerFill)) + hintRight;
+    const innerWidth = Math.max(1, termWidth - 2);
+    const logoWidth = Math.max(...GSD_LOGO.map((line) => visLen(line)));
+    const divider = ` ${chalk.dim('│')} `;
+    const panelWidth = innerWidth - logoWidth - visLen(divider);
+    if (panelWidth < 44) {
+        return ['', `  Get Shit Done v${version}`, `  ${shortCwd}`, ''];
+    }
     // "Welcome back" context lines — GSD state if available, else hint.
     // Intentionally avoids data already shown in the footer (model, provider,
     // pwd, branch).
     const state = readGsdState();
-    let line1 = '';
-    let line2 = '';
+    let projectText = 'No active GSD project';
+    let commandText = '/gsd start';
+    let modeText = 'manual';
     if (state?.milestone) {
         const statusParts = [state.milestone, state.phase, state.slice].filter(Boolean);
-        const activePrefix = '  Active     ';
-        const maxActiveLen = RIGHT_INNER - activePrefix.length - 1;
-        let activeText = statusParts.join(' · ');
-        if (activeText.length > maxActiveLen)
-            activeText = activeText.slice(0, maxActiveLen - 1) + '…';
-        line1 = `${activePrefix}${chalk.dim(activeText)}`;
-        line2 = state.nextAction
-            ? `  Next       ${chalk.dim(state.nextAction)}`
-            : '';
-    }
-    else {
-        line1 = `  Status     ${chalk.dim('No active GSD project')}`;
-        line2 = `             ${chalk.dim('/gsd to begin')}`;
+        projectText = statusParts.join(' · ');
+        const maxActionWidth = Math.max(10, panelWidth - 30);
+        commandText = state.nextAction ? clampVisible(state.nextAction, maxActionWidth) : '/gsd next';
+        modeText = state.phase ?? 'active';
     }
-    const sessionLine = line1;
-    const projectLine = line2;
     const mcpCount = countMcpServers();
-    const mcpLine = mcpCount > 0
-        ? `  MCP        ${chalk.dim(`${mcpCount} server${mcpCount === 1 ? '' : 's'} configured`)}`
-        : '';
-    const DIVIDER = null;
-    const rightRows = [
-        titleRow,
-        DIVIDER,
-        sessionLine,
-        projectLine,
-        mcpLine,
-        '',
-        DIVIDER,
-        footerRow,
+    const mcpText = toolParts.length > 0
+        ? toolParts.join('  ·  ')
+        : mcpCount > 0
+            ? `${mcpCount} server${mcpCount === 1 ? '' : 's'} configured`
+            : 'none configured';
+    const label = (s) => chalk.dim(s);
+    const value = (s) => chalk.hex('#dce4f2')(s);
+    const accent = (s) => chalk.hex('#8db7ff')(s);
+    const panelRows = [
+        rightAlign(`${accent('GSD')} ${chalk.bold(value('Project Console'))}`, chalk.dim(`v${version}`), panelWidth),
+        rightAlign(`${label('Project')} ${value(projectText)}`, `${label('Command')} ${accent(commandText)}`, panelWidth),
+        rightAlign(`${label('Workspace')} ${value(shortCwd)}`, `${label('Mode')} ${value(modeText)}`, panelWidth),
+        rightAlign(`${label('MCP')} ${chalk.dim(mcpText)}`, `${label('Status')} ${value(state?.milestone ? 'active' : 'idle')}`, panelWidth),
+        rightAlign(`${label('Next')} ${accent('/gsd to begin')}`, `${label('Setup')} ${accent('/gsd start')}`, panelWidth),
+        rightAlign(chalk.dim('/gsd templates'), chalk.dim('/gsd help'), panelWidth),
     ];
     // ── Render ──────────────────────────────────────────────────────────────────
     const out = [''];
-    // Top bar — full-width accent separator, matches auto-mode widget ui.bar()
-    out.push(chalk.cyan(H.repeat(termWidth)));
-    for (let i = 0; i < 8; i++) {
-        const row = leftRows[i] ?? '';
-        const lContent = rpad(row ? chalk.cyan(row) : '', LEFT_INNER);
-        const rRow = rightRows[i];
-        if (rRow === null) {
-            // Section divider: left logo area + dim ├────... extending right
-            out.push(' ' + lContent + chalk.dim(DS + H.repeat(RIGHT_INNER)));
-        }
-        else {
-            // Content row: 1 space + logo │ info (no outer vertical borders)
-            out.push(' ' + lContent + chalk.dim(DV) + rpad(rRow, RIGHT_INNER));
-        }
+    out.push(chalk.hex('#a7ba78')('╭' + '─'.repeat(termWidth - 2) + '╮'));
+    for (let i = 0; i < GSD_LOGO.length; i++) {
+        const logo = rpad(chalk.hex('#a7ba78')(GSD_LOGO[i]), logoWidth);
+        out.push(frameLine(`${logo}${divider}${panelRows[i] ?? ''}`, termWidth));
     }
-    // Bottom bar — full-width accent separator
-    out.push(chalk.cyan(H.repeat(termWidth)));
+    out.push(chalk.hex('#a7ba78')('╰' + '─'.repeat(termWidth - 2) + '╯'));
     out.push('');
-    return out;
+    return out.map((line) => clampVisible(line, termWidth));
 }
 export function printWelcomeScreen(opts) {
     if (!process.stderr.isTTY)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-pi",
-  "version": "2.81.0",
+  "version": "2.82.0-dev.ed17d078d",
   "description": "GSD — Get Shit Done coding agent",
   "license": "MIT",
   "repository": {
@@ -73,7 +73,7 @@
     "test:packages:compiled": "node scripts/run-package-tests.cjs",
     "verify:workspace-coverage": "node scripts/verify-workspace-coverage.cjs",
     "test:marketplace": "node scripts/with-env.mjs GSD_TEST_CLONE_MARKETPLACES=1 -- node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test src/resources/extensions/gsd/tests/claude-import-tui.test.ts src/resources/extensions/gsd/tests/plugin-importer-live.test.ts src/tests/marketplace-discovery.test.ts",
-    "test:coverage": "c8 --reporter=text --reporter=lcov --exclude=\"src/resources/extensions/gsd/tests/**\" --exclude=\"src/tests/**\" --exclude=\"scripts/**\" --exclude=\"native/**\" --exclude=\"node_modules/**\" --check-coverage --statements=40 --lines=40 --branches=20 --functions=20 node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --experimental-test-isolation=process --test src/resources/extensions/gsd/tests/*.test.ts src/resources/extensions/gsd/tests/*.test.mjs src/tests/*.test.ts src/resources/extensions/shared/tests/*.test.ts",
+    "test:coverage": "cross-env NODE_OPTIONS=--max-old-space-size=8192 c8 --reporter=text --reporter=lcov --exclude=\"src/resources/extensions/gsd/tests/**\" --exclude=\"src/tests/**\" --exclude=\"scripts/**\" --exclude=\"native/**\" --exclude=\"node_modules/**\" --check-coverage --statements=40 --lines=40 --branches=20 --functions=20 node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --experimental-test-isolation=process --test src/resources/extensions/gsd/tests/*.test.ts src/resources/extensions/gsd/tests/*.test.mjs src/tests/*.test.ts src/resources/extensions/shared/tests/*.test.ts",
     "test:integration": "node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test \"src/tests/integration/*.test.ts\" \"src/resources/extensions/gsd/tests/integration/*.test.ts\" \"src/resources/extensions/async-jobs/*.test.ts\" \"src/resources/extensions/browser-tools/tests/*.test.mjs\"",
     "pretest": "npm run typecheck:extensions",
     "test": "npm run test:unit && npm run test:integration && npm run test:packages",
@@ -149,6 +149,7 @@
     "@types/node": "^24.12.0",
     "@types/picomatch": "^4.0.2",
     "c8": "^11.0.0",
+    "cross-env": "^7.0.3",
     "esbuild": "^0.25.12",
     "jiti": "^2.6.1",
     "typescript": "^5.4.0"

package/packages/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gsd-build/daemon",
-  "version": "2.81.0",
+  "version": "2.82.0",
   "description": "GSD daemon — background process for project monitoring and Discord integration",
   "license": "MIT",
   "repository": {
@@ -30,7 +30,7 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.52.0",
     "@gsd-build/contracts": "^2.80.0",
-    "@gsd-build/rpc-client": "^2.81.0",
+    "@gsd-build/rpc-client": "^2.82.0",
     "discord.js": "^14.25.1",
     "yaml": "^2.8.0",
     "zod": "^3.24.0"

package/packages/mcp-server/README.md

@@ -102,6 +102,8 @@ The workflow MCP surface includes:
 
 These tools use the same GSD workflow handlers as the native in-process tool path wherever a shared handler exists.
 
+`gsd_decision_save` and its `gsd_save_decision` alias persist new decisions to the ADR-013 memory store, not to the legacy `decisions` table. The assigned `D###` ID is recorded in `memories.structured_fields.sourceDecisionId`, and `.gsd/DECISIONS.md` is refreshed as a projection from memory-backed decisions. The legacy table may still be read by compatibility and inspection paths during the cutover window, but it is no longer a write target.
+
 `gsd_summary_save` computes artifact paths from the supplied IDs. `milestone_id` is required for milestone-, slice-, and task-scoped artifact types (`SUMMARY`, `RESEARCH`, `CONTEXT`, `ASSESSMENT`, `CONTEXT-DRAFT`) and should be omitted only for root-level `PROJECT`, `PROJECT-DRAFT`, `REQUIREMENTS`, and `REQUIREMENTS-DRAFT` artifacts. For final `REQUIREMENTS` saves, the tool renders content from active database requirement rows; callers must create those rows with `gsd_requirement_save` first.
 
 ### Interactive tools

package/packages/mcp-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gsd-build/mcp-server",
-  "version": "2.81.0",
+  "version": "2.82.0",
   "description": "MCP server exposing GSD orchestration tools for Claude Code, Cursor, and other MCP clients",
   "license": "MIT",
   "gsd": {
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "@gsd-build/contracts": "^2.80.0",
-    "@gsd-build/rpc-client": "^2.81.0",
+    "@gsd-build/rpc-client": "^2.82.0",
     "@modelcontextprotocol/sdk": "^1.27.1",
     "zod": "^4.0.0"
   },

package/packages/mcp-server/src/workflow-tools-parity.test.ts

@@ -0,0 +1,244 @@
+// ADR-008 validation criterion #3 — behavior-parity lock-in for gsd_task_complete.
+//
+// ADR-008 §1 ("One handler layer, multiple transports") is shipped: both
+// native (`db-tools.ts`) and MCP (`workflow-tools.ts`) registrations wrap the
+// same `executeTaskComplete` from `workflow-tool-executors.ts`. This test
+// guards the equivalence so a future executor refactor cannot silently drift
+// the two transports apart.
+//
+// Strategy: run the same completion against two equivalent fresh basePaths,
+// one via the native path (direct call to the shared executor — which is
+// faithfully what `db-tools.ts:670-674` does after `resolveCtxCwd`) and one
+// via the MCP path (`registerWorkflowTools` + tool.handler). Snapshot DB row,
+// summary file content, and journal events for each. Assert equivalence
+// modulo expected diffs (timestamps).
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import {
+  closeDatabase,
+  getTask,
+} from "../../../src/resources/extensions/gsd/gsd-db.ts";
+import { executeTaskComplete } from "../../../src/resources/extensions/gsd/tools/workflow-tool-executors.ts";
+import { registerWorkflowTools } from "./workflow-tools.ts";
+
+function makeTmpBase(): string {
+  const base = join(tmpdir(), `gsd-mcp-parity-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function seedMilestoneAndSlice(base: string): void {
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md"),
+    "# S01\n\n- [ ] **T01: Demo** `est:5m`\n",
+    "utf-8",
+  );
+}
+
+function cleanup(base: string): void {
+  try {
+    closeDatabase();
+  } catch {
+    // swallow
+  }
+  try {
+    rmSync(base, { recursive: true, force: true });
+  } catch {
+    // swallow
+  }
+}
+
+function makeMockServer() {
+  const tools: Array<{
+    name: string;
+    handler: (args: Record<string, unknown>) => Promise<unknown>;
+  }> = [];
+  return {
+    tools,
+    tool(
+      name: string,
+      _description: string,
+      _params: Record<string, unknown>,
+      handler: (args: Record<string, unknown>) => Promise<unknown>,
+    ) {
+      tools.push({ name, handler });
+    },
+  };
+}
+
+interface SnapshotShape {
+  /** SUMMARY.md content, trimmed, with ISO timestamps replaced by a sentinel. */
+  summary: string;
+  /** Task row, with volatile fields (timestamps, derived ids) elided. */
+  taskRow: Record<string, unknown>;
+  /** Journal events for this completion, with timestamps and ids normalized. */
+  journalEvents: Array<{ cmd: string; params: Record<string, unknown>; actor: string }>;
+}
+
+const ISO_TIMESTAMP_RE = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z/g;
+
+function normalizeTimestamps(text: string): string {
+  return text.replace(ISO_TIMESTAMP_RE, "<NORMALIZED-TS>");
+}
+
+function normalizeParams(params: Record<string, unknown>): Record<string, unknown> {
+  // Recursively replace ISO timestamps in any string value so the deep-equal
+  // doesn't fail on `ts`/`completed_at` style fields nested in the payload.
+  const out: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(params)) {
+    if (typeof v === "string") {
+      out[k] = normalizeTimestamps(v);
+    } else if (Array.isArray(v)) {
+      out[k] = v.map((item) =>
+        typeof item === "string"
+          ? normalizeTimestamps(item)
+          : item && typeof item === "object"
+            ? normalizeParams(item as Record<string, unknown>)
+            : item,
+      );
+    } else if (v !== null && typeof v === "object") {
+      out[k] = normalizeParams(v as Record<string, unknown>);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
+function snapshotState(base: string, milestoneId: string, sliceId: string, taskId: string): SnapshotShape {
+  const summaryPath = join(base, ".gsd", "milestones", milestoneId, "slices", sliceId, "tasks", `${taskId}-SUMMARY.md`);
+  assert.ok(existsSync(summaryPath), `summary file must exist at ${summaryPath}`);
+  const summary = normalizeTimestamps(readFileSync(summaryPath, "utf-8").trim());
+
+  const row = getTask(milestoneId, sliceId, taskId);
+  assert.ok(row, "task row must exist in DB after completion");
+  // Recursively normalize ISO timestamps in the row (the SQLite row uses
+  // snake_case `completed_at` and embeds another ISO timestamp inside the
+  // string field `full_summary_md`). Recursive normalization is simpler and
+  // more robust than maintaining an elision list.
+  const taskRow = normalizeParams(row as Record<string, unknown>);
+  assert.equal(taskRow.status, "complete", "task status must be 'complete' after completion");
+
+  const journalPath = join(base, ".gsd", "event-log.jsonl");
+  const journalEvents: SnapshotShape["journalEvents"] = [];
+  if (existsSync(journalPath)) {
+    const lines = readFileSync(journalPath, "utf-8")
+      .split("\n")
+      .filter((l) => l.length > 0);
+    for (const line of lines) {
+      try {
+        const evt = JSON.parse(line) as { cmd: string; params: Record<string, unknown>; actor: string };
+        if (evt.cmd === "complete-task" || evt.cmd === "complete_task") {
+          // Normalize cmd to canonical hyphen form, and elide ISO timestamps
+          // in the payload so the wall-clock skew between the two runs doesn't
+          // produce a spurious diff.
+          journalEvents.push({
+            cmd: "complete-task",
+            params: normalizeParams(evt.params),
+            actor: evt.actor,
+          });
+        }
+      } catch {
+        // Skip corrupted lines — non-fatal for parity comparison.
+      }
+    }
+  }
+
+  return { summary, taskRow, journalEvents };
+}
+
+const COMPLETION_ARGS = {
+  taskId: "T01",
+  sliceId: "S01",
+  milestoneId: "M001",
+  oneLiner: "Completed the demo task",
+  narrative: "Did the work described in the plan. Verified by running the test suite.",
+  verification: "npm test — all passing",
+  deviations: "None.",
+  knownIssues: "None.",
+  keyFiles: ["src/demo.ts"],
+  keyDecisions: ["Used Option A from the plan."],
+};
+
+describe("ADR-008 parity: gsd_task_complete native vs MCP", () => {
+  it("native and MCP produce equivalent DB row, summary, and journal event", async () => {
+    let baseNative = "";
+    let baseMcp = "";
+    try {
+      // ─── Native path ─────────────────────────────────────────────────
+      // The native wrapper in db-tools.ts:670-674 is:
+      //   const taskCompleteExecute = async (_tcid, params, ...) => {
+      //     const { executeTaskComplete } = await loadWorkflowExecutors();
+      //     return executeTaskComplete(params, resolveCtxCwd(_ctx));
+      //   };
+      // Calling executeTaskComplete directly with a basePath is the same
+      // post-resolution call shape.
+      baseNative = makeTmpBase();
+      seedMilestoneAndSlice(baseNative);
+      const nativeResult = await executeTaskComplete(COMPLETION_ARGS, baseNative);
+      assert.ok(!nativeResult.isError, "native completion must succeed");
+
+      const snapshotNative = snapshotState(baseNative, "M001", "S01", "T01");
+      closeDatabase();
+
+      // ─── MCP path ────────────────────────────────────────────────────
+      baseMcp = makeTmpBase();
+      seedMilestoneAndSlice(baseMcp);
+
+      const server = makeMockServer();
+      registerWorkflowTools(server as Parameters<typeof registerWorkflowTools>[0]);
+      const taskTool = server.tools.find((t) => t.name === "gsd_task_complete");
+      assert.ok(taskTool, "gsd_task_complete must be registered on the MCP surface");
+
+      const mcpResult = await taskTool.handler({ projectDir: baseMcp, ...COMPLETION_ARGS });
+      assert.ok(!mcpResult.isError, "mcp completion must succeed");
+
+      const snapshotMcp = snapshotState(baseMcp, "M001", "S01", "T01");
+
+      // ─── Compare ─────────────────────────────────────────────────────
+      assert.equal(
+        snapshotNative.summary,
+        snapshotMcp.summary,
+        "SUMMARY.md content must be byte-equal between native and MCP completions",
+      );
+
+      assert.deepEqual(
+        snapshotNative.taskRow,
+        snapshotMcp.taskRow,
+        "tasks DB row (modulo volatile timestamps and ids) must be equal",
+      );
+
+      // Journal event count must match (1 complete-task event per completion).
+      assert.equal(
+        snapshotNative.journalEvents.length,
+        snapshotMcp.journalEvents.length,
+        "both transports must emit the same number of complete-task journal events",
+      );
+
+      // Each journal event's params must match (these encode the completion
+      // payload; cmd is normalized and actor must align).
+      for (let i = 0; i < snapshotNative.journalEvents.length; i++) {
+        assert.equal(
+          snapshotNative.journalEvents[i].actor,
+          snapshotMcp.journalEvents[i].actor,
+          `journal event #${i} actor must match between native and MCP`,
+        );
+        assert.deepEqual(
+          snapshotNative.journalEvents[i].params,
+          snapshotMcp.journalEvents[i].params,
+          `journal event #${i} params must match between native and MCP`,
+        );
+      }
+    } finally {
+      if (baseNative) cleanup(baseNative);
+      if (baseMcp) cleanup(baseMcp);
+    }
+  });
+});

package/packages/native/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gsd/native",
-  "version": "2.81.0",
+  "version": "2.82.0",
   "description": "Native Rust bindings for GSD — high-performance native modules via N-API",
   "type": "commonjs",
   "gsd": {

package/packages/pi-agent-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gsd/pi-agent-core",
-  "version": "2.81.0",
+  "version": "2.82.0",
   "description": "General-purpose agent core (vendored from pi-mono)",
   "type": "module",
   "gsd": {