@hienlh/ppm 0.23.13 → 0.23.15

package/src/web/design-share-page/use-share-canvas.ts

@@ -0,0 +1,51 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { newBridgeNonce, useDesignBridge } from "../components/design/canvas/use-design-bridge";
+import { shareBase } from "./share-api";
+
+/**
+ * The design frame of a share link: which page it shows and the bridge to it.
+ *
+ * Every load gets a fresh nonce on its URL (`?n=`), and reloading means setting a new `src`:
+ * the frame's origin is opaque, so `location.reload()` is not the parent's to call. A load
+ * that never says `ready` is retried once with a new nonce; failing again, the page says the
+ * design stopped responding rather than reloading forever.
+ */
+
+/** `/s/<code>/f/<slug>/<file>`, each segment encoded, `file` keeping its own slashes. */
+export function frameUrl(code: string, slug: string, file: string): string {
+  return `${shareBase(code)}/f/${encodeURIComponent(slug)}/${file.split("/").map(encodeURIComponent).join("/")}`;
+}
+
+export function useShareCanvas(code: string, slug: string, file: string) {
+  const iframeRef = useRef<HTMLIFrameElement | null>(null);
+  const [nonce, setNonce] = useState(() => newBridgeNonce());
+  const [dead, setDead] = useState(false);
+  const recovering = useRef(false);
+
+  const recover = useCallback(() => {
+    if (recovering.current) { setDead(true); return; }
+    recovering.current = true;
+    setNonce(newBridgeNonce());
+  }, []);
+  const bridge = useDesignBridge(iframeRef, nonce, recover);
+
+  // Another page of the design is another document: a new nonce goes with it.
+  const shown = useRef(file);
+  useEffect(() => {
+    if (shown.current === file) return;
+    shown.current = file;
+    setNonce(newBridgeNonce());
+  }, [file]);
+
+  useEffect(() => bridge.on("ready", () => { recovering.current = false; setDead(false); }), [bridge.on]);
+
+  const reload = useCallback(() => {
+    recovering.current = false;
+    setDead(false);
+    setNonce(newBridgeNonce());
+  }, []);
+
+  return { iframeRef, src: `${frameUrl(code, slug, file)}?n=${encodeURIComponent(nonce)}`, bridge, dead, reload };
+}
+
+export type ShareCanvasState = ReturnType<typeof useShareCanvas>;

package/src/web/design-share-page/use-share-info.ts

@@ -0,0 +1,34 @@
+import { useCallback, useEffect, useState } from "react";
+import type { DesignShareGuestInfo } from "../../shared/design-share-guest-types";
+import { fetchShareInfo, ShareApiError, failureMessage } from "./share-api";
+
+/** What `/s/<code>/info` said: still loading, the shared version, a dead link, or a failure to retry. */
+export type ShareInfoState =
+  | { status: "loading" }
+  | { status: "ready"; info: DesignShareGuestInfo }
+  | { status: "invalid" }
+  | { status: "error"; message: string };
+
+export function useShareInfo(code: string | null): { state: ShareInfoState; retry: () => void } {
+  const [state, setState] = useState<ShareInfoState>(code ? { status: "loading" } : { status: "invalid" });
+  const [attempt, setAttempt] = useState(0);
+
+  useEffect(() => {
+    if (!code) return;
+    let cancelled = false;
+    setState({ status: "loading" });
+    fetchShareInfo(code).then(
+      (info) => { if (!cancelled) setState({ status: "ready", info }); },
+      (e: unknown) => {
+        if (cancelled) return;
+        const failure = e instanceof ShareApiError ? e.failure : null;
+        if (failure?.kind === "invalid") setState({ status: "invalid" });
+        else setState({ status: "error", message: failure ? failureMessage(failure) : "Could not open the design." });
+      },
+    );
+    return () => { cancelled = true; };
+  }, [code, attempt]);
+
+  const retry = useCallback(() => setAttempt((n) => n + 1), []);
+  return { state, retry };
+}

package/src/web/design-share-page/use-share-session.ts

