@1agh/maude 0.39.0 → 0.39.1

package/apps/studio/acp/bridge.ts

@@ -8,7 +8,7 @@
 // (env.ts): the child inherits the environment MINUS `ANTHROPIC_API_KEY`, so
 // auth precedence falls through to the user's Pro/Max subscription.
 
-import { appendFile, mkdir } from 'node:fs/promises';
+import { appendFile, mkdir, readFile, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 
 import {
@@ -71,6 +71,29 @@ const EFFORT_THINKING_TOKENS: Record<string, number | null> = {
 
 export type AcpEffort = keyof typeof EFFORT_THINKING_TOKENS;
 
+// Real sessionIds are adapter-generated `randomUUID()`s. A persisted value that
+// doesn't look like one (corrupt sidecar, or a tracked file a cloned repo
+// shipped despite `_chat/` being gitignored — DDR-115) is rejected rather than
+// forwarded into the privileged `loadSession` ACP call.
+const VALID_SESSION_ID = /^[A-Za-z0-9_-]{1,128}$/;
+
+// `loadSession`'s replay can, in principle, never settle if the underlying
+// transport dies mid-call (adapter crash, a concurrent `stop()` from another
+// chat sharing this bridge). Bound it so `replaying` always resets and a
+// resume attempt always falls back to `newSession` instead of wedging the
+// bridge silent forever. Mirrors the `withTimeout`/`TIMED_OUT` pattern already
+// used for network calls in `apps/studio/git/service.ts`.
+const LOAD_SESSION_TIMEOUT_MS = 15_000;
+const TIMED_OUT = Symbol('maude-acp-load-session-timeout');
+function withTimeout<T>(p: Promise<T>, ms: number): Promise<T | typeof TIMED_OUT> {
+  p.catch(() => {});
+  let timer: ReturnType<typeof setTimeout>;
+  const t = new Promise<typeof TIMED_OUT>((res) => {
+    timer = setTimeout(() => res(TIMED_OUT), ms);
+  });
+  return Promise.race([p, t]).finally(() => clearTimeout(timer));
+}
+
 /**
  * Build the `session/new` params, carrying TWO adapter-internal `_meta` payloads
  * (both spread by the installed `claude-agent-acp@0.49.x` `newSession`):
@@ -90,6 +113,10 @@ export type AcpEffort = keyof typeof EFFORT_THINKING_TOKENS;
  * must fail the presence tests LOUDLY (acp-bootstrap-brief.test.ts +
  * acp-session-plugins.test.ts), not silently un-brief / un-plugin every session.
  * Exported for those tests.
+ *
+ * `cwd`/`mcpServers`/`_meta` are also exactly the shared fields of a
+ * `LoadSessionRequest` (schema/types.gen.d.ts) — `sessionFor`'s resume path
+ * spreads this same object and adds `sessionId` rather than duplicating it.
  */
 export function newSessionParams(
   repoRoot: string,
@@ -136,12 +163,21 @@ export class AcpBridge {
   // context. The adapter (one subprocess) holds them all; switching chats reuses
   // the session, so claude remembers that chat while the app is open.
   private sessions = new Map<string, string>(); // chatId → sessionId
+  // In-flight sessionFor() calls, keyed by chatId — lets a `warm` and a `prompt`
+  // racing for the same chat share one resume/create attempt instead of each
+  // running establishSession() and stomping the single shared `replaying` flag.
+  private sessionPromises = new Map<string, Promise<string>>();
   private currentSession: string | null = null; // the in-flight prompt's session
   /** Sessions whose bootstrap brief already hit the transcript (audit record). */
   private briefLogged = new Set<string>();
   private starting: Promise<void> | null = null;
   /** Per-chat transcript file (`_chat/<id>.jsonl`); set per prompt. */
   private transcriptPath: string | null = null;
+  /** Sidecar persisting this chat's ACP sessionId across restarts (`_chat/<id>.session.json`). */
+  private sessionStorePath: string | null = null;
+  /** True while `conn.loadSession()` is replaying a resumed session's history
+   *  back through the `sessionUpdate` client callback — see the guard in `start()`. */
+  private replaying = false;
   // Model + effort are env-at-spawn (ANTHROPIC_MODEL / MAX_THINKING_TOKENS), so a
   // change re-spawns the adapter. `desired*` is what the UI asked for; `active*`
   // is what the running session was spawned with.
@@ -165,6 +201,10 @@ export class AcpBridge {
     this.transcriptPath = path;
   }
 
+  setSessionStorePath(path: string | null): void {
+    this.sessionStorePath = path;
+  }
+
   /** Desired model (alias/id, or null for the user's default) + effort. Applied
    *  on the next prompt — re-spawning the adapter only if it actually changed. */
   setConfig(model: string | null, effort: AcpEffort): void {
@@ -187,18 +227,104 @@ export class AcpBridge {
     return this.starting;
   }
 
-  /** Get-or-create the ACP session for a chat id (one claude context per chat). */
+  /**
+   * Get-or-create the ACP session for a chat id (one claude context per chat).
+   * `warm` and `prompt` can both reach this for the same chat close together
+   * (composer autocomplete warm-up racing the user hitting send) — a second
+   * concurrent call for the same chatId shares the FIRST call's in-flight
+   * promise (mirrors `ensureStarted`'s `this.starting` pattern) rather than
+   * re-entering resume/create and stomping the single shared `replaying` flag.
+   */
   private async sessionFor(chatId: string): Promise<string> {
     const existing = this.sessions.get(chatId);
     if (existing) return existing;
+    const inFlight = this.sessionPromises.get(chatId);
+    if (inFlight) return inFlight;
+
+    const promise = this.establishSession(chatId).finally(() => {
+      this.sessionPromises.delete(chatId);
+    });
+    this.sessionPromises.set(chatId, promise);
+    return promise;
+  }
+
+  /**
+   * Resumes a session persisted from a PRIOR app/dev-server lifetime (the
+   * cross-restart memory gap tracked in DDR-125) via the adapter's `loadSession`
+   * before falling back to a brand-new `newSession` — either because this chat
+   * has never had a session, or because the resume attempt failed (e.g. the
+   * underlying claude session was pruned, `claude` was reinstalled, or the
+   * adapter's response never arrives — `loadSession` is time-boxed so a dead
+   * transport can't wedge `replaying` true forever and silently black-hole
+   * every future turn on this bridge).
+   */
+  private async establishSession(chatId: string): Promise<string> {
     if (!this.conn) throw new Error('ACP adapter not started');
-    const created = await this.conn.newSession(
-      newSessionParams(this.opts.repoRoot, this.opts.studioBrief, this.opts.plugins)
-    );
+
+    const params = newSessionParams(this.opts.repoRoot, this.opts.studioBrief, this.opts.plugins);
+    const persistedId = await this.readPersistedSessionId();
+    if (persistedId) {
+      try {
+        this.replaying = true;
+        const result = await withTimeout(
+          this.conn.loadSession({ ...params, sessionId: persistedId }),
+          LOAD_SESSION_TIMEOUT_MS
+        );
+        if (result === TIMED_OUT) {
+          throw new Error(`loadSession timed out after ${LOAD_SESSION_TIMEOUT_MS}ms`);
+        }
+        this.sessions.set(chatId, persistedId);
+        return persistedId;
+      } catch (err) {
+        await this.appendTranscript({
+          role: 'bootstrap',
+          kind: 'resume-failed',
+          error: err instanceof Error ? err.message : String(err),
+        });
+      } finally {
+        this.replaying = false;
+      }
+    }
+
+    const created = await this.conn.newSession(params);
     this.sessions.set(chatId, created.sessionId);
+    await this.writePersistedSessionId(created.sessionId);
     return created.sessionId;
   }
 
+  /** Read the sessionId persisted for this chat by a prior bridge lifetime.
+   *  Null when there's no sidecar wired (e.g. warm-up before any prompt), the
+   *  file doesn't exist yet (first-ever turn), it's unreadable/corrupt, or its
+   *  `sessionId` doesn't look like a real one (defense-in-depth — this file's
+   *  directory is per-machine/gitignored per DDR-115, but a cloned repo could
+   *  still ship a tracked file there, so bound what we'll forward into the
+   *  privileged `loadSession` ACP call rather than trusting its shape blindly). */
+  private async readPersistedSessionId(): Promise<string | null> {
+    if (!this.sessionStorePath) return null;
+    try {
+      const raw = await readFile(this.sessionStorePath, 'utf8');
+      const data = JSON.parse(raw) as { sessionId?: unknown };
+      const id = data.sessionId;
+      return typeof id === 'string' && VALID_SESSION_ID.test(id) ? id : null;
+    } catch {
+      return null;
+    }
+  }
+
+  /** Persist a freshly-created sessionId so the NEXT bridge lifetime (app
+   *  restart, dev-server restart) can resume this chat instead of starting
+   *  fresh. Best-effort, like `appendTranscript` — a failed write just means
+   *  the next restart falls back to a new session. */
+  private async writePersistedSessionId(sessionId: string): Promise<void> {
+    if (!this.sessionStorePath) return;
+    try {
+      await mkdir(dirname(this.sessionStorePath), { recursive: true });
+      await writeFile(this.sessionStorePath, JSON.stringify({ sessionId, updatedAt: Date.now() }));
+    } catch {
+      /* best-effort — see doc comment above */
+    }
+  }
+
   private async start(): Promise<void> {
     const adapterEntry = resolveAdapterEntry();
     if (!adapterEntry) {
@@ -279,6 +405,12 @@ export class AcpBridge {
           this.opts.onCommands?.(params.update.availableCommands ?? []);
           return;
         }
+        // `loadSession` replays the resumed session's entire prior history back
+        // through this SAME callback (claude-agent-acp's replaySessionHistory) to
+        // prime its own in-adapter state. That history is already on disk in the
+        // transcript and already rendered client-side, so forwarding/re-appending
+        // it here would duplicate every message in the panel and the jsonl file.
+        if (this.replaying) return;
         this.opts.onUpdate(params.update);
         void this.appendTranscript({ role: 'agent', update: params.update });
       },
@@ -388,6 +520,13 @@ export class AcpBridge {
     this.proc = null;
     this.conn = null;
     this.sessions.clear();
+    // Drop any in-flight sessionFor() promises too — they were bound to the
+    // now-dead `conn`; a subsequent sessionFor() for the same chatId must
+    // establish fresh against the respawned connection, not await a stale
+    // reference (each entry's own .finally() would eventually clear it once its
+    // bounded loadSession timeout fires, but a call landing before then would
+    // otherwise get back a result tied to the connection we just tore down).
+    this.sessionPromises.clear();
     this.briefLogged.clear();
     this.currentSession = null;
   }

package/apps/studio/acp/index.ts

@@ -185,8 +185,16 @@ export function createAcp(ctx: Context, aiActivity?: AiActivity): Acp {
     const safe = id.replace(/[^a-z0-9_-]/gi, '').slice(0, 64);
     return safe || 'default';
   }
+  function chatFilePathFor(chatId: string, suffix: string): string {
+    return join(ctx.paths.designRoot, '_chat', `${sanitizeChatId(chatId)}${suffix}`);
+  }
   function transcriptPathFor(chatId: string): string {
-    return join(ctx.paths.designRoot, '_chat', `${sanitizeChatId(chatId)}.jsonl`);
+    return chatFilePathFor(chatId, '.jsonl');
+  }
+  // Sidecar persisting this chat's ACP sessionId across restarts (bridge.ts
+  // sessionFor's resume path) — the cross-restart memory gap tracked in DDR-125.
+  function sessionStorePathFor(chatId: string): string {
+    return chatFilePathFor(chatId, '.session.json');
   }
 
   async function handlePrompt(
@@ -198,6 +206,7 @@ export function createAcp(ctx: Context, aiActivity?: AiActivity): Acp {
   ): Promise<void> {
     const bridge = getOrCreateBridge(ws);
     bridge.setTranscriptPath(transcriptPathFor(chatId));
+    bridge.setSessionStorePath(sessionStorePathFor(chatId));
     bridge.setConfig(model, effort);
     try {
       await bridge.ensureStarted();
@@ -226,6 +235,7 @@ export function createAcp(ctx: Context, aiActivity?: AiActivity): Acp {
     effort: AcpEffort
   ): Promise<void> {
     const bridge = getOrCreateBridge(ws);
+    bridge.setSessionStorePath(sessionStorePathFor(chatId));
     bridge.setConfig(model, effort);
     try {
       await bridge.warmUp(sanitizeChatId(chatId));

package/apps/studio/test/acp-bridge.test.ts

@@ -4,6 +4,8 @@
 // (DDR-123 guardrail #1, verified end-to-end — the mock echoes its own env).
 
 import { afterEach, describe, expect, test } from 'bun:test';
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
 import { AcpBridge } from '../acp/bridge.ts';
@@ -112,6 +114,136 @@ describe('AcpBridge — round-trip + subscription guardrail', () => {
   }, 15000);
 });
 
+describe('AcpBridge — cross-restart session resume (DDR-125 gap)', () => {
+  let dir: string;
+
+  afterEach(async () => {
+    if (dir) await rm(dir, { recursive: true, force: true });
+  });
+
+  test('a persisted sessionId resumes via loadSession instead of spawning a new session', async () => {
+    process.env.MAUDE_ACP_ADAPTER_ENTRY = FIXTURE;
+    process.env.MAUDE_ACP_RUNTIME = process.execPath;
+    process.env.MAUDE_CLAUDE_BIN = process.execPath;
+    dir = await mkdtemp(join(tmpdir(), 'acp-bridge-test-'));
+    const storePath = join(dir, 'c1.session.json');
+    await Bun.write(storePath, JSON.stringify({ sessionId: 'persisted-session-abc' }));
+
+    const updates: unknown[] = [];
+    const bridge = new AcpBridge({ repoRoot: process.cwd(), onUpdate: (u) => updates.push(u) });
+    try {
+      bridge.setSessionStorePath(storePath);
+      await bridge.prompt('pokracuj', 'c1');
+      // Resumed the persisted id verbatim — never fell through to session/new
+      // (which would have minted a fresh `mock-session-N`).
+      expect(bridge.sessionId).toBe('persisted-session-abc');
+      // The mock's replay notification must NOT reach the UI sink.
+      expect(JSON.stringify(updates)).not.toContain('REPLAYED-HISTORY-SHOULD-NOT-SURFACE');
+    } finally {
+      await bridge.stop();
+    }
+  }, 15000);
+
+  test('a resume that fails (pruned session) falls back to newSession and re-persists the new id', async () => {
+    process.env.MAUDE_ACP_ADAPTER_ENTRY = FIXTURE;
+    process.env.MAUDE_ACP_RUNTIME = process.execPath;
+    process.env.MAUDE_CLAUDE_BIN = process.execPath;
+    dir = await mkdtemp(join(tmpdir(), 'acp-bridge-test-'));
+    const storePath = join(dir, 'c1.session.json');
+    await Bun.write(storePath, JSON.stringify({ sessionId: 'not-found' }));
+
+    const bridge = new AcpBridge({ repoRoot: process.cwd(), onUpdate: () => {} });
+    try {
+      bridge.setSessionStorePath(storePath);
+      await bridge.prompt('pokracuj', 'c1');
+      expect(bridge.sessionId).toBe('mock-session-1'); // fresh session, not the stale id
+      const stored = JSON.parse(await readFile(storePath, 'utf8'));
+      expect(stored.sessionId).toBe('mock-session-1'); // re-persisted so the NEXT restart resumes it
+    } finally {
+      await bridge.stop();
+    }
+  }, 15000);
+
+  test('no prior chat for this sidecar behaves exactly as before — a brand new session is created and persisted', async () => {
+    process.env.MAUDE_ACP_ADAPTER_ENTRY = FIXTURE;
+    process.env.MAUDE_ACP_RUNTIME = process.execPath;
+    process.env.MAUDE_CLAUDE_BIN = process.execPath;
+    dir = await mkdtemp(join(tmpdir(), 'acp-bridge-test-'));
+    const storePath = join(dir, 'brand-new.session.json');
+
+    const bridge = new AcpBridge({ repoRoot: process.cwd(), onUpdate: () => {} });
+    try {
+      bridge.setSessionStorePath(storePath);
+      await bridge.prompt('hi', 'c1');
+      expect(bridge.sessionId).toBe('mock-session-1');
+      const stored = JSON.parse(await readFile(storePath, 'utf8'));
+      expect(stored.sessionId).toBe('mock-session-1');
+    } finally {
+      await bridge.stop();
+    }
+  }, 15000);
+
+  test('no sidecar wired at all (e.g. a warm-up before any prompt) never touches disk and behaves exactly as before', async () => {
+    process.env.MAUDE_ACP_ADAPTER_ENTRY = FIXTURE;
+    process.env.MAUDE_ACP_RUNTIME = process.execPath;
+    process.env.MAUDE_CLAUDE_BIN = process.execPath;
+
+    const bridge = new AcpBridge({ repoRoot: process.cwd(), onUpdate: () => {} });
+    try {
+      // setSessionStorePath is never called — sessionStorePath stays null.
+      await bridge.prompt('hi', 'c1');
+      expect(bridge.sessionId).toBe('mock-session-1');
+    } finally {
+      await bridge.stop();
+    }
+  }, 15000);
+
+  test('a malformed persisted sessionId (not a plausible shape) is rejected — falls back to newSession', async () => {
+    process.env.MAUDE_ACP_ADAPTER_ENTRY = FIXTURE;
+    process.env.MAUDE_ACP_RUNTIME = process.execPath;
+    process.env.MAUDE_CLAUDE_BIN = process.execPath;
+    dir = await mkdtemp(join(tmpdir(), 'acp-bridge-test-'));
+    const storePath = join(dir, 'c1.session.json');
+    // Not a plausible sessionId shape (embedded newline + non-UUID charset) —
+    // must never reach the wire as a `loadSession` sessionId.
+    await Bun.write(storePath, JSON.stringify({ sessionId: 'evil\nsessionId; rm -rf /' }));
+
+    const bridge = new AcpBridge({ repoRoot: process.cwd(), onUpdate: () => {} });
+    try {
+      bridge.setSessionStorePath(storePath);
+      await bridge.prompt('hi', 'c1');
+      expect(bridge.sessionId).toBe('mock-session-1'); // rejected — fresh session instead
+    } finally {
+      await bridge.stop();
+    }
+  }, 15000);
+
+  test('warm and prompt racing for the same chat share one resume attempt (no replaying race)', async () => {
+    process.env.MAUDE_ACP_ADAPTER_ENTRY = FIXTURE;
+    process.env.MAUDE_ACP_RUNTIME = process.execPath;
+    process.env.MAUDE_CLAUDE_BIN = process.execPath;
+    dir = await mkdtemp(join(tmpdir(), 'acp-bridge-test-'));
+    const storePath = join(dir, 'c1.session.json');
+    await Bun.write(storePath, JSON.stringify({ sessionId: 'persisted-race-session' }));
+
+    const updates: unknown[] = [];
+    const bridge = new AcpBridge({ repoRoot: process.cwd(), onUpdate: (u) => updates.push(u) });
+    try {
+      bridge.setSessionStorePath(storePath);
+      // Fire warmUp and prompt concurrently for the same chatId — both call
+      // sessionFor('c1') before either has resolved.
+      const [, result] = await Promise.all([bridge.warmUp('c1'), bridge.prompt('pokracuj', 'c1')]);
+      expect(bridge.sessionId).toBe('persisted-race-session');
+      expect(result.stopReason).toBe('end_turn');
+      // Only ONE resume attempt happened — the mock's replay text never leaked,
+      // and the prompt's own turn still streamed normally.
+      expect(JSON.stringify(updates)).not.toContain('REPLAYED-HISTORY-SHOULD-NOT-SURFACE');
+    } finally {
+      await bridge.stop();
+    }
+  }, 15000);
+});
+
 describe('probeAcpAvailability — not-connected detection', () => {
   test('reports not-available with a Claude-Code reason when the CLI is absent', () => {
     process.env.MAUDE_ACP_ADAPTER_ENTRY = FIXTURE;

package/apps/studio/test/acp-commands.test.ts

@@ -6,6 +6,8 @@
 //     the cached list to a freshly-opened socket.
 
 import { afterEach, describe, expect, test } from 'bun:test';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
 import type { ServerWebSocket } from 'bun';
@@ -73,9 +75,11 @@ describe('AcpBridge.warmUp — publishes the command catalogue without a prompt'
 describe('Acp manager — warm frame broadcasts + open replays commands', () => {
   test('a {t:warm} frame yields a {t:commands} frame, replayed to a new socket', async () => {
     useMockAgent();
-    const ctx = {
-      paths: { repoRoot: process.cwd(), designRoot: join(process.cwd(), '.design') },
-    } as unknown as Context;
+    // Isolated tmp designRoot — `warm` now also writes a session-store sidecar
+    // (bridge.ts sessionFor's resume path), so this must not land in a real
+    // repo path.
+    const designRoot = await mkdtemp(join(tmpdir(), 'acp-commands-test-'));
+    const ctx = { paths: { repoRoot: process.cwd(), designRoot } } as unknown as Context;
     const acp = createAcp(ctx);
 
     const a = fakeWs('ws-a');
@@ -103,6 +107,7 @@ describe('Acp manager — warm frame broadcasts + open replays commands', () =>
       acp.onClose(a.ws);
       // give teardown a tick to kill the subprocess
       await new Promise((r) => setTimeout(r, 50));
+      await rm(designRoot, { recursive: true, force: true });
     }
   }, 20000);
 });

package/apps/studio/test/fixtures/mock-acp-agent.mjs

@@ -5,6 +5,16 @@
 // `agent_message_chunk` whose text echoes whether ANTHROPIC_API_KEY survived
 // into the child env — it MUST read `<unset>`, proving scrubAgentEnv (DDR-123
 // guardrail #1) stripped it before spawn.
+//
+// session/load simulates the REAL adapter's cross-restart resume (this is a
+// fresh subprocess per test, so it has no memory of a prior session/new call —
+// exactly like the real claude-agent-acp adapter after an app restart, whose
+// resume is backed by the underlying `claude` CLI's own on-disk store, not its
+// own process memory). Any sessionId resolves EXCEPT the `not-found` sentinel
+// (simulates a pruned/unresumable session), so a test controls resume
+// success/failure by choosing which id it persists. It also emits one replay
+// `session/update` BEFORE resolving, mirroring claude-agent-acp's
+// `replaySessionHistory` — bridge.ts must not forward or re-transcript it.
 
 import { Readable, Writable } from 'node:stream';
 
@@ -16,7 +26,7 @@ acp
   .agent({ name: 'mock-acp-agent' })
   .onRequest('initialize', () => ({
     protocolVersion: acp.PROTOCOL_VERSION,
-    agentCapabilities: { loadSession: false },
+    agentCapabilities: { loadSession: true },
   }))
   .onRequest(
     'session/new',
@@ -25,6 +35,19 @@ acp
       return () => ({ sessionId: `mock-session-${++n}` });
     })()
   )
+  .onRequest('session/load', async (ctx) => {
+    if (ctx.params.sessionId === 'not-found') {
+      throw new Error('session not found');
+    }
+    await ctx.client.notify('session/update', {
+      sessionId: ctx.params.sessionId,
+      update: {
+        sessionUpdate: 'agent_message_chunk',
+        content: { type: 'text', text: 'REPLAYED-HISTORY-SHOULD-NOT-SURFACE' },
+      },
+    });
+    return {};
+  })
   .onRequest('session/prompt', async (ctx) => {
     // The per-request handler context exposes the client connection at `.client`.
     await ctx.client.notify('session/update', {

package/apps/studio/whats-new.json

@@ -1,6 +1,15 @@
 {
   "$schema": "./whats-new.schema.json",
   "entries": [
+    {
+      "id": "acp-chat-cross-restart-resume",
+      "version": "0.39.1",
+      "date": "2026-07-03",
+      "kind": "fix",
+      "title": "The Assistant remembers your conversation after a restart",
+      "summary": "Killed the app to grab an update, or restarted the dev server mid-chat? The Assistant now picks up the actual conversation where you left off instead of quietly starting fresh while the old messages just sat there.",
+      "surface": "design-ui"
+    },
     {
       "id": "acp-chat-image-thumbnails",
       "version": "0.39.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1agh/maude",
-  "version": "0.39.0",
+  "version": "0.39.1",
   "description": "Marketplace of Claude Code plugins by Michal Dovrtěl: `design` (canvas-first design iteration) + `flow` (generic agentic workflow loop with .ai second brain). Ships the `maude` CLI (with `mdcc` legacy alias) to scaffold workspace, run the design dev server, and manage configs.",
   "type": "module",
   "engines": {
@@ -50,13 +50,13 @@
     "test:e2e:desktop:onboarding": "pnpm --filter @maude/desktop-e2e e2e:onboarding"
   },
   "optionalDependencies": {
-    "@1agh/maude-darwin-arm64": "0.39.0",
-    "@1agh/maude-darwin-x64": "0.39.0",
-    "@1agh/maude-linux-arm64": "0.39.0",
-    "@1agh/maude-linux-arm64-musl": "0.39.0",
-    "@1agh/maude-linux-x64": "0.39.0",
-    "@1agh/maude-linux-x64-musl": "0.39.0",
-    "@1agh/maude-win32-x64": "0.39.0"
+    "@1agh/maude-darwin-arm64": "0.39.1",
+    "@1agh/maude-darwin-x64": "0.39.1",
+    "@1agh/maude-linux-arm64": "0.39.1",
+    "@1agh/maude-linux-arm64-musl": "0.39.1",
+    "@1agh/maude-linux-x64": "0.39.1",
+    "@1agh/maude-linux-x64-musl": "0.39.1",
+    "@1agh/maude-win32-x64": "0.39.1"
   },
   "files": [
     "cli",