V48 Gate 3 (specification-implementation): plural nav labels + selection always loads execution telemetry and resumed results

Nav: the route links now read 'Deposits' and 'Reads' (public nav +
footer links), matching the plural routes; action verbs elsewhere
(terminal actions, footer flow steps, docs prose) stay singular.

Master-detail selection contract hardened on both pages:
- Selecting ANY pipeline run adopts it into the Telemetry detail — a
  live run [re-]connects its stream, a historic run always replays its
  persisted events. Synthesis runs additionally resume synthesized
  options into review; other runs are a telemetry-only detail (kicker
  'Pipeline run') that completes without an options fetch.
- usePipelineExecution skips the SSE tail when the history row is
  already terminal (no more empty reconnect churn on historic rows).
- Terminal rows adopt AT their terminal status instead of passing
  through a transient 'running' that relabeled/disabled the Synthesize
  button and animated the orb until hydration; the resume effect now
  also runs from 'complete' while options are unloaded.
- An actively dispatched run owns the detail until the user actually
  changes selection (first liveRuns arrival can no longer re-point the
  detail at a historical row mid-dispatch).
- /reads: a completed run's persisted output surfaces a 'Synthesized
  AssetPacks' summary (option ids, titles, covered-path counts) with a
  'Review in Deposits' link into the /deposits review detail.

Tests: telemetry-only adoption on /deposits, synthesized-packs resume
on /reads, pluralized nav/footer assertions, URL-aware default history
mocks echoing the requested run id.

Spec: BITCODE_SPEC_V48_NOTES.md master-detail section extended with the
selection-always-loads contract + plural nav-label law.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: geraldarthurdavis

BITCODE_SPEC_V48_NOTES.md

@@ -533,6 +533,22 @@ become MASTER-DETAIL:
   fallback (completed rows without a completion event; interrupted rows via
   the orphan sweeper — 'interrupted' is now a terminal status for the SSE
   tail).
+- **Selection ALWAYS loads the execution's telemetry:** selecting ANY
+  pipeline run adopts it into the detail — a live run [re-]connects its
+  stream, a historic run replays its persisted events (the tail hook skips
+  the SSE tail entirely when the history row is already terminal). A
+  synthesis run additionally resumes its synthesized AssetPack options into
+  review; any other run is a telemetry-only detail (kicker 'Pipeline run')
+  that completes without an options fetch. Terminal rows adopt AT their
+  terminal status — never through a transient 'running' (which would
+  disable the dispatch button and animate the orb until hydration). An
+  actively dispatched run owns the detail until the user actually changes
+  selection. On /reads, a completed run's persisted output additionally
+  surfaces a 'Synthesized AssetPacks' summary linking back to the /deposits
+  review detail.
+- **Nav route labels are plural** ('Deposits', 'Reads') — matching the
+  routes they open; action verbs elsewhere (terminal actions, footer flow
+  steps, docs prose) stay singular.
 - **Known read-gate gap:** read-lens pipeline runs dispatched through the
   sandbox harness do not yet persist their own lens-stamped executions rows
   (structured mode); the /reads table lists what exists and the telemetry

uapi/app/deposits/DepositPageClient.tsx