@@ -0,0 +1,75 @@
+import { useCallback, useMemo, useRef, useState } from "react";
+import type { DesignShareGuestInfo } from "../../shared/design-share-guest-types";
+import { failureMessage, isVersionChanged, ShareApiError, shareWrites, type ShareFailure } from "./share-api";
+import { browserStore, loadGuestKey, loadGuestName, saveGuestName } from "./share-identity";
+import { useShareThreads } from "./use-share-threads";
+import type { GuestThread } from "./share-thread-model";
+
+/**
+ * One reviewer on one link: their key and name, the threads, and every write, each of
+ * which reports its own failure in the page's notice line and answers whether it went
+ * through. A write refused because the link stopped opening turns the whole page into the
+ * "no longer valid" state, the same as a poll that finds it so.
+ */
+
+export interface ShareNotice { id: number; message: string }
+
+export function useShareSession(info: DesignShareGuestInfo, code: string) {
+  const store = useMemo(() => browserStore(), []);
+  const key = useMemo(() => loadGuestKey(store, info.linkId), [store, info.linkId]);
+  const [name, setNameState] = useState(() => loadGuestName(store, info.linkId));
+  const [notice, setNotice] = useState<ShareNotice | null>(null);
+  const [writeInvalid, setWriteInvalid] = useState(false);
+  const noticeId = useRef(0);
+
+  const notify = useCallback((message: string) => setNotice({ id: ++noticeId.current, message }), []);
+  const dismissNotice = useCallback(() => setNotice(null), []);
+  const onPollFailure = useCallback((f: ShareFailure) => notify(failureMessage(f)), [notify]);
+  const threads = useShareThreads(code, key, info.versionId, onPollFailure);
+  const [writeVersionChanged, setWriteVersionChanged] = useState(false);
+  const { applyThread, applyDeleted, refresh } = threads;
+  const writes = useMemo(() => shareWrites(code, key), [code, key]);
+
+  /** Validates and remembers a name; an error is for the field that asked. */
+  const setName = useCallback((raw: string) => {
+    const saved = saveGuestName(store, info.linkId, raw);
+    if (saved.ok) setNameState(saved.name);
+    return saved;
+  }, [store, info.linkId]);
+
+  const run = useCallback(async <T,>(op: () => Promise<T>, done: (result: T) => void): Promise<boolean> => {
+    try {
+      done(await op());
+      return true;
+    } catch (e) {
+      const failure: ShareFailure = e instanceof ShareApiError ? e.failure : { kind: "network" };
+      if (failure.kind === "invalid") setWriteInvalid(true);
+      // The page's own bar says this, with the button that fixes it.
+      else if (isVersionChanged(failure)) setWriteVersionChanged(true);
+      else notify(failureMessage(failure));
+      // The thread may be gone or changed under the reviewer; show what is there now.
+      if (failure.kind === "error" && (failure.status === 404 || failure.status === 409)) refresh();
+      return false;
+    }
+  }, [notify, refresh]);
+
+  const actions = useMemo(() => ({
+    addThread: (anchor: unknown, body: string, as: string, onDone: (t: GuestThread) => void) =>
+      run(() => writes.addThread(anchor, body, as, info.versionId), (t) => { applyThread(t); onDone(t); }),
+    reply: (id: string, body: string, as: string) => run(() => writes.reply(id, body, as), applyThread),
+    editThread: (id: string, body: string) => run(() => writes.editThread(id, body), applyThread),
+    deleteThread: (id: string) => run(() => writes.deleteThread(id), () => applyDeleted(id)),
+    editReply: (id: string, replyId: string, body: string) => run(() => writes.editReply(id, replyId, body), applyThread),
+    deleteReply: (id: string, replyId: string) => run(() => writes.deleteReply(id, replyId), applyThread),
+  }), [run, writes, applyThread, applyDeleted, info.versionId]);
+
+  return {
+    name, setName, notice, dismissNotice,
+    threads: threads.threads, loaded: threads.loaded, invalid: threads.invalid || writeInvalid,
+    versionChanged: threads.versionChanged || writeVersionChanged,
+    actions,
+  };
+}
+
+export type ShareSession = ReturnType<typeof useShareSession>;
+export type ShareActions = ShareSession["actions"];

package/src/web/design-share-page/use-share-threads.ts

