@@ -70,11 +70,23 @@ export async function captureNotebookArtifacts(projectId: string, artifacts: str
   return out;
 }
 
+/**
+ * Readers (and the Methods draft, which quotes these) see prose, not codes.
+ * "unsafe-path" mostly means an internal file such as uv.lock or a dot-path,
+ * which reads as a security problem when shown verbatim.
+ */
+const INCOMPLETE_CHECK: Record<Exclude<NonNullable<Check["reason"]>, "missing">, string> = {
+  "unsafe-path": "not a user-visible sandbox file (internal files such as uv.lock or dot-paths, and symlinks leaving the sandbox, are not checked)",
+  unreadable: "the file could not be read",
+  budget: "the check budget for this read was exhausted",
+  "changed-during-check": "the file changed while it was being hashed",
+};
+
 /** Pure comparison. Missing hashes and harvest-time identities never earn unchanged. */
 export function compareNotebookArtifact(recorded: NotebookArtifactSnapshot | undefined, current: Check): NotebookArtifactHealth {
   const base = { path: current.path, checkedAt: current.capturedAt };
   if (current.reason === "missing") return { ...base, status: "missing", reason: "Cited artifact is missing. Review this entry; this does not refute its claim." };
-  if (current.reason) return { ...base, status: "unverified", reason: `Artifact check incomplete: ${current.reason}.` };
+  if (current.reason) return { ...base, status: "unverified", reason: `Artifact check incomplete: ${INCOMPLETE_CHECK[current.reason] ?? current.reason}.` };
   if (recorded?.sha256 && current.sha256) {
     if (recorded.sha256 !== current.sha256) return { ...base, status: "changed", reason: recorded.timing === "harvest" ? "Bytes changed since a later identity check; original citation-time bytes are unknown." : recorded.timing === "output" ? "Bytes differ from the server-recorded compute output. Review against the retained result." : "Bytes differ from the recorded citation. Review the interpretation against the new artifact." };
     if (recorded.timing === "entry" || recorded.timing === "output") return { ...base, status: "unchanged", reason: recorded.timing === "output" ? "Bytes match the server-recorded compute output. This does not verify scientific validity or unchanged upstream inputs." : "Bytes match the citation-time hash. This does not verify scientific validity or unchanged upstream inputs." };
 
@@ -6,7 +6,7 @@
  * This file is the authoritative source of truth for reload and export;
  * the live SSE `tool_start` frame is only a provisional mirror.
  */
-import type { NotebookEvidenceLink, NotebookOutcome, NotebookArtifactSnapshot, NotebookArtifactHealth } from "../../../web/src/lib/notebook-evidence-core.ts";
+import { localizeEvidenceLinks, type NotebookEvidenceLink, type NotebookOutcome, type NotebookArtifactSnapshot, type NotebookArtifactHealth } from "../../../web/src/lib/notebook-evidence-core.ts";
 import type { AnalysisPlanInput, AnalysisPlanHistory } from "../../../web/src/lib/notebook-plans.ts";
 import type { NotebookResultLink, NotebookResultSnapshot } from "../../../web/src/lib/notebook-result-links.ts";
 import type { RobustnessDraft } from "../../../web/src/lib/notebook-robustness.ts";
@@ -158,7 +158,7 @@ export function readNotebookEntries(
   sessionId: string,
   projectId?: string,
 ): NotebookEntry[] {
-  return parseNotebookFile(notebookPath(sessionId, projectId));
+  return localizeEvidenceLinks(parseNotebookFile(notebookPath(sessionId, projectId)), sessionId);
 }
 
 export interface SessionNotebook {
@@ -182,7 +182,7 @@ export function readProjectNotebooks(projectId: string): SessionNotebook[] {
     if (!f.endsWith(".jsonl")) continue;
     const sessionId = f.slice(0, -".jsonl".length);
     if (!isValidSessionId(sessionId)) continue;
-    out.push({ sessionId, entries: parseNotebookFile(path.join(dir, f)) });
+    out.push({ sessionId, entries: localizeEvidenceLinks(parseNotebookFile(path.join(dir, f)), sessionId) });
   }
   return out;
 }
@@ -49,6 +49,12 @@ describe("notebook artifact verification", () => {
     const checks = await captureNotebookArtifacts("default", ["../../outside.txt", ".pi/auth.json", "AGENTS.md"]);
     expect(checks.every((c) => c.reason === "unsafe-path" && !c.sha256)).toBe(true);
   });
+  it("explains an incomplete check in words, not the internal reason code", () => {
+    const health = compareNotebookArtifact(undefined, { path: "uv.lock", capturedAt: 1, reason: "unsafe-path" });
+    expect(health.status).toBe("unverified");
+    expect(health.reason).toMatch(/not a user-visible sandbox file/);
+    expect(health.reason).not.toMatch(/unsafe-path/);
+  });
   it.skipIf(process.platform === "win32")("does not follow symlinks outside the sandbox or into hidden files", async () => {
     write();
     const outside = path.join(PROJECTS_ROOT, "secret.txt"); fs.writeFileSync(outside, "secret");
 
@@ -99,6 +99,16 @@ describe("GET /sessions/:id/notebook/export", () => {
     expect(resPdf.json().detail).toMatch(/format must be md, json, or zip/);
   });
 
+  it("resolves a link that names its own session and counts it as evidence", async () => {
+    appendNotebookEntry("route-own", entry({ id: "h", type: "hypothesis", title: "Claim", timestamp: 1 }), "default");
+    appendNotebookEntry("route-own", entry({ id: "pipeline:o", type: "observation", title: "Finding", timestamp: 2, role: "pipeline",
+      evidence: [{ entryId: "h", sessionId: "route-own", relation: "supports" }] }), "default");
+    const md = await app.inject({ method: "GET", url: "/sessions/route-own/notebook/export?format=md", headers: { "x-project-id": "default" } });
+    expect(md.body).toContain("_↳ supports “Claim” (h)_");
+    expect(md.body).not.toContain("unavailable in this export");
+    expect(md.body).toContain("**Evidence status:** Supporting evidence");
+  });
+
   it("returns a JSON download with format=json", async () => {
     appendNotebookEntry("route-json", entry({ id: "tc_1" }), "default");
     appendNotebookEntry("route-json", entry({ id: "tc_2", type: "observation" }), "default");
 
@@ -63,6 +63,20 @@ describe("notebook-store", () => {
     expect("relatesTo" in got[1]).toBe(false);
     expect("runId" in got[1]).toBe(false);
   });
+  it("treats a link naming its own session as a same-chat link", () => {
+    // Specialists copy session ids from notebook_search, so harvested rows can
+    // spell out the parent chat; keyed by bare id, those links resolved to nothing.
+    const s = "sess-store-own";
+    appendNotebookEntry(s, entry({ id: "obs", evidence: [
+      { entryId: "tc_1", sessionId: s, relation: "supports" },
+      { entryId: "tc_9", sessionId: "sess-other", relation: "context" },
+    ] }));
+    expect(readNotebookEntries(s)[0].evidence).toEqual([
+      { entryId: "tc_1", relation: "supports" },
+      { entryId: "tc_9", sessionId: "sess-other", relation: "context" },
+    ]);
+    expect(readProjectNotebooks("default").find((n) => n.sessionId === s)!.entries[0].evidence![0]).toEqual({ entryId: "tc_1", relation: "supports" });
+  });
 });
 
 describe("appendNewNotebookEntries", () => {
 
@@ -815,6 +815,9 @@ function WorkspacePage({
   // ------------------------------------------------------------------
 
   const activeSessionId = activeMeta?.sessionId ?? null;
+  // A jump targets the chat it came from; a notebook view remounting under
+  // another chat must not replay it ("That notebook entry isn't in this chat").
+  useEffect(() => { setNotebookFocus(null); }, [activeSessionId]);
   const {
     activeCount: activeModalJobCount,
     loading: modalJobsLoading,
 
@@ -504,6 +504,53 @@ describe("LabNotebookView", () => {
     ).toBe(true);
   });
 
+  it("relabels the project view when a chat appears after the first label lookup", async () => {
+    // The view usually mounts before the project's first chat exists; the
+    // divider then showed the raw session id for the rest of the visit.
+    let chats: unknown[] = [];
+    let entries: NotebookEntry[] = [];
+    routeFetch((url) => {
+      if (url === "/projects/default/notebook") return okJson({ entries });
+      if (url === "/sessions") return okJson(chats);
+    });
+    const { rerender } = rtlRender(<LabNotebookView {...baseProps} sessionId={null} />);
+    await waitFor(() => expect(spy.mock.calls.some(([u]) => u === "/sessions")).toBe(true));
+    chats = [{ id: "sNew", firstMessage: "fit the dose curve" }];
+    entries = [e({ id: "p1", title: "Fresh entry", sessionId: "sNew" })];
+    rerender(<LabNotebookView {...baseProps} sessionId="sNew" streaming />);
+    await waitFor(() => expect(screen.getByText("Fresh entry")).toBeInTheDocument());
+    await waitFor(() => expect(screen.getByText("fit the dose curve")).toBeInTheDocument());
+  });
+
+  it("counts a live link that names its own chat as same-chat evidence", () => {
+    render(<LabNotebookView {...baseProps} liveEntries={[
+      e({ id: "h", title: "Claim" }),
+      e({ id: "o", type: "observation", title: "Finding", evidence: [{ entryId: "h", sessionId: "s1", relation: "supports" }] }),
+    ]} />);
+    expect(screen.queryByText(/not in this view/)).not.toBeInTheDocument();
+    expect(screen.getByText("Supporting evidence")).toBeInTheDocument();
+  });
+
+  it("does not replay a handled focus jump when the scope or chat changes", async () => {
+    const orig = Element.prototype.scrollIntoView;
+    const scrollSpy = vi.fn();
+    Element.prototype.scrollIntoView = scrollSpy;
+    try {
+      const focusEntry = { id: "tc_1", token: 7 };
+      const { rerender } = render(<LabNotebookView {...baseProps} liveEntries={[e({})]} focusEntry={focusEntry} />);
+      await waitFor(() => expect(scrollSpy).toHaveBeenCalled());
+      scrollSpy.mockClear();
+      fireEvent.click(screen.getByRole("button", { name: "All chats" }));
+      fireEvent.click(screen.getByRole("button", { name: "This chat" }));
+      rerender(<LabNotebookView {...baseProps} sessionId="s2" liveEntries={[]} focusEntry={focusEntry} />);
+      await new Promise((r) => setTimeout(r, 50));
+      expect(scrollSpy).not.toHaveBeenCalled();
+      expect(toast.error).not.toHaveBeenCalled();
+    } finally {
+      Element.prototype.scrollIntoView = orig;
+    }
+  });
+
   it("saves the methods draft without interrupting notebook work and offers an explicit open action", async () => {
     const user = userEvent.setup();
     routeFetch((url) => {
 
@@ -11,6 +11,7 @@ import {
   notebookEntryKey,
   type NotebookEntry,
 } from "@/lib/notebook";
+import { localizeEvidenceLinks } from "@/lib/notebook-evidence-core";
 import { deriveThreads } from "@/lib/notebook-threads";
 import {
   countByType,
@@ -133,6 +134,14 @@ export function LabNotebookView({
     addNote,
   } = useNotebookAnnotations(sessionId, canAnnotate, scopedProjectId);
 
+  // Re-read labels when a chat appears that the last lookup could not have
+  // named (the view usually mounts before the project's first chat exists).
+  const labelledSessionsKey = useMemo(() => {
+    const ids = new Set(projectData.entries.map((e) => e.sessionId).filter((id): id is string => Boolean(id)));
+    if (sessionId) ids.add(sessionId);
+    return [...ids].sort().join("\n");
+  }, [projectData.entries, sessionId]);
+
   // Labels are cosmetic; a failed label lookup must not hide notebook data.
   useEffect(() => {
     if (scope !== "project") return;
@@ -155,7 +164,7 @@ export function LabNotebookView({
       }
     })();
     return () => { cancelled = true; };
-  }, [scope, scopedProjectId]);
+  }, [scope, scopedProjectId, labelledSessionsKey]);
 
   // User notes render as synthetic entries so they flow through the timeline.
   const noteEntries = useMemo<NotebookEntry[]>(
@@ -172,9 +181,11 @@ export function LabNotebookView({
   );
 
   // Authoritative (fetched) entries win over provisional (live) ones by id.
+  // The server localizes fetched rows; provisional tool frames still carry
+  // the raw links until the refetch lands.
   const sessionEntries = useMemo(
-    () => mergeNotebookEntries(mergeNotebookEntries(liveEntries, fetched), noteEntries),
-    [liveEntries, fetched, noteEntries],
+    () => mergeNotebookEntries(mergeNotebookEntries(sessionId ? localizeEvidenceLinks(liveEntries, sessionId) : liveEntries, fetched), noteEntries),
+    [liveEntries, fetched, noteEntries, sessionId],
   );
   // The project stream has no separate SSE channel. Overlay this chat's live
   // entries immediately, then let authoritative project rows win by scoped id.
@@ -250,7 +261,10 @@ export function LabNotebookView({
 
   // --- Deep-link focus (chat → notebook, and thread-reference jumps) ---
   const pendingFocusRef = useRef<string | null>(null);
-  const memorySuppressedFocusToken = useRef<number | undefined>(undefined);
+  // A chat-side jump is one request: once handled, switching scope or chat
+  // must not replay it (that scrolled to a stale entry, or toasted "isn't in
+  // this chat's notebook" for an entry in the previous chat).
+  const handledFocusToken = useRef<number | undefined>(undefined);
   const focusTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
 
   const tryFocus = useCallback(() => {
@@ -299,10 +313,11 @@ export function LabNotebookView({
 
   const focusToken = focusEntry?.token;
   useEffect(() => {
-    if (focusEntry && focusToken !== undefined && focusToken !== memorySuppressedFocusToken.current) focusById(scope === "project" && sessionId
-      ? notebookEntryKey({ id: focusEntry.id, sessionId }) : focusEntry.id);
+    if (!focusEntry || focusToken === undefined || focusToken === handledFocusToken.current) return;
+    handledFocusToken.current = focusToken;
+    focusById(scope === "project" && sessionId ? notebookEntryKey({ id: focusEntry.id, sessionId }) : focusEntry.id);
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [focusToken, scope, sessionId]);
+  }, [focusToken]);
 
   // Retry pending focus whenever the rendered set changes (refetch landing).
   useEffect(() => {
@@ -430,7 +445,6 @@ export function LabNotebookView({
       <LabNotebookHeader
         packageControl={<EvidencePackageDialog projectId={scopedProjectId} candidates={displayEntries.filter((e) => !e.provisional && ["hypothesis", "method", "observation", "decision"].includes(e.type) && (e.sessionId ?? sessionId)).map((e) => ({ sessionId: e.sessionId ?? sessionId!, entryId: e.id, title: e.title, type: e.type }))} />}
         memory={<NotebookMemoryDialog projectId={scopedProjectId} activeSessionId={sessionId} onOpenFile={onOpenFile} onJump={(source) => {
-          memorySuppressedFocusToken.current = focusToken;
           if (source.kind === "user-note") {
             if (source.sessionId !== sessionId) return;
             setScope("session");
 
@@ -70,6 +70,27 @@ export function notebookTargetKey(entry: { sessionId?: string }, id: string, ses
   return notebookEntryKey({ id, sessionId: sessionId ?? entry.sessionId });
 }
 
+/**
+ * Drop a link's `sessionId` when it names the chat the entries came from.
+ * Session views key entries by bare id, so a link spelling out its own chat
+ * (specialists copy it from notebook_search; proposal targets always carry
+ * it) would otherwise resolve to nothing and silently stop counting as
+ * evidence. An omitted sessionId already means "this chat", so this is lossless.
+ */
+export function localizeEvidenceLinks<T extends { evidence?: NotebookEvidenceLink[] }>(entries: T[], sessionId: string): T[] {
+  return entries.map((entry) => {
+    if (!Array.isArray(entry.evidence) || !entry.evidence.some((link) => link?.sessionId === sessionId)) return entry;
+    return {
+      ...entry,
+      evidence: entry.evidence.map((link) => {
+        if (link?.sessionId !== sessionId) return link;
+        const { sessionId: _own, ...local } = link;
+        return local;
+      }),
+    };
+  });
+}
+
 /** Defensive parsing for old files and provisional tool frames. */
 export function normalizeEvidenceLinks(value: unknown): NotebookEvidenceLink[] {
   if (!Array.isArray(value)) return [];