@@ -155,6 +155,11 @@ export default function DepositPageClient() {
   const [protectedIpExclusionsText, setProtectedIpExclusionsText] = useState("");
   const [optionsRequested, setOptionsRequested] = useState(false);
   const [synthesisRunId, setSynthesisRunId] = useState<string | null>(null);
+  // Whether the attached run is an option synthesis (its completed output
+  // carries synthesized AssetPack options to resume into review) or any
+  // other pipeline execution (telemetry-only detail).
+  const [synthesisRunExpectsOptions, setSynthesisRunExpectsOptions] =
+    useState(true);
   // Master-detail pipelines table: lens-preset filters + pagination for the
   // Deposits run table (selection itself lives in the URL transactionId).
   const [pipelineFilters, setPipelineFilters] = useState<TransactionFilters>({
@@ -616,7 +621,16 @@ export default function DepositPageClient() {
   // streamed run completes, read the persisted synthesis from the execution row
   // output and surface the reviewable options; a streamed error fails the run.
   useEffect(() => {
-    if (synthesisStatus !== "running" || !synthesisRunId || realSynthesis) return;
+    // Runs while a run is attached and its results are not resumed yet:
+    // 'running' covers live tails, 'complete' covers adopted terminal rows
+    // whose persisted output still needs loading (realSynthesis guards
+    // against re-fetch loops once the options are in).
+    if (
+      (synthesisStatus !== "running" && synthesisStatus !== "complete") ||
+      !synthesisRunId ||
+      realSynthesis
+    )
+      return;
     // A hook-level fetch error (history unavailable) fails the run outright;
     // an event-derived error counts only once the events are attributed to
     // THIS run (execution match) — otherwise a previously selected run's
@@ -635,6 +649,12 @@ export default function DepositPageClient() {
       String((synthesisExecution as { status?: string } | null)?.status || "").toLowerCase() ===
       "completed";
     if (!synthesisActivity.isStreamingComplete && !rowCompleted) return;
+    if (!synthesisRunExpectsOptions) {
+      // Telemetry-only run (not an option synthesis): the replayed history
+      // IS the resumed result — freeze the clock, nothing to load.
+      setSynthesisStatus("complete");
+      return;
+    }
     let cancelled = false;
     void (async () => {
       try {
@@ -674,6 +694,7 @@ export default function DepositPageClient() {
   }, [
     synthesisStatus,
     synthesisRunId,
+    synthesisRunExpectsOptions,
     realSynthesis,
     synthesisActivity.isStreamingComplete,
     synthesisActivity.error,
@@ -701,27 +722,36 @@ export default function DepositPageClient() {
     }
   }, [liveRuns, synthesisRunId, synthesisStatus]);
 
-  // Master-detail adoption: selecting a synthesis pipeline run in the table
-  // connects the Telemetry + Options detail to it. A RUNNING run reattaches
-  // its live stream (usePipelineExecution tails any runId); a COMPLETED run
-  // resumes its persisted results through the same completion effect (its
-  // history already carries the terminal event, so the effect resolves
-  // immediately); a failed/interrupted run surfaces its terminal state with
-  // the historical log attached. Adoption fires only on SELECTION-ID
-  // transitions: a fresh dispatch changes synthesisRunId while the URL
-  // selection is still the previous run, and re-adopting that stale
-  // selection would clobber the just-dispatched run.
+  // Master-detail adoption: selecting ANY pipeline run in the table connects
+  // the Telemetry detail to it. A RUNNING run reattaches its live stream
+  // (usePipelineExecution tails any runId); a COMPLETED run replays its
+  // persisted history, and a synthesis run additionally resumes its
+  // synthesized options into review through the completion effect; a
+  // failed/interrupted run surfaces its terminal state with the historical
+  // log attached. Adoption fires only on SELECTION-ID transitions: a fresh
+  // dispatch changes synthesisRunId while the URL selection is still the
+  // previous run, and re-adopting that stale selection would clobber the
+  // just-dispatched run.
   const lastAdoptedSelectionIdRef = useRef<string | null>(null);
   useEffect(() => {
     const run = selectedRun;
-    if (!run?.id || run.contextSource !== "deposit-option-synthesis") {
-      lastAdoptedSelectionIdRef.current = run?.id ?? null;
+    if (!run?.id) {
+      lastAdoptedSelectionIdRef.current = null;
       return;
     }
     if (lastAdoptedSelectionIdRef.current === run.id) return;
     lastAdoptedSelectionIdRef.current = run.id;
     if (run.id === synthesisRunId) return;
+    // An actively dispatched run owns the detail until the user actually
+    // changes selection — the FIRST liveRuns arrival after a fast dispatch
+    // must not re-point the detail at a historical row.
+    if (synthesisDispatchedAtMs !== null && synthesisStatus === "running") {
+      return;
+    }
     setSynthesisRunId(run.id);
+    setSynthesisRunExpectsOptions(
+      run.contextSource === "deposit-option-synthesis",
+    );
     setSynthesisDispatchedAtMs(null);
     setSynthesisLogScrolled(false);
     setRealSynthesis(null);
@@ -733,10 +763,16 @@ export default function DepositPageClient() {
       setSynthesisError(
         run.summary ? `Run ${status} — ${run.summary}` : `Run ${status}.`,
       );
+    } else if (status === "completed") {
+      // Adopt a completed row AT its terminal status — never pass through a
+      // transient 'running' (it would relabel/disable the dispatch button
+      // and animate the orb until the tail hydrates). The completion effect
+      // also resumes from 'complete' while options are not loaded yet.
+      setSynthesisStatus("complete");
     } else {
       setSynthesisStatus("running");
     }
-  }, [selectedRun, synthesisRunId]);
+  }, [selectedRun, synthesisRunId, synthesisDispatchedAtMs, synthesisStatus]);
 
   const sessionRows = [
     {
@@ -885,6 +921,7 @@ export default function DepositPageClient() {
         ? crypto.randomUUID()
         : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
     setSynthesisRunId(runId);
+    setSynthesisRunExpectsOptions(true);
     setSynthesisDispatchedAtMs(Date.now());
     setSynthesisLogScrolled(false);
 
@@ -955,13 +992,16 @@ export default function DepositPageClient() {
     synthesizeOptionsRef.current = handleSynthesizeOptions;
   }, [handleSynthesizeOptions]);
 
+  // Auto-scroll to Telemetry only for DISPATCHED runs (dispatch stamps the
+  // timestamp; table adoption clears it) — adopting a row on page load or a
+  // table click must not yank the viewport away from where the user is.
   useEffect(() => {
-    if (!synthesisRunId) return;
+    if (!synthesisRunId || synthesisDispatchedAtMs === null) return;
     synthesisTelemetryRef.current?.scrollIntoView?.({
       behavior: "smooth",
       block: "start",
     });
-  }, [synthesisRunId]);
+  }, [synthesisRunId, synthesisDispatchedAtMs]);
 
   // Secondary per-option actions only: Archive (rejected-by-depositor) and
   // Resynthesize. Approval/deposit is a single batch call (handleDepositSelected).
@@ -1450,7 +1490,9 @@ export default function DepositPageClient() {
                 <div className="flex flex-wrap items-center justify-between gap-3">
                   <div className="min-w-0">
                     <p className="text-[0.68rem] uppercase tracking-[0.22em] text-emerald-200/80">
-                      Asset Pack Synthesis
+                      {synthesisRunExpectsOptions
+                        ? "Asset Pack Synthesis"
+                        : "Pipeline run"}
                     </p>
                     <h2 className="mt-2 flex items-center gap-2 text-lg font-semibold text-white">
                       <span>Telemetry</span>

uapi/app/reads/ReadPageClient.tsx

@@ -109,6 +109,16 @@ export default function ReadPageClient() {
   // Telemetry error dismissal is per selected run.
   const [dismissedTelemetryErrorRunId, setDismissedTelemetryErrorRunId] =
     useState<string | null>(null);
+  // Resumed results for a COMPLETED selected run: its persisted output may
+  // carry synthesized AssetPack options (a synthesis run selected here).
+  const [selectedRunPacks, setSelectedRunPacks] = useState<{
+    runId: string;
+    options: Array<{
+      optionId: string;
+      title: string;
+      coveredSourcePathCount: number;
+    }>;
+  } | null>(null);
 
   const readCurrentSearchParams = useCallback(
     () =>
@@ -227,6 +237,61 @@ export default function ReadPageClient() {
     return Number.isFinite(parsed) ? parsed : null;
   }, [readRunEvents, readRunIsProcessing]);
 
+  // Resume a completed run's synthesized AssetPacks: load the persisted
+  // output and summarize the options alongside the replayed telemetry (the
+  // full review/admission detail lives on /deposits). Best-effort — a run
+  // without synthesized options simply shows telemetry only.
+  useEffect(() => {
+    setSelectedRunPacks(null);
+    if (!selectedPipelineRunId || selectedRun?.status !== "completed") return;
+    let cancelled = false;
+    void (async () => {
+      try {
+        const res = await fetch(
+          `/api/executions/history/${selectedPipelineRunId}`,
+        );
+        const data = await res.json().catch(() => null);
+        if (cancelled || !res?.ok) return;
+        const output = data?.run?.output as {
+          depositOptionSynthesis?: {
+            options?: Array<{ optionId?: string; title?: string }>;
+          };
+          reviewProjections?: Array<{
+            optionId?: string;
+            title?: string;
+            coveredSourcePaths?: string[];
+          }>;
+        } | null;
+        const projections = Array.isArray(output?.reviewProjections)
+          ? output.reviewProjections
+          : [];
+        const fallback = Array.isArray(output?.depositOptionSynthesis?.options)
+          ? output.depositOptionSynthesis.options
+          : [];
+        const options = (projections.length > 0 ? projections : fallback)
+          .map((option) => ({
+            optionId: String(option?.optionId || ""),
+            title: String(option?.title || "Untitled AssetPack option"),
+            coveredSourcePathCount: Array.isArray(
+              (option as { coveredSourcePaths?: string[] })
+                ?.coveredSourcePaths,
+            )
+              ? (option as { coveredSourcePaths: string[] })
+                  .coveredSourcePaths.length
+              : 0,
+          }))
+          .filter((option) => option.optionId);
+        if (cancelled || options.length === 0) return;
+        setSelectedRunPacks({ runId: selectedPipelineRunId, options });
+      } catch {
+        // Telemetry replay stands on its own; the packs summary is additive.
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [selectedPipelineRunId, selectedRun?.status]);
+
   const depositedSourceRevision =
     useMemo<TerminalDepositedSourceRevision | null>(() => {
       const selectedRepository = repositoryContext?.selectedRepository || null;
@@ -743,6 +808,40 @@ export default function ReadPageClient() {
                 }}
               />
             </div>
+            {selectedRunPacks?.runId === selectedPipelineRunId ? (
+              <div
+                data-testid="reads-synthesized-packs"
+                className="mt-4 border border-emerald-300/15 bg-emerald-300/[0.05] px-3 py-3"
+              >
+                <p className="font-mono text-[0.62rem] uppercase tracking-[0.16em] text-emerald-200/80">
+                  Synthesized AssetPacks · {selectedRunPacks.options.length}
+                </p>
+                <ul className="mt-2 space-y-1 text-sm leading-6 text-neutral-200">
+                  {selectedRunPacks.options.map((option) => (
+                    <li
+                      key={option.optionId}
+                      className="flex flex-wrap items-baseline gap-x-3 gap-y-1"
+                    >
+                      <span className="font-mono text-[0.68rem] text-neutral-500">
+                        {option.optionId}
+                      </span>
+                      <span>{option.title}</span>
+                      {option.coveredSourcePathCount > 0 ? (
+                        <span className="text-xs text-neutral-500">
+                          {option.coveredSourcePathCount} source paths
+                        </span>
+                      ) : null}
+                    </li>
+                  ))}
+                </ul>
+                <Link
+                  href={`/deposits?transactionId=${encodeURIComponent(selectedRunPacks.runId)}&depositStage=review-options`}
+                  className="mt-3 inline-flex items-center border border-emerald-300/20 bg-emerald-300/10 px-3 py-2 text-xs font-medium text-emerald-100 transition hover:border-emerald-200/40 hover:bg-emerald-300/15"
+                >
+                  Review in Deposits
+                </Link>
+              </div>
+            ) : null}
           </section>
         ) : null}
 

uapi/components/base/bitcode/layout/bitcode-public-copy.ts

@@ -105,8 +105,8 @@ export const BITCODE_PUBLIC_COPY = {
     userCta: 'Open Auxillaries',
     links: {
       network: 'Packs',
-      deposit: 'Deposit',
-      read: 'Read',
+      deposit: 'Deposits',
+      read: 'Reads',
       transactions: 'Packs',
       docs: 'Docs',
       github: 'Bitcode on GitHub',
@@ -115,8 +115,8 @@ export const BITCODE_PUBLIC_COPY = {
   publicNav: {
     links: [
       { href: '/packs', label: 'Packs' },
-      { href: '/deposits', label: 'Deposit' },
-      { href: '/reads', label: 'Read' },
+      { href: '/deposits', label: 'Deposits' },
+      { href: '/reads', label: 'Reads' },
       { href: '/docs', label: 'Docs' },
     ],
     guestPrimaryCta: 'Open Auxillaries',

uapi/hooks/usePipelineExecution.ts

@@ -95,6 +95,19 @@ export function usePipelineExecution(runId: string | null): UsePipelineExecution
         // initial history hydration, not the tail's lifetime.
         setIsLoading(false);
 
+        // A terminal row's history IS the complete telemetry: replay it
+        // without opening the live tail (the run can produce no further
+        // events, so the tail would only burn empty reconnects).
+        const rowStatus = String((data.run as { status?: string } | null)?.status || '').toLowerCase();
+        if (
+          rowStatus === 'completed' ||
+          rowStatus === 'failed' ||
+          rowStatus === 'interrupted' ||
+          rowStatus === 'cancelled'
+        ) {
+          return;
+        }
+
         try {
           const last = (data.events || []).slice(-1)[0];
           let cursorTs = last?.created_at || '';

uapi/tests/depositPageClient.test.tsx

@@ -171,7 +171,28 @@ describe("DepositPageClient", () => {
         items: [],
       },
     ]);
-    global.fetch = jest.fn();
+    // Selecting any pipeline run adopts it into the Telemetry detail, whose
+    // tail hydrates from the history endpoint — the default mock answers
+    // those with a bare completed row (echoing the requested id) so tests
+    // that never dispatch still settle cleanly.
+    global.fetch = jest.fn((input: unknown) => {
+      const url = String(input);
+      if (url.includes("/api/executions/history/")) {
+        return Promise.resolve({
+          ok: true,
+          status: 200,
+          json: async () => ({
+            run: { id: url.split("/").pop(), status: "completed", output: {} },
+            events: [],
+          }),
+        });
+      }
+      return Promise.resolve({
+        ok: false,
+        status: 404,
+        json: async () => null,
+      });
+    }) as unknown as typeof fetch;
   });
 
   afterEach(() => {
@@ -897,4 +918,23 @@ describe("DepositPageClient", () => {
     const alert = await screen.findByRole("alert");
     expect(alert).toHaveTextContent("Repository ownership check failed.");
   });
+
+  it("adopts a selected non-synthesis pipeline run as a telemetry-only detail (no options, no failure)", async () => {
+    // Default fixtures: selection deposit-1, a COMPLETED composer run (not an
+    // option synthesis). Selecting it must attach its replayed telemetry at
+    // its terminal status without attempting an options resume.
+    render(<DepositPageClient />);
+
+    const telemetry = await screen.findByTestId("deposit-synthesis-telemetry");
+    expect(telemetry).toHaveTextContent("Pipeline run");
+    expect(telemetry).not.toHaveTextContent("Asset Pack Synthesis");
+    expect(telemetry).toHaveTextContent("deposit-1");
+    await waitFor(() =>
+      expect(screen.getByTestId("pipeline-execution-log")).toHaveAttribute(
+        "data-processing",
+        "false",
+      ),
+    );
+    expect(screen.queryByRole("alert")).not.toBeInTheDocument();
+  });
 });