@@ -0,0 +1,139 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { fetchThreads, ShareApiError, type ShareFailure } from "./share-api";
+import { removeThread, upsertThread, type GuestThread } from "./share-thread-model";
+
+/**
+ * The link's threads, kept current by polling.
+ *
+ * Polling rather than a stream: a Cloudflare tunnel does not pass a closed connection on to
+ * the origin, so a stream per reviewer would never be let go. A poll goes out every
+ * {@link POLL_MS} while the page is visible, at once when it becomes visible again, and right
+ * after the reviewer's own write; `If-None-Match` makes an unchanged answer a bodiless 304.
+ * A 404 means the link stopped opening, and polling stops for good. An answer naming another
+ * version than the page's means the owner re-pinned the link: the page says so and keeps
+ * polling, since the threads are the link's and not the version's.
+ */
+
+export const POLL_MS = 10_000;
+export const MAX_BACKOFF_MS = 60_000;
+
+/**
+ * How long until the next poll, or null for none while the page is hidden. A server that
+ * asked for a wait gets at least that; failures in a row back off, doubling up to a minute.
+ */
+export function nextPollDelay(s: { visible: boolean; failures: number; retryAfterMs?: number }): number | null {
+  if (!s.visible) return null;
+  const backoff = Math.min(POLL_MS * 2 ** Math.max(0, s.failures), MAX_BACKOFF_MS);
+  return Math.max(backoff, s.retryAfterMs ?? 0);
+}
+
+export interface ShareThreadsState {
+  threads: GuestThread[];
+  loaded: boolean;
+  invalid: boolean;
+  /** The owner re-pinned the link since this page loaded, so it shows an old version. */
+  versionChanged: boolean;
+  /** Fold a write's answer in at once, then poll so everyone else's changes follow. */
+  applyThread: (thread: GuestThread) => void;
+  applyDeleted: (id: string) => void;
+  refresh: () => void;
+}
+
+/** Whether a poll's answer names another version than the one the page loaded. */
+export function repinnedSince(shown: string, reported: string | null): boolean {
+  return reported !== null && reported !== shown;
+}
+
+export function useShareThreads(
+  code: string, key: string, versionId: string, onFailure: (f: ShareFailure) => void,
+): ShareThreadsState {
+  const [threads, setThreads] = useState<GuestThread[]>([]);
+  const [loaded, setLoaded] = useState(false);
+  const [invalid, setInvalid] = useState(false);
+  const [versionChanged, setVersionChanged] = useState(false);
+  const etag = useRef<string | null>(null);
+  const timer = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const inFlight = useRef(false);
+  const again = useRef(false);
+  const failures = useRef(0);
+  const stopped = useRef(false);
+  const onFailureRef = useRef(onFailure);
+  onFailureRef.current = onFailure;
+  // The timer calls the current poll through this, so the two callbacks need not name each other.
+  const pollRef = useRef<() => Promise<void>>(async () => {});
+
+  const schedule = useCallback((retryAfterMs?: number) => {
+    if (timer.current) clearTimeout(timer.current);
+    timer.current = null;
+    if (stopped.current) return;
+    const delay = nextPollDelay({ visible: document.visibilityState === "visible", failures: failures.current, retryAfterMs });
+    if (delay !== null) timer.current = setTimeout(() => { void pollRef.current(); }, delay);
+  }, []);
+
+  const poll = useCallback(async () => {
+    if (stopped.current) return;
+    if (inFlight.current) { again.current = true; return; }
+    inFlight.current = true;
+    let retryAfterMs: number | undefined;
+    try {
+      const answer = await fetchThreads(code, key, etag.current);
+      failures.current = 0;
+      if (!answer.unchanged) {
+        etag.current = answer.etag;
+        setThreads(answer.threads);
+        if (repinnedSince(versionId, answer.versionId)) setVersionChanged(true);
+      }
+      setLoaded(true);
+    } catch (e) {
+      const failure: ShareFailure = e instanceof ShareApiError ? e.failure : { kind: "network" };
+      if (failure.kind === "invalid") {
+        stopped.current = true;
+        setInvalid(true);
+      } else {
+        failures.current++;
+        // A poll failing quietly is normal on a phone; only a wait the server asked for is news.
+        if (failure.kind === "rate-limited") {
+          retryAfterMs = failure.retryAfterMs;
+          onFailureRef.current(failure);
+        }
+      }
+    } finally {
+      inFlight.current = false;
+    }
+    if (again.current) {
+      again.current = false;
+      void poll();
+      return;
+    }
+    schedule(retryAfterMs);
+  }, [code, key, versionId, schedule]);
+  pollRef.current = poll;
+
+  useEffect(() => {
+    stopped.current = false;
+    void poll();
+    const onVisibility = () => {
+      if (document.visibilityState === "visible") void poll();
+      else schedule();
+    };
+    document.addEventListener("visibilitychange", onVisibility);
+    return () => {
+      stopped.current = true;
+      document.removeEventListener("visibilitychange", onVisibility);
+      if (timer.current) clearTimeout(timer.current);
+    };
+  }, [poll, schedule]);
+
+  const applyThread = useCallback((thread: GuestThread) => {
+    setThreads((list) => upsertThread(list, thread));
+    void poll();
+  }, [poll]);
+  const applyDeleted = useCallback((id: string) => {
+    setThreads((list) => removeThread(list, id));
+    void poll();
+  }, [poll]);
+
+  const refresh = useCallback(() => { void poll(); }, [poll]);
+
+  return { threads, loaded, invalid, versionChanged, applyThread, applyDeleted, refresh };
+}

