@1agh/maude 0.56.0 → 0.57.0

package/apps/studio/client/panels/RepoBranchSwitcher.jsx

@@ -97,6 +97,30 @@ async function postJson(url, body, opts = {}) {
   }
 }
 
+/**
+ * Copy for the "a chat is mid-turn" confirm (Addendum Task 9). Pure + exported
+ * so the WORDING is unit-testable without rendering the switcher (which needs a
+ * native shim and three fetches on mount) — same rationale as
+ * PermissionPrompt.jsx's `pickDefaultAllow`/`describeOutOfProject`: on a safety
+ * prompt the affordance IS the control, so the words are worth a test.
+ *
+ * The wording is deliberately "is editing files on this branch", NOT "this will
+ * stop it". Before Task 8 the reload genuinely killed the turn and "will stop
+ * it" was true; now the bridge outlives its socket, so the turn KEEPS GOING —
+ * into a worktree that has moved under it. Saying "will stop it" would now be
+ * false in the reassuring direction, which is the worst way for a safety prompt
+ * to be wrong.
+ */
+export function chatGuardCopy({ count, branch, verb }) {
+  return {
+    title: count > 1 ? `${count} chats are working right now` : 'A chat is working right now',
+    body: `Claude is editing files on ${branch}. If you ${verb} now, those edits can land on the wrong branch — and Maude's History can't undo a cross-branch mix-up.`,
+    meta: 'Safest is to wait for the chat to finish, or stop it yourself first.',
+    confirm: 'Do it anyway',
+    cancel: 'Wait',
+  };
+}
+
 export default function RepoBranchSwitcher({ project, liveBranch, remoteSync, onGetLatest }) {
   const native = isNativeApp();
   const [status, setStatus] = useState(null); // { repo, branch }
@@ -115,6 +139,9 @@ export default function RepoBranchSwitcher({ project, liveBranch, remoteSync, on
   const [pulling, setPulling] = useState(false);
   // "Continue on <draft>?" nudge — dismissed for this session once the user opts out.
   const [resumeDismissed, setResumeDismissed] = useState(false);
+  // Task 9 — a pending branch change held back because a chat is mid-turn:
+  // `{ count, verb, action }`. Null when nothing is being confirmed.
+  const [chatGuard, setChatGuard] = useState(null);
 
   // Open the PR in the OS browser. A WKWebView anchor can't reach the default browser,
   // so native goes through the Tauri opener (github.com host-locked in Rust); an older
@@ -241,9 +268,52 @@ export default function RepoBranchSwitcher({ project, liveBranch, remoteSync, on
     catch { /* not a repo / offline — keep the prior list, never blank it */ }
   }
 
-  async function switchDraft(name, where) {
-    setOpen(false);
-    if (name === branch) return;
+  // ── Task 9: warn before a branch change moves the ground under a live turn ──
+  //
+  // THREE call sites reload, not one — `switchDraft`, `createDraft` and the
+  // local-merge fold in `foldDraft`. All three need the gate; missing one is the
+  // easy mistake here.
+  //
+  // Task 8 means the reload itself no longer KILLS the chat (the bridge outlives
+  // its socket now). That makes this warning MORE necessary, not less: the turn
+  // survives into a worktree that is no longer the one it was reasoning about.
+  // The agent read `foo.tsx` on this draft and will write it back after the
+  // checkout — a silent cross-branch clobber. And the "it's reversible" story
+  // this whole feature leans on degrades exactly here, because the `_history/`
+  // snapshot stack is per-canvas-slug with NO branch awareness.
+  //
+  // Asked of the SERVER, not of local chat state: a bridge can be running
+  // detached (post-reload, pre-re-attach) with no client that knows about it —
+  // precisely the case this warning is for.
+  async function chatsRunning() {
+    try {
+      const r = await fetch('/_api/acp/running');
+      if (!r.ok) return 0;
+      const j = await r.json();
+      return Number(j?.running) || 0;
+    } catch {
+      // Never block a branch switch because the probe failed — a switch the
+      // user asked for must not be hostage to an unrelated fetch error.
+      return 0;
+    }
+  }
+
+  /** Run `action` after an explicit confirm if a turn is in flight. Resolves
+   *  the pending action into state so the sheet below can render it; the sheet
+   *  calls back in on confirm. */
+  async function guardedByChat(action, verb) {
+    const n = await chatsRunning();
+    if (n === 0) {
+      action();
+      return;
+    }
+    setChatGuard({ count: n, verb, action });
+  }
+
+  // The raw action. Every caller goes through the guarded wrapper below — the
+  // warning has to happen BEFORE the checkout, since warning after the worktree
+  // already moved would be theatre.
+  async function doSwitchDraft(name, where) {
     setSwitching(name);
     setDownloading(where === 'remote'); // a remote-only branch is downloaded on switch
     setErr('');
@@ -252,6 +322,12 @@ export default function RepoBranchSwitcher({ project, liveBranch, remoteSync, on
     else { setErr(r.json?.error || 'Could not switch.'); setSwitching(''); setDownloading(false); }
   }
 
+  async function switchDraft(name, where) {
+    setOpen(false);
+    if (name === branch) return;
+    await guardedByChat(() => doSwitchDraft(name, where), `switch to “${name}”`);
+  }
+
   // "Fetch remote branches" — fetch all remote heads so a teammate's new branch
   // surfaces, then re-read the list. Explicit gesture (never auto-run); token is
   // server-held. A failure surfaces as an in-popup notice (DDR-133) — it NEVER
@@ -271,15 +347,21 @@ export default function RepoBranchSwitcher({ project, liveBranch, remoteSync, on
     setRefreshing(false);
   }
 
-  async function createDraft() {
-    const name = slugify(draftName);
-    if (!name) return;
+  async function doCreateDraft(name) {
     setBusy(true); setErr('');
     const r = await postJson('/_api/git/branch', { name });
     if (r.ok && r.json?.ok) window.location.reload();
     else { setErr(r.json?.error || 'Could not create the draft.'); setBusy(false); }
   }
 
+  // Call site 2 of 3 — creating a branch checks it out, so it moves the
+  // worktree exactly like a switch does.
+  async function createDraft() {
+    const name = slugify(draftName);
+    if (!name) return;
+    await guardedByChat(() => doCreateDraft(name), `create “${name}”`);
+  }
+
   // "Get latest" from the dock nudge — pull the shared version's new commits. Reuses
   // the app's pull handler (onGetLatest = gitGetLatest): on success it re-probes so the
   // nudge clears; a content conflict opens the visual resolver (handled in app.jsx).
@@ -297,7 +379,15 @@ export default function RepoBranchSwitcher({ project, liveBranch, remoteSync, on
   // opens a pull request (the merge happens on GitHub, post-review) — surface the PR
   // link and keep the sheet open. A local project merges directly (reload). A draft that
   // pushed but couldn't open a PR (no sign-in / non-github) shows a heads-up.
+  // Call site 3 of 3 — the LOCAL-merge path reloads (the GitHub-remote path
+  // opens a PR and stays put). Guarded as a whole rather than only around the
+  // reload: a merge landing under a running agent is the same hazard whether or
+  // not the page happens to reload afterward.
   async function foldDraft() {
+    await guardedByChat(doFoldDraft, `merge “${branch}” into ${sharedName}`);
+  }
+
+  async function doFoldDraft() {
     setFolding(branch);
     setErr('');
     const r = await postJson('/_api/git/fold', { name: branch }, { timeoutMs: 45000 });
@@ -339,6 +429,10 @@ export default function RepoBranchSwitcher({ project, liveBranch, remoteSync, on
   }
 
   const slug = slugify(draftName);
+  // Task 9 — the confirm's words, from the pure helper above so they stay testable.
+  const guardCopy = chatGuard
+    ? chatGuardCopy({ count: chatGuard.count, branch, verb: chatGuard.verb })
+    : null;
   const currentDraft = onShared ? null : branches.find((b) => b.current);
   // On the Shared version with a draft around? Offer to jump back to the most
   // recently-worked local draft. Maude shows whatever branch HEAD is, so after a
@@ -544,6 +638,51 @@ export default function RepoBranchSwitcher({ project, liveBranch, remoteSync, on
         {err && !open && !newDraft && !switching && <div className="rb-switcher-err" role="alert">{err}</div>}
       </div>
 
+      {/* Task 9 — a chat is mid-turn and the user asked for something that moves
+          the worktree. Silently reloading is the ONE outcome the Addendum calls
+          unacceptable, so this is an explicit confirm, not a toast. */}
+      {chatGuard && guardCopy && (
+        <div className="rb-scrim" role="presentation" onClick={() => setChatGuard(null)}>
+          <div
+            className="rb-sheet"
+            role="dialog"
+            aria-modal="true"
+            aria-labelledby="rb-chatguard-title"
+            aria-describedby="rb-chatguard-body"
+            data-testid="switcher-chat-guard"
+            onClick={(e) => e.stopPropagation()}
+            onKeyDown={(e) => { if (e.key === 'Escape') setChatGuard(null); }}
+          >
+            <span className="rb-sheet-icon"><Icon name="draft" size={20} /></span>
+            <h2 className="rb-sheet-title" id="rb-chatguard-title">{guardCopy.title}</h2>
+            <p className="rb-sheet-body" id="rb-chatguard-body">{guardCopy.body}</p>
+            <p className="rb-sheet-meta">{guardCopy.meta}</p>
+            <div className="rb-sheet-actions">
+              <button
+                type="button"
+                className="btn btn--ghost"
+                data-testid="switcher-chat-guard-cancel"
+                onClick={() => setChatGuard(null)}
+              >
+                {guardCopy.cancel}
+              </button>
+              <button
+                type="button"
+                className="btn btn--danger"
+                data-testid="switcher-chat-guard-confirm"
+                onClick={() => {
+                  const { action } = chatGuard;
+                  setChatGuard(null);
+                  action();
+                }}
+              >
+                {guardCopy.confirm}
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
+
       {/* Add-to-default confirm — the one modal in this surface. No 3-way merge UI.
           After a GitHub-remote fold it flips to a pull-request result view (DDR-162). */}
       {foldConfirm && (

package/apps/studio/client/panels/acp-runtime.js

@@ -123,6 +123,20 @@ export function applyUpdate(parts, toolIndex, u) {
 export function createAcpConnection() {
   let ws = null;
   let openPromise = null;
+  // ── The re-attach seam (Addendum Task 8) ──────────────────────────────────
+  // The chat this connection speaks for, and how far its history has been
+  // hydrated. Both are set by `bindChat()` BEFORE the socket opens, because the
+  // `attach` frame that carries them is sent from `onopen`.
+  //
+  // `hydratedSeq` is a transcript LINE NUMBER, not a message count — the server
+  // stamps every `update` with the line it occupies, so the two are directly
+  // comparable. Frames at or below it are things the panel already rendered
+  // from the HTTP hydration, and dropping them is what stops a reload from
+  // showing the last few seconds twice.
+  let attachedChatId = null;
+  let hydratedSeq = 0;
+  /** True when the server said we re-joined a turn that is STILL running. */
+  const attachedListeners = new Set();
   let turnHandler = null; // the in-flight run()'s frame sink
   const statusListeners = new Set();
   const status = { available: null, reason: undefined, ready: false };
@@ -240,6 +254,26 @@ export function createAcpConnection() {
   }
 
   function onFrame(frame) {
+    // ── The re-attach seam (Addendum Task 8) ────────────────────────────────
+    // Drop anything the panel already rendered from its HTTP hydration. The
+    // server replays the tail on `attach` and the live stream continues past
+    // it, so without this filter a reload mid-turn would show the overlap
+    // twice. Frames with no `seq` (every non-`update` frame) are unaffected.
+    if (typeof frame.seq === 'number') {
+      if (frame.seq <= hydratedSeq) return;
+      // Advance the marker as we consume, so a SECOND reconnect on the same
+      // page (a dropped socket, not a page reload) re-attaches from where the
+      // live stream actually got to rather than from the original hydration.
+      hydratedSeq = frame.seq;
+    }
+    if (frame.t === 'attached') {
+      for (const fn of attachedListeners) fn({ chat: frame.chat, running: !!frame.running });
+      // Re-joined a turn that is STILL running: restore the busy state, or the
+      // panel would look idle while the agent keeps working (and the composer
+      // would happily start a second, concurrent turn).
+      if (frame.running) setBusy(true);
+      return;
+    }
     if (frame.t === 'ready') {
       status.ready = true;
       status.available = frame.available;
@@ -274,7 +308,17 @@ export function createAcpConnection() {
     if (frame.t === 'permission-request') {
       pendingPermissions = [
         ...pendingPermissions,
-        { id: frame.id, toolCall: frame.toolCall, options: frame.options ?? [] },
+        {
+          id: frame.id,
+          toolCall: frame.toolCall,
+          options: frame.options ?? [],
+          // feature-acp-write-path-scope — present only when the server's
+          // write-path gate declined a write tool. `{ outOfProjectWrite,
+          // resolvedPaths, scopeRoot, reason }`; absent for every ordinary
+          // permission request, so PermissionPrompt's "outside the project"
+          // copy can't fire on one.
+          scope: frame.scope ?? null,
+        },
       ];
       emitPermissions();
       return;
@@ -329,7 +373,28 @@ export function createAcpConnection() {
       const scheme = location.protocol === 'https:' ? 'wss' : 'ws';
       const sock = new WebSocket(`${scheme}://${location.host}${WS_PATH}`);
       ws = sock;
-      sock.onopen = () => resolve();
+      sock.onopen = () => {
+        // Addendum Task 8 — bind to this chat's (possibly still running) bridge
+        // and close the re-attach seam in the same frame. `hydratedSeq` is the
+        // transcript line the panel hydrated over HTTP; the server replays
+        // exactly what came after it. A reload mid-turn therefore rejoins the
+        // live stream with no hole and no doubled text.
+        //
+        // Sent unconditionally, including for a brand-new chat (seq 0, nothing
+        // to replay) — the attach is what registers the socket as a sink, so
+        // skipping it for new chats would leave them detached until the first
+        // prompt.
+        if (attachedChatId) {
+          try {
+            sock.send(
+              JSON.stringify({ t: 'attach', chat: attachedChatId, seq: hydratedSeq })
+            );
+          } catch {
+            /* the frame handlers below surface a dead socket */
+          }
+        }
+        resolve();
+      };
       sock.onerror = () => reject(new Error('Could not reach the Claude bridge.'));
       sock.onclose = () => {
         ws = null;
@@ -423,13 +488,37 @@ export function createAcpConnection() {
      * "resolved" frame; the turn just continues). A response for an id that's
      * no longer pending (already timed out, or a duplicate click) is a no-op.
      */
+    /**
+     * Bind this connection to a chat and tell it how far the panel already
+     * hydrated that chat's transcript over HTTP (`seq` — a transcript LINE
+     * number, from the `X-Maude-Chat-Seq` response header).
+     *
+     * Must be called BEFORE the socket opens: the `attach` frame is sent from
+     * `onopen`, and it is what registers this socket as a sink for the chat's
+     * (possibly still running) server-side bridge. Calling it later still
+     * works for a subsequent reconnect, it just misses the current one.
+     */
+    bindChat(chatId, seq = 0) {
+      attachedChatId = chatId || null;
+      hydratedSeq = Number.isFinite(seq) && seq > 0 ? Math.floor(seq) : 0;
+    },
+
+    /** Subscribe to `{ chat, running }` — fires once per successful attach.
+     *  `running: true` means this socket re-joined a LIVE turn. */
+    onAttached(fn) {
+      attachedListeners.add(fn);
+      return () => attachedListeners.delete(fn);
+    },
+
     async respondPermission(id, decision) {
       if (!pendingPermissions.some((p) => p.id === id)) return;
       pendingPermissions = pendingPermissions.filter((p) => p.id !== id);
       emitPermissions();
       try {
         await ensureOpen();
-        ws?.send(JSON.stringify({ t: 'permission-response', id, decision }));
+        // `chat` is echoed back from the request frame — a bridge is keyed by
+        // chat now, not by socket, so the response has to name which one.
+        ws?.send(JSON.stringify({ t: 'permission-response', id, chat: attachedChatId, decision }));
       } catch {
         /* socket unavailable — the bridge's own timeout will deny this request */
       }
@@ -446,7 +535,9 @@ export function createAcpConnection() {
       emitElicitations();
       try {
         await ensureOpen();
-        ws?.send(JSON.stringify({ t: 'elicitation-response', id, ...response }));
+        ws?.send(
+          JSON.stringify({ t: 'elicitation-response', id, chat: attachedChatId, ...response })
+        );
       } catch {
         /* socket unavailable — the bridge's own timeout will decline this request */
       }
@@ -532,7 +623,7 @@ export function createAcpConnection() {
       };
       const cancel = () => {
         try {
-          ws?.send(JSON.stringify({ t: 'cancel' }));
+          ws?.send(JSON.stringify({ t: 'cancel', chat: attachedChatId || undefined }));
         } catch {
           /* socket already gone */
         }

package/apps/studio/client/styles/3-shell-maude.css

@@ -2240,10 +2240,19 @@ body.st-scrubbing, body.st-scrubbing * { cursor: ew-resize !important; user-sele
 
 /* identity rail — sidebar footer */
 .gi-rail { position: relative; flex: 0 0 auto; margin-top: auto; padding: var(--space-2) var(--space-3); border-top: 1px solid var(--border-default); display: flex; flex-direction: column; gap: var(--space-2); }
-.gi-rail-hint { font-size: var(--type-xs); color: var(--fg-2); padding: var(--space-1) var(--space-1); }
+/* Truncation the code already assumed: CloudBar.jsx documents `title` as "the
+   full sentence on hover (the rail truncates)" — and this rule did not exist,
+   so a long hub-supplied project name wrapped and grew, pushing the rail into
+   adjacent chrome. Its sibling .gi-rail-err has carried the same three
+   properties all along. `anywhere` so a single unbreakable 60-char token
+   cannot overflow horizontally either. */
+.gi-rail-hint { font-size: var(--type-xs); color: var(--fg-2); padding: var(--space-1) var(--space-1); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; overflow-wrap: anywhere; }
 .gi-rail-signin { width: 100%; justify-content: center; }
 .gi-rail-confirm { display: flex; align-items: center; gap: var(--space-2); flex-wrap: wrap; padding: var(--space-2); border: 1px solid var(--border-default); border-radius: var(--radius-md); background: var(--bg-2); }
-.gi-rail-confirm .gi-rail-hint { flex: 1 1 100%; padding: 0; }
+/* …but the deep-link confirm strip is a paragraph that MUST wrap — it explains
+   both sides of a consent decision, and one ellipsised line would hide half of
+   what the person is agreeing to. */
+.gi-rail-confirm .gi-rail-hint { flex: 1 1 100%; padding: 0; white-space: normal; overflow: visible; }
 .gi-rail-err { font-size: var(--type-xs); color: var(--status-error); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
 .gi-avatar { border-radius: var(--radius-pill); display: grid; place-items: center; font-family: var(--font-mono); font-size: 10px; font-weight: 600; color: var(--accent-fg); background: var(--accent); flex: 0 0 auto; }
 .gi-rail-account { display: flex; align-items: center; gap: var(--space-2); width: 100%; padding: var(--space-1) var(--space-2); border: 1px solid transparent; border-radius: var(--radius-md); background: transparent; color: var(--fg-0); cursor: pointer; text-align: left; }

package/apps/studio/client/styles/6-acp-chat.css

@@ -880,6 +880,57 @@
     gap: var(--space-2);
   }
 
+  /* feature-acp-write-path-scope Task 4 — the out-of-project WRITE variant.
+     Distinguished from an ordinary permission card because the two ask
+     materially different questions: the ordinary one is "do you want this
+     tool to run", this one is "do you want a file written somewhere your
+     project's history stack cannot roll back". The danger tint is the whole
+     point — a card that looks identical to the routine one gets clicked
+     through at the same rate. */
+  .chat-perm--outside {
+    border-color: var(--danger, #d9534f);
+  }
+  .chat-perm--outside .chat-perm-hd b {
+    color: var(--danger, #d9534f);
+  }
+  .chat-perm-outside {
+    display: flex;
+    flex-direction: column;
+    gap: var(--space-1);
+  }
+  /* The resolved absolute paths. Monospaced + wrapping at any character: these
+     are the one string on the card the user actually has to READ, and a path
+     that overflows or ellipsizes is a path whose dangerous tail is hidden —
+     the same failure the .chat-perm-hd b clamp above exists to prevent, but
+     with the opposite fix, because here truncation is what would be unsafe. */
+  .chat-perm-paths {
+    margin: 0;
+    padding: 0;
+    list-style: none;
+    display: flex;
+    flex-direction: column;
+    gap: var(--space-1);
+  }
+  .chat-perm-path {
+    padding: var(--space-1) var(--space-2);
+    border-radius: var(--radius-xs);
+    background: var(--bg-1);
+    color: var(--fg-0);
+    font-family: var(--font-mono);
+    font-size: var(--type-xs);
+    overflow-wrap: anywhere;
+  }
+  .chat-perm-scope,
+  .chat-perm-note {
+    margin: 0;
+    font-size: var(--type-xs);
+    color: var(--fg-3);
+  }
+  .chat-perm-root {
+    font-family: var(--font-mono);
+    overflow-wrap: anywhere;
+  }
+
   /* Form-elicitation card (feature-acp-ask-user-question — AskUserQuestion +
      generic MCP form input). Same slot + shape as .chat-perm, mutually
      exclusive with it — see the mount site in ChatPanel.jsx. */