package/src/web/hooks/use-chat.ts

@@ -15,6 +15,7 @@ import type { PromptCacheState } from "../../shared/prompt-cache-idle";
 import type { TurnStop } from "../../shared/turn-stop";
 import { decodeReply, encodeReply, type ReplyReference } from "../../shared/chat-reply";
 import { prefixTokens } from "../../shared/turn-usage";
+import { dbExecuteApprovalInput } from "../../shared/db-ai-tools";
 import type { ChatWsServerMessage, SessionPhase, BackgroundShell, VersionGroup } from "../../types/api";
 import { useBackgroundOutputStore } from "../stores/background-output-store";
 import { useSessionListStore } from "@/stores/session-list-store";
@@ -664,7 +665,9 @@ export function useChat(
       }
 
       case "approval_request": {
-        upsertStreamingEvent((e) => e.type === "approval_request" && (e as any).requestId === ev.requestId);
+        const dbApproval = dbExecuteApprovalInput(ev.tool, ev.input);
+        // A database change already has its db_execute card in the turn; its approval is only the prompt.
+        if (!dbApproval) upsertStreamingEvent((e) => e.type === "approval_request" && (e as any).requestId === ev.requestId);
         // During turn_events replay, session_state already set the correct
         // pendingApproval — skip re-setting it for historical (already-answered) events
         if (isReplayingRef.current) break;
@@ -681,7 +684,7 @@ export function useChat(
           const sid = sessionIdRef.current;
           const isQuestion = ev.tool === "AskUserQuestion";
           approvalToastRef.current = toast[isQuestion ? "info" : "warning"](
-            isQuestion ? "AI has a question" : `${ev.tool} needs permission`,
+            isQuestion ? "AI has a question" : dbApproval ? `AI wants to change ${dbApproval.connectionName}` : `${ev.tool} needs permission`,
             {
               description: projectNameRef.current || `Session ${sid.slice(0, 8)}`,
               duration: Infinity,

package/src/web/hooks/use-design-session-redirect.ts

@@ -11,7 +11,8 @@ import { openDesignTab } from "@/lib/design/open-design-tab";
  * not know the session is a design one — would otherwise take it out of design mode: no
  * canvas, and a history the design tab no longer owns. Asking once per session here covers
  * all of them, including ones added later, instead of trusting each caller to route itself.
- * The design tab is opened first (in the same panel) so the panel is never left empty.
+ * The design tab is opened first, in the same panel and kept there even where designs open in
+ * windows (`inPlace`), so the panel is never left empty.
  */
 export function useDesignSessionRedirect(input: {
   tabId?: string;
@@ -30,7 +31,7 @@ export function useDesignSessionRedirect(input: {
       .then(({ designSlug: slug }) => {
         if (cancelled || !slug) return;
         const panelId = usePanelStore.getState().getPanelForTab(tabId)?.id;
-        openDesignTab({ projectName, slug, sessionId, providerId, panelId });
+        openDesignTab({ projectName, slug, sessionId, providerId, panelId, inPlace: true });
         usePanelStore.getState().closeTab(tabId, panelId);
       })
       .catch(() => { /* an unknown session stays a plain chat */ });

package/src/web/hooks/use-git-repo.ts

@@ -1,15 +1,18 @@
 /**
- * The repository a git surface should talk to, and the two ways to address it.
+ * The repository a git surface should talk to, and the ways to address it.
  *
- * `gitUrl` builds a project-scoped git URL carrying the `repo=` scope, and
- * `repoPath` rebases a project-relative file path onto that repository. Between
- * them they cover both shapes of git route: the repo-scoped ones (status, log,
- * graph, worktrees) and the file-scoped ones (blame, hunks, file diff).
+ * `gitUrl` builds a project-scoped git URL carrying the `repo=` scope of the
+ * repository the panels are pointed at (status, log, graph, worktrees, and the
+ * hunks and staging that act on what those panels list).
+ *
+ * A call about one file — blame, a file's diff, a blob — goes through
+ * `fileScope` and `fileGitUrl` instead: a file has exactly one repository,
+ * whatever Source Control is pointed at.
  *
  * For a project that *is* a repository — nearly all of them — every URL this
- * returns is byte-identical to what the call site built before, and
- * `repoPath` is the identity. That is deliberate: the container-folder case
- * must not be able to regress the ordinary one.
+ * returns is byte-identical to what the call site built before, and every file
+ * path is unchanged. That is deliberate: the container-folder case must not be
+ * able to regress the ordinary one.
  */
 import { useCallback, useEffect, useMemo } from "react";
 import { projectUrl } from "@/lib/api-client";
@@ -19,9 +22,10 @@ import {
   needsPick,
   projectRelativePath,
   rebaseStatusPaths,
-  repoRelativePath,
+  fileGitScope,
   resolveRepo,
   withRepoParam,
+  type FileGitScope,
   type GitRepoCandidate,
   type StatusPaths,
 } from "@/lib/git-repo-scope";
@@ -39,8 +43,17 @@ export interface UseGitRepo {
   noRepo: boolean;
   /** `gitUrl("/status")`, `gitUrl("/graph?max=50")` — scope included. */
   gitUrl: (suffix: string) => string;
-  /** Project-relative → repository-relative; null when outside the repository. */
-  repoPath: (projectRelative: string) => string | null;
+  /**
+   * Where a call about this one file goes, regardless of the choice. `undefined`
+   * while discovery is pending, `null` when no repository holds the file.
+   */
+  fileScope: (projectRelative: string) => FileGitScope | null | undefined;
+  /**
+   * A git URL scoped to a `fileScope` answer's `repo` (`null`: no `repo=`). Its
+   * identity follows the project only, so an effect depending on it does not
+   * re-run when the choice changes.
+   */
+  fileGitUrl: (suffix: string, repo: GitRepoCandidate | null) => string;
   /** Repository-relative → project-relative, for paths git reported. */
   projectFile: (repoRelative: string) => string;
   /** A status answer with its paths in the project's terms, for the file tree. */
@@ -66,9 +79,15 @@ export function useGitRepo(projectName: string | undefined): UseGitRepo {
     [projectName, repo],
   );
 
-  const repoPath = useCallback(
-    (projectRelative: string) => repoRelativePath(projectRelative, repo),
-    [repo],
+  const fileScope = useCallback(
+    (projectRelative: string) => fileGitScope(discovery, projectRelative),
+    [discovery],
+  );
+
+  const fileGitUrl = useCallback(
+    (suffix: string, repo: GitRepoCandidate | null) =>
+      withRepoParam(`${projectUrl(projectName ?? "")}/git${suffix}`, repo),
+    [projectName],
   );
 
   const projectFile = useCallback(
@@ -113,12 +132,13 @@ export function useGitRepo(projectName: string | undefined): UseGitRepo {
       needsPick: needsPick(discovery, chosen),
       noRepo: hasNoRepo(discovery),
       gitUrl,
-      repoPath,
+      fileScope,
+      fileGitUrl,
       projectFile,
       rebaseStatus,
       choose,
       reload,
     }),
-    [repo, discovery, chosen, gitUrl, repoPath, projectFile, rebaseStatus, choose, reload],
+    [repo, discovery, chosen, gitUrl, fileScope, fileGitUrl, projectFile, rebaseStatus, choose, reload],
   );
 }

package/src/web/hooks/use-global-events.ts

@@ -7,6 +7,7 @@ import { useFileStore } from "@/stores/file-store";
 import { syncRunningSessions } from "@/lib/sync-running-sessions";
 import { syncAllKnownProjects } from "@/stores/session-list-sync-triggers";
 import { notifyGlobalReady, sendIfOpen, setGlobalWsClient } from "@/lib/global-ws-channel";
+import { SESSION_FILE_CHANGES_PUSH } from "../../shared/session-file-changes";
 
 /** How often the client pings — well under the server's own idle timeout, so a live but
  *  silent socket never gets reaped as dead. */
@@ -41,6 +42,8 @@ const IDLE_TIMEOUT_MS = 45_000;
  *   login URL/state, setup progress/done/pending/error).
  * - `git:*` → re-dispatched as window events (`git:changed` after any write PPM
  *   makes to a repository, `git:commit-draft` when the shared commit message changes).
+ * - `session:file-changes` → re-dispatched as a window event: the rows of the files the agent
+ *   just changed, for the changes bar of that session (`useSessionFileChanges`).
  * - `design:*` → re-dispatched as window events (`design:history_changed`,
  *   `design:comments_changed`). A design's `.design/` folder is not watched, so these
  *   are the only signal that its snapshots or comments changed.
@@ -147,6 +150,7 @@ export function useGlobalEvents(enabled: boolean, projectName?: string): void {
         || type.startsWith("agent-transcript:")
         || type.startsWith("logs:")
         || type === "agent-activity"
+        || type === SESSION_FILE_CHANGES_PUSH
       ) {
         window.dispatchEvent(new CustomEvent(type, { detail: data }));
       }

package/src/web/hooks/use-inline-blame.ts

@@ -108,14 +108,20 @@ export function useInlineBlame({
   // which is what those commands take. Looked up here rather than passed in, so
   // the three call sites do not each have to find it.
   const projectPath = useProjectStore((s) => s.projects.find((p) => p.name === projectName)?.path);
-  // Which repository the project's git actually lives in: itself, or a subfolder
-  // the user picked. Every path below is expressed relative to *that*, because
-  // that is where git runs.
-  const gitRepo = useGitRepo(projectName);
-  const gitRoot = gitRepo.repo?.path ?? projectPath;
-  // `null` means the open file is outside the chosen repository — there is
+  // The repository that holds *this file*: the project itself, or one of the
+  // checkouts in a container folder. Not the one picked in Source Control — a
+  // file has exactly one repository, and going by the pick left blame silent
+  // until the right one was chosen, or ran git in the container (not a
+  // repository) when nothing was. Every path below is relative to it, because
+  // that is where git runs. `fileRepo` null with a `repoFile` is a project
+  // inside a repository: git runs unscoped there, as it always did.
+  const { fileScope, fileGitUrl } = useGitRepo(projectName);
+  const scope = filePath ? fileScope(filePath) : null;
+  const fileRepo = scope?.repo ?? null;
+  const gitRoot = fileRepo?.path ?? projectPath;
+  // `null` while discovery is pending, or when no repository holds the file —
   // nothing to blame, which is a quiet no-annotation rather than an error.
-  const repoFile = filePath ? gitRepo.repoPath(filePath) : null;
+  const repoFile = scope?.path ?? null;
 
   const refresh = useCallback(() => setReloadToken((n) => n + 1), []);
 
@@ -140,7 +146,7 @@ export function useInlineBlame({
     const query = new URLSearchParams({ path: repoFile });
     if (rev) query.set("rev", rev);
     api
-      .get<BlameResult>(gitRepo.gitUrl(`/blame?${query}`))
+      .get<BlameResult>(fileGitUrl(`/blame?${query}`, fileRepo))
       .then((result) => {
         if (cancelled) return;
         setBlame(result);
@@ -153,7 +159,7 @@ export function useInlineBlame({
     return () => {
       cancelled = true;
     };
-  }, [enabled, projectName, filePath, repoFile, rev, reloadToken, gitRepo]);
+  }, [enabled, projectName, filePath, repoFile, rev, reloadToken, fileGitUrl, fileRepo]);
 
   // Follow the cursor, and notice edits.
   useEffect(() => {
@@ -247,7 +253,7 @@ export function useInlineBlame({
     let cancelled = false;
     const query = new URLSearchParams({ hash: detailHash, path: detailPath, line: String(detailLine) });
     api
-      .get<BlameLineDetail | null>(gitRepo.gitUrl(`/commit-line?${query}`))
+      .get<BlameLineDetail | null>(fileGitUrl(`/commit-line?${query}`, fileRepo))
       .then((result) => {
         if (cancelled) return;
         // Bounded: `tab-pool` keeps editors mounted for the life of the session,
@@ -264,7 +270,7 @@ export function useInlineBlame({
     return () => {
       cancelled = true;
     };
-  }, [enabled, projectName, detailHash, detailPath, detailLine, detailKey, gitRepo]);
+  }, [enabled, projectName, detailHash, detailPath, detailLine, detailKey, fileGitUrl, fileRepo]);
 
   // Draw it.
   useEffect(() => {

package/src/web/hooks/use-notification-clicks.ts

@@ -2,11 +2,15 @@ import { useEffect, useRef } from "react";
 import { useProjectStore } from "@/stores/project-store";
 import { useTabStore } from "@/stores/tab-store";
 import { hydrateWorkspaceFromServer } from "@/stores/panel-utils";
-import { autoOpenFromUrl } from "@/hooks/use-url-sync";
+import { autoOpenFromUrl, parseUrlState } from "@/hooks/use-url-sync";
 import { OPEN_FROM_NOTIFICATION, type OpenFromNotificationMessage } from "../../shared/web-push-payload";
 
-/** Show a notification's session in this window, the way a `?openChat=` link opens it at boot. */
-async function openNotifiedSession(projectName: string, sessionId: string, providerId: string): Promise<void> {
+/**
+ * Show a notification's session in this window, the way a `?openChat=` link opens it at boot.
+ * A notification about something other than a chat (a design a reviewer commented on) opens
+ * the tab its URL names, as that URL would at boot.
+ */
+async function openNotifiedSession(projectName: string, sessionId: string, providerId: string, url: string): Promise<void> {
   const target = useProjectStore.getState().projects.find((p) => p.name === projectName);
   if (!target) return;
   // Without a local copy of the layout, switching would create an empty one and overwrite the saved tabs.
@@ -14,7 +18,21 @@ async function openNotifiedSession(projectName: string, sessionId: string, provi
   useProjectStore.getState().setActiveProject(target);
   useTabStore.getState().switchProject(target.name);
   // `provider/session` as in a chat URL; without the provider the tab would open as Claude.
-  if (sessionId) autoOpenFromUrl("chat", providerId ? `${providerId}/${sessionId}` : sessionId, target.name);
+  if (sessionId) {
+    autoOpenFromUrl("chat", providerId ? `${providerId}/${sessionId}` : sessionId, target.name);
+    return;
+  }
+  const state = notifiedTab(url);
+  if (state?.tabType && state.projectName === target.name) autoOpenFromUrl(state.tabType, state.tabIdentifier, target.name);
+}
+
+function notifiedTab(url: string): ReturnType<typeof parseUrlState> | null {
+  try {
+    const parsed = new URL(url, window.location.href);
+    return parsed.origin === window.location.origin ? parseUrlState(parsed) : null;
+  } catch {
+    return null;
+  }
 }
 
 /**
@@ -35,7 +53,7 @@ export function useNotificationClicks(authenticated: boolean): void {
         if (new URL(message.url, window.location.href).origin === window.location.origin) window.location.assign(message.url);
         return;
       }
-      void openNotifiedSession(message.project ?? "", message.sessionId ?? "", message.providerId ?? "");
+      void openNotifiedSession(message.project ?? "", message.sessionId ?? "", message.providerId ?? "", message.url);
     };
     navigator.serviceWorker.addEventListener("message", onMessage);
     return () => navigator.serviceWorker.removeEventListener("message", onMessage);