diff --git a/e2e/workspace-collaboration.spec.ts b/e2e/workspace-collaboration.spec.ts
index 8671c2a17..c9b23392d 100644
--- a/e2e/workspace-collaboration.spec.ts
+++ b/e2e/workspace-collaboration.spec.ts
@@ -3,6 +3,7 @@ import { expect, test, type Browser, type BrowserContext, type Page } from "@pla
 import { spawn, type ChildProcess } from "node:child_process";
 import { createConnection } from "node:net";
 import { kill as killProcess } from "node:process";
+import type { WorkspaceToolContext } from "../src/lib/workspace/tool-context";
 
 const supabaseUrl = process.env.LOCAL_SUPABASE_URL;
 const anonKey = process.env.LOCAL_SUPABASE_ANON_KEY;
@@ -348,3 +349,142 @@ test("real local users collaborate, recover, review, restore, and revoke access"
     await Promise.allSettled(ids.map((id) => admin.auth.admin.deleteUser(id)));
   }
 });
+
+test("workspace evidence, team AI review, and practice survive a teammate reload", async ({ browser }, testInfo) => {
+  test.skip(testInfo.project.name === "mobile-chromium", "The core mobile collaboration journey runs above");
+  test.setTimeout(120_000);
+  const admin = createClient(supabaseUrl!, serviceKey!, { auth: { persistSession: false } });
+  const password = `Local-${crypto.randomUUID()}!`;
+  const ids: string[] = [];
+  const contexts: BrowserContext[] = [];
+  let collaboration: ChildProcess | undefined;
+
+  try {
+    const sessions: Session[] = [];
+    for (const prefix of ["practice-owner", "practice-member"]) {
+      const email = `${prefix}-${Date.now()}-${crypto.randomUUID()}@workspace.test`;
+      const created = await admin.auth.admin.createUser({ email, email_confirm: true, password });
+      if (created.error || !created.data.user) throw created.error ?? new Error("User creation failed");
+      ids.push(created.data.user.id);
+      const client = createClient(supabaseUrl!, anonKey!, { auth: { persistSession: false } });
+      const signedIn = await client.auth.signInWithPassword({ email, password });
+      if (signedIn.error || !signedIn.data.session) throw signedIn.error ?? new Error("Sign in failed");
+      sessions.push(signedIn.data.session);
+    }
+
+    collaboration = await startCollaboration();
+    const owner = await authenticatedPage(browser, sessions[0]);
+    const member = await authenticatedPage(browser, sessions[1]);
+    contexts.push(owner.context, member.context);
+    await owner.page.route("**/functions/v1/ai", async (route) => {
+      const body = route.request().postDataJSON() as {
+        input?: { message?: string };
+        workspaceContext?: WorkspaceToolContext;
+      };
+      const workspaceContext = body.workspaceContext;
+      if (workspaceContext?.threadId && workspaceContext.threadRequest && body.input?.message) {
+        const started = await admin.rpc("start_workspace_thread_generation", {
+          p_assistant_message_id: workspaceContext.threadRequest.assistantMessageId,
+          p_content: body.input.message,
+          p_request_id: workspaceContext.requestId,
+          p_thread_id: workspaceContext.threadId,
+          p_user_id: ids[0],
+          p_user_message_id: workspaceContext.threadRequest.userMessageId,
+          p_workspace_id: workspaceContext.workspaceId,
+        });
+        if (started.error) throw started.error;
+      }
+      await route.fulfill({
+        body: JSON.stringify({ output: { response: "Phones should be limited with a clear enforcement mechanism.", followUpQuestions: [], uncertainties: [] } }),
+        contentType: "application/json",
+        status: 200,
+      });
+    });
+
+    await owner.page.goto("/app/workspaces");
+    await owner.page.getByRole("textbox", { name: "Motion" }).fill("Schools should limit phones");
+    await owner.page.getByRole("button", { name: "Create workspace" }).click();
+    await expect(owner.page).toHaveURL(/\/app\/workspaces\/[0-9a-f-]+$/, { timeout: 20_000 });
+    const workspaceUrl = owner.page.url();
+    const workspaceId = workspaceUrl.split("/").at(-1)!;
+    const membership = await admin.from("workspace_members").insert({ workspace_id: workspaceId, user_id: ids[1] });
+    if (membership.error) throw membership.error;
+
+    await owner.page.getByRole("button", { name: "R1" }).click();
+    await owner.page.locator(".ProseMirror").fill("Phones interrupt learning");
+    await expect(owner.page.getByText("Saved", { exact: true })).toBeVisible();
+
+    await openPanel(owner.page, "Evidence");
+    await owner.page.getByLabel("Source title").fill("Attention study");
+    await owner.page.getByLabel("Quoted evidence").fill("Notifications reduce sustained attention.");
+    await owner.page.getByRole("button", { name: "Add evidence" }).click();
+    await expect(owner.page.getByText("Attention study", { exact: true })).toBeVisible();
+    await owner.page.getByRole("button", { name: "Insert citation" }).click();
+    await expect(owner.page.locator(".ProseMirror")).toContainText("Attention study");
+
+    await openPanel(owner.page, "Team threads");
+    await owner.page.getByLabel("Thread name").fill("Both sides");
+    await owner.page.getByRole("button", { name: "Create", exact: true }).click();
+    await owner.page.getByLabel("Team message").fill("Compare both sides");
+    await owner.page.getByRole("button", { name: "Send", exact: true }).click();
+    let pendingMessage: { request_id: string; thread_id: string } | null = null;
+    await expect.poll(async () => {
+      const result = await admin.from("workspace_thread_messages")
+        .select("request_id,thread_id").eq("workspace_id", workspaceId).eq("role", "assistant").eq("status", "progress").maybeSingle();
+      if (result.error) throw result.error;
+      pendingMessage = result.data;
+      return Boolean(pendingMessage);
+    }).toBe(true);
+    if (!pendingMessage) throw new Error("Thread progress was not stored");
+    const completed = await admin.rpc("complete_workspace_thread_generation", {
+      p_content: "Phones should be limited with a clear enforcement mechanism.",
+      p_request_id: pendingMessage.request_id,
+      p_status: "complete",
+      p_thread_id: pendingMessage.thread_id,
+      p_user_id: ids[0],
+      p_workspace_id: workspaceId,
+    });
+    if (completed.error) throw completed.error;
+    await expect(owner.page.getByText(/clear enforcement mechanism/)).toBeVisible();
+
+    await openPanel(owner.page, "Practice");
+    await owner.page.getByRole("button", { name: "Suggest AI rewrite" }).click();
+    await openPanel(owner.page, "Review");
+    await expect(owner.page.getByRole("button", { name: "Reject" })).toHaveCount(1);
+    await owner.page.getByRole("button", { name: "Reject" }).click();
+    await expect(owner.page.locator(".ProseMirror")).toContainText("Phones interrupt learning");
+    await openPanel(owner.page, "Practice");
+    await owner.page.getByRole("button", { name: "Suggest AI rewrite" }).click();
+    await openPanel(owner.page, "Review");
+    await expect(owner.page.getByRole("button", { name: "Accept" })).toHaveCount(1);
+    await owner.page.getByRole("button", { name: "Accept" }).click();
+    await expect(owner.page.locator(".ProseMirror")).toContainText("clear enforcement mechanism");
+
+    await openPanel(owner.page, "Practice");
+    await owner.page.getByRole("button", { name: "Crossfire", exact: true }).click();
+    await expect(owner.page).toHaveURL(/\/app\/crossfire$/);
+    await expect(owner.page.getByTestId("crossfire-resolution")).toHaveValue("Schools should limit phones");
+    await expect(owner.page.getByText(/Shared workspace session/)).toBeVisible();
+    await expect.poll(async () => {
+      const result = await admin.from("workspace_artifacts").select("id").eq("workspace_id", workspaceId).eq("tool", "crossfire");
+      if (result.error) throw result.error;
+      return result.data.length;
+    }).toBe(1);
+    await owner.page.getByRole("link", { name: "Return to workspace" }).click();
+
+    await member.page.goto(workspaceUrl);
+    await member.page.getByRole("button", { name: "R1" }).click();
+    await openPanel(member.page, "Practice");
+    await expect(member.page.locator("summary").filter({ hasText: /Crossfire.*progress/i })).toBeVisible();
+    await member.page.reload();
+    await openPanel(member.page, "Practice");
+    await expect(member.page.locator("summary").filter({ hasText: /Crossfire.*progress/i })).toBeVisible();
+
+    await owner.page.goto("/app/ask");
+    await expect(owner.page.getByText(/Shared workspace session/)).toHaveCount(0);
+  } finally {
+    await stop(collaboration);
+    await Promise.allSettled(contexts.map((context) => context.close()));
+    await Promise.allSettled(ids.map((id) => admin.auth.admin.deleteUser(id)));
+  }
+});
diff --git a/services/collaboration/src/postgres-store.test.ts b/services/collaboration/src/postgres-store.test.ts
index 8a40673b0..e98af150c 100644
--- a/services/collaboration/src/postgres-store.test.ts
+++ b/services/collaboration/src/postgres-store.test.ts
@@ -81,6 +81,7 @@ describe("Postgres collaboration writer locks", () => {
   });
 
   it("appends and snapshots only while author membership and epoch are current", async () => {
+    const { snapshot } = proposalFixture();
     const client = new FakeClient();
     const pool = { connect: vi.fn().mockResolvedValue(client) };
     const store = new PostgresDurableUpdateStore(pool);
@@ -104,7 +105,7 @@ describe("Postgres collaboration writer locks", () => {
       documentId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
       epoch: 3,
       mutationId: "a".repeat(43),
-      snapshot: new Uint8Array([3, 4]),
+      snapshot,
       syncType: 2,
     });
 
@@ -114,6 +115,8 @@ describe("Postgres collaboration writer locks", () => {
       .toBeLessThan(appendQueries.findIndex((text) => text.includes("SELECT state.workspace_id, state.durable_sequence")));
     expect(client.query.mock.calls.some(([text]) => String(text).startsWith("INSERT INTO private.workspace_document_updates"))).toBe(true);
     expect(client.query.mock.calls.some(([text]) => String(text).startsWith("UPDATE private.workspace_document_state"))).toBe(true);
+    const projectionWrite = client.query.mock.calls.find(([text]) => String(text).startsWith("UPDATE private.workspace_document_state"));
+    expect(projectionWrite?.[1]?.[3]).toBe("Hello world");
     expect(client.query).toHaveBeenCalledWith("COMMIT");
     await release();
   });
@@ -145,6 +148,7 @@ describe("Postgres collaboration writer locks", () => {
   });
 
   it("loads the current snapshot and durable acknowledgement from the writer session", async () => {
+    const { snapshot } = proposalFixture();
     const client = new FakeClient();
     const pool = { connect: vi.fn().mockResolvedValue(client) };
     const store = new PostgresDurableUpdateStore(pool);
@@ -156,7 +160,7 @@ describe("Postgres collaboration writer locks", () => {
     client.query.mockReset();
     client.query.mockImplementation(async (text: string) => {
       if (text.includes("SELECT snapshot")) {
-        return { rows: [{ snapshot: new Uint8Array([9, 8]) }] };
+        return { rows: [{ snapshot, text_projection: "" }] };
       }
       return {
         rows: [{
@@ -171,7 +175,8 @@ describe("Postgres collaboration writer locks", () => {
     await expect(store.loadSnapshot(
       "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
       3,
-    )).resolves.toEqual(new Uint8Array([9, 8]));
+    )).resolves.toEqual(snapshot);
+    expect(client.query.mock.calls.some(([text]) => String(text).includes("SET text_projection"))).toBe(true);
     await expect(store.find(
       "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
       3,
diff --git a/services/collaboration/src/postgres-store.ts b/services/collaboration/src/postgres-store.ts
index 2ba4d6dfc..8e7ecec43 100644
--- a/services/collaboration/src/postgres-store.ts
+++ b/services/collaboration/src/postgres-store.ts
@@ -1,13 +1,14 @@
 import { createHash } from "node:crypto";
 import { z } from "zod";
 import * as Y from "yjs";
+import { yXmlFragmentToProsemirrorJSON } from "@tiptap/y-tiptap";
 import {
   acceptProposalHunkInDocument,
   deserializeProposal,
   rejectProposalHunks,
   serializeProposal,
 } from "../../../src/lib/workspace/review";
-import { validateWorkspaceDocument } from "../../../src/lib/workspace/schema";
+import { validateWorkspaceDocument, WORKSPACE_CONTENT_FIELD, workspaceSchema } from "../../../src/lib/workspace/schema";
 import type { DurableAppend, DurableUpdate, DurableUpdateStore } from "./server";
 
 export interface PgClient {
@@ -42,7 +43,7 @@ const durableRowSchema = z.object({
   sync_type: z.number(),
 });
 const storedUpdateRowSchema = durableRowSchema.extend({ mutation_id: z.string() });
-const snapshotRowSchema = z.object({ snapshot: z.instanceof(Uint8Array) });
+const snapshotRowSchema = z.object({ snapshot: z.instanceof(Uint8Array), text_projection: z.string().optional() });
 const authorizationRowSchema = z.object({ allowed: z.boolean() });
 const proposalRowSchema = z.object({
   durable_sequence: bigintSchema,
@@ -52,6 +53,18 @@ const proposalRowSchema = z.object({
   workspace_id: z.string().uuid(),
 });
 
+function snapshotText(snapshot: Uint8Array) {
+  const document = new Y.Doc();
+  try {
+    if (snapshot.byteLength) Y.applyUpdate(document, snapshot);
+    return workspaceSchema.nodeFromJSON(
+      yXmlFragmentToProsemirrorJSON(document.getXmlFragment(WORKSPACE_CONTENT_FIELD)),
+    ).textContent.slice(0, 100_000);
+  } finally {
+    document.destroy();
+  }
+}
+
 export class PostgresDurableUpdateStore implements DurableUpdateStore {
   private readonly writers = new Map<string, Writer>();
 
@@ -84,14 +97,26 @@ export class PostgresDurableUpdateStore implements DurableUpdateStore {
   }
 
   async loadSnapshot(documentId: string, epoch: number) {
-    const result = await this.getWriter(documentId, epoch).query(
-      `SELECT snapshot
+    const client = this.getWriter(documentId, epoch);
+    const result = await client.query(
+      `SELECT snapshot, text_projection
        FROM private.workspace_document_state
        WHERE document_id = $1 AND epoch = $2`,
       [documentId, epoch],
     );
     const input = result.rows[0];
-    return input ? new Uint8Array(snapshotRowSchema.parse(input).snapshot) : undefined;
+    if (!input) return undefined;
+    const row = snapshotRowSchema.parse(input);
+    const snapshot = new Uint8Array(row.snapshot);
+    if (!row.text_projection) {
+      await client.query(
+        `UPDATE private.workspace_document_state
+         SET text_projection = $3
+         WHERE document_id = $1 AND epoch = $2 AND text_projection = ''`,
+        [documentId, epoch, snapshotText(snapshot)],
+      );
+    }
+    return snapshot;
   }
 
   async load(documentId: string, epoch: number): Promise<DurableUpdate[]> {
@@ -204,9 +229,9 @@ export class PostgresDurableUpdateStore implements DurableUpdateStore {
       );
       await client.query(
         `UPDATE private.workspace_document_state
-         SET durable_sequence = $2, snapshot = $3, updated_at = now()
+         SET durable_sequence = $2, snapshot = $3, text_projection = $4, updated_at = now()
          WHERE document_id = $1`,
-        [update.documentId, sequence, Buffer.from(update.snapshot)],
+        [update.documentId, sequence, Buffer.from(update.snapshot), snapshotText(update.snapshot)],
       );
       await client.query(
         `UPDATE public.workspace_documents
@@ -374,9 +399,9 @@ export class PostgresDurableUpdateStore implements DurableUpdateStore {
             );
             await client.query(
               `UPDATE private.workspace_document_state
-               SET durable_sequence = $2, snapshot = $3, updated_at = now()
+               SET durable_sequence = $2, snapshot = $3, text_projection = $4, updated_at = now()
                WHERE document_id = $1`,
-              [input.documentId, sequence, Buffer.from(snapshot)],
+              [input.documentId, sequence, Buffer.from(snapshot), snapshotText(snapshot)],
             );
             await client.query(
               `UPDATE public.workspace_documents
diff --git a/src/components/features/sparring/SparringSetup.tsx b/src/components/features/sparring/SparringSetup.tsx
index e889083da..628cc9ebf 100644
--- a/src/components/features/sparring/SparringSetup.tsx
+++ b/src/components/features/sparring/SparringSetup.tsx
@@ -26,6 +26,7 @@ export interface SparringSetupValues {
 interface SparringSetupProps {
   onStart: (values: SparringSetupValues) => void;
   isStarting?: boolean;
+  initialValues?: Partial<SparringSetupValues>;
 }
 
 const DIFFICULTIES: Array<{ id: SparringDifficulty; name: string }> = [
@@ -34,10 +35,10 @@ const DIFFICULTIES: Array<{ id: SparringDifficulty; name: string }> = [
   { id: 'hard', name: 'Ruthless' },
 ];
 
-export function SparringSetup({ onStart, isStarting = false }: SparringSetupProps) {
+export function SparringSetup({ onStart, isStarting = false, initialValues }: SparringSetupProps) {
   const { t } = useTranslation();
-  const [motion, setMotion] = useState('');
-  const [userSide, setUserSide] = useState<SparringSide>('pro');
+  const [motion, setMotion] = useState(initialValues?.motion ?? '');
+  const [userSide, setUserSide] = useState<SparringSide>(initialValues?.userSide ?? 'pro');
   const [format, setFormat] = useState<SparringFormat>('standard');
   const [difficulty, setDifficulty] = useState<SparringDifficulty>('medium');
   const [isOnline, setIsOnline] = useState(() => typeof navigator === 'undefined' || navigator.onLine);
diff --git a/src/components/features/workspace/WorkspaceEditor.tsx b/src/components/features/workspace/WorkspaceEditor.tsx
index 353bd3e29..cea48f2e7 100644
--- a/src/components/features/workspace/WorkspaceEditor.tsx
+++ b/src/components/features/workspace/WorkspaceEditor.tsx
@@ -20,6 +20,7 @@ import { createWorkspaceEditor } from "@/lib/workspace/editor-schema";
 import { createProposal, createQuoteAnchor, type ProposalHunkInput } from "@/lib/workspace/review";
 import { createWorkspaceComment, saveWorkspaceProposal } from "@/lib/workspace/client";
 import { useOnlineStatus } from "@/hooks/use-online-status";
+import type { WorkspaceSource } from "@/lib/workspace/practice-client";
 
 const acknowledgementSchema = z.object({
   epoch: z.number().int().nonnegative(),
@@ -32,6 +33,8 @@ export type SaveStatus = "Offline" | "Saved" | "Saving";
 
 export function WorkspaceEditor({
   documentId,
+  citationToInsert,
+  aiSuggestion,
   editable,
   epoch,
   members,
@@ -40,9 +43,14 @@ export function WorkspaceEditor({
   userName,
   workspaceId,
   onDurableSequence,
+  onCitationInserted,
+  onAiSuggestionConsumed,
   onSaveStatus,
+  onTextChange,
 }: {
   documentId: string;
+  citationToInsert?: WorkspaceSource | null;
+  aiSuggestion?: { id: string; text: string } | null;
   editable: boolean;
   epoch: number;
   members: Array<{ user_id: string }>;
@@ -51,7 +59,10 @@ export function WorkspaceEditor({
   userName: string;
   workspaceId: string;
   onDurableSequence?: (sequence: number) => void;
+  onCitationInserted?: () => void;
+  onAiSuggestionConsumed?: () => void;
   onSaveStatus?: (status: SaveStatus) => void;
+  onTextChange?: (text: string) => void;
 }) {
   const { t } = useTranslation();
   const online = useOnlineStatus();
@@ -87,6 +98,7 @@ export function WorkspaceEditor({
     setStatus(navigator.onLine ? "Saving" : "Offline");
     let provider: HocuspocusProvider | undefined;
     let activeEditor: ReturnType<typeof createWorkspaceEditor> | undefined;
+    let reportText: (() => void) | undefined;
     const pending = new Set<string>();
     const loadedPending = new Set<string>();
     let bufferedHunk: ProposalHunkInput | undefined;
@@ -231,6 +243,9 @@ export function WorkspaceEditor({
         provider,
         user: { color: `hsl(${Math.abs(userId.charCodeAt(0) * 47) % 360} 70% 45%)`, name: userName },
       });
+      reportText = () => onTextChange?.(activeEditor?.getText() ?? "");
+      activeEditor.on("update", reportText);
+      reportText();
       document.on("update", (_update, origin) => {
         if (origin !== provider) setStatus("Saving");
         void persist();
@@ -248,11 +263,49 @@ export function WorkspaceEditor({
       flushSuggestion();
       window.removeEventListener("offline", offline);
       window.removeEventListener("online", online);
+      if (activeEditor && reportText) activeEditor.off("update", reportText);
       activeEditor?.destroy();
       provider?.destroy();
       document.destroy();
     };
-  }, [documentId, editable, epoch, identity, onDurableSequence, online, queryClient, t, token, userId, userName, workspaceId]);
+  }, [documentId, editable, epoch, identity, onDurableSequence, onTextChange, online, queryClient, t, token, userId, userName, workspaceId]);
+
+  useEffect(() => {
+    if (!editor || !citationToInsert) return;
+    const snapshot = citationToInsert.citation_snapshot;
+    editor.chain().focus().insertContent({
+      type: "citation",
+      attrs: {
+        href: typeof snapshot.url === "string" ? snapshot.url : null,
+        locator: citationToInsert.title,
+        quote: citationToInsert.content,
+        sourceId: citationToInsert.id,
+        title: citationToInsert.title,
+      },
+    }).run();
+    onCitationInserted?.();
+  }, [citationToInsert, editor, onCitationInserted]);
+
+  useEffect(() => {
+    if (!editor || !aiSuggestion || status !== "Saved") return;
+    onAiSuggestionConsumed?.();
+    const proposal = createProposal({
+      authorId: userId,
+      documentEpoch: epoch,
+      editor,
+      hunks: [{
+        content: [{ type: "paragraph", content: [{ type: "text", text: aiSuggestion.text }] }],
+        from: 0,
+        id: aiSuggestion.id,
+        kind: "format",
+        to: editor.state.doc.content.size,
+      }],
+      id: crypto.randomUUID(),
+    });
+    void saveWorkspaceProposal({ documentId, proposal, workspaceId })
+      .then(() => queryClient.invalidateQueries({ queryKey: ["workspace-proposals", userId, documentId] }))
+      .catch(() => setReviewError(t("workspaces.suggestionFailed", "Suggestion could not be saved.")));
+  }, [aiSuggestion, documentId, editor, epoch, onAiSuggestionConsumed, queryClient, status, t, userId, workspaceId]);
 
   if (!COLLABORATION_URL) {
     return <p role="alert" className="p-4 text-sm text-destructive">{t("workspaces.collaborationUnavailable", "Collaboration service is not configured.")}</p>;
diff --git a/src/components/features/workspace/WorkspacePracticePanel.tsx b/src/components/features/workspace/WorkspacePracticePanel.tsx
new file mode 100644
index 000000000..d7587db9d
--- /dev/null
+++ b/src/components/features/workspace/WorkspacePracticePanel.tsx
@@ -0,0 +1,355 @@
+import { useMemo, useState, type FormEvent } from "react";
+import { useNavigate } from "react-router-dom";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { useTranslation } from "react-i18next";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Textarea } from "@/components/ui/textarea";
+import { askChat } from "@/lib/ai/client";
+import { useSessionStore } from "@/lib/stores/session-store";
+import { useSettingsStore } from "@/lib/stores/settings-store";
+import { useSparringStore } from "@/lib/stores/sparring-store";
+import {
+  createWorkspaceThread,
+  listWorkspacePractice,
+  saveWorkspaceArtifact,
+  saveWorkspaceSource,
+  type WorkspaceSource,
+} from "@/lib/workspace/practice-client";
+import { workspaceRouteState, type WorkspaceTool, type WorkspaceToolContext } from "@/lib/workspace/tool-context";
+
+const TOOL_ROUTES: Array<{ tool: WorkspaceTool; route: string }> = [
+  { tool: "generate", route: "/app/generate" },
+  { tool: "factoids", route: "/app/factoids" },
+  { tool: "brainstorm", route: "/app/brainstorm" },
+  { tool: "attack", route: "/app/attack" },
+  { tool: "ask", route: "/app/ask" },
+  { tool: "flowchart", route: "/app/flowchart" },
+  { tool: "crossfire", route: "/app/crossfire" },
+  { tool: "sparring", route: "/app/sparring" },
+];
+
+export function WorkspacePracticePanel({
+  documentEpoch,
+  documentId,
+  documents,
+  documentText,
+  documentTitle,
+  motion,
+  onInsertCitation,
+  onSuggestRewrite,
+  side,
+  userId,
+  workspaceId,
+}: {
+  documentEpoch: number;
+  documentId: string;
+  documents: Array<{ id: string; side: "pro" | "con"; title: string }>;
+  documentText: string;
+  documentTitle: string;
+  motion: string;
+  onInsertCitation: (source: WorkspaceSource) => void;
+  onSuggestRewrite: (suggestion: { id: string; text: string }) => void;
+  side: "pro" | "con";
+  userId: string;
+  workspaceId: string;
+}) {
+  const { t } = useTranslation();
+  const navigate = useNavigate();
+  const queryClient = useQueryClient();
+  const personalSources = useSessionStore((state) => state.sourceLibrary);
+  const savedCases = useSessionStore((state) => state.savedCases);
+  const savedAttacks = useSessionStore((state) => state.savedAttacks);
+  const savedBrainstorms = useSessionStore((state) => state.savedBrainstorms);
+  const savedFactoids = useSessionStore((state) => state.savedFactoids);
+  const savedChats = useSessionStore((state) => state.savedChats);
+  const savedFlowcharts = useSessionStore((state) => state.savedFlowcharts);
+  const savedSparring = useSparringStore((state) => state.savedSessions);
+  const askConfig = useSettingsStore((state) => state.getFeatureConfig("ask"));
+  const [sourceTitle, setSourceTitle] = useState("");
+  const [sourceContent, setSourceContent] = useState("");
+  const [sourceSearch, setSourceSearch] = useState("");
+  const [selectedSourceIds, setSelectedSourceIds] = useState<string[]>([]);
+  const [selectedDocumentIds, setSelectedDocumentIds] = useState<string[]>([documentId]);
+  const [threadName, setThreadName] = useState("");
+  const [threadId, setThreadId] = useState<string | null>(null);
+  const [message, setMessage] = useState("");
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const practice = useQuery({
+    queryKey: ["workspace-practice", userId, workspaceId],
+    queryFn: () => listWorkspacePractice(workspaceId),
+    refetchInterval: 3_000,
+  });
+  const visibleSources = useMemo(() => {
+    const search = sourceSearch.trim().toLowerCase();
+    return practice.data?.sources.filter((source) => !search || `${source.title} ${source.content}`.toLowerCase().includes(search)) ?? [];
+  }, [practice.data?.sources, sourceSearch]);
+  const selectedThread = threadId;
+  const threadMessages = practice.data?.messages.filter((item) => item.thread_id === selectedThread) ?? [];
+  const privateResults = useMemo(() => [
+    ...savedCases.map((item) => ({ ...item, tool: "generate" as const })),
+    ...savedAttacks.map((item) => ({ ...item, tool: "attack" as const })),
+    ...savedBrainstorms.map((item) => ({ ...item, tool: "brainstorm" as const })),
+    ...savedFactoids.map((item) => ({ ...item, tool: "factoids" as const })),
+    ...savedChats.map((item) => ({ ...item, tool: "ask" as const })),
+    ...savedFlowcharts.map((item) => ({ ...item, tool: "flowchart" as const })),
+    ...savedSparring.map((item) => ({ createdAt: item.createdAt, data: item, id: item.id, title: item.motion, tool: "sparring" as const })),
+  ].sort((left, right) => right.createdAt - left.createdAt).slice(0, 10), [savedAttacks, savedBrainstorms, savedCases, savedChats, savedFactoids, savedFlowcharts, savedSparring]);
+
+  const refresh = () => queryClient.invalidateQueries({ queryKey: ["workspace-practice", userId, workspaceId] });
+  const run = async (operation: () => Promise<void>) => {
+    if (busy || !navigator.onLine) return;
+    setBusy(true);
+    setError(null);
+    try {
+      await operation();
+      await refresh();
+    } catch {
+      setError(t("workspaces.practiceFailed", "The workspace practice item could not be saved."));
+    } finally {
+      setBusy(false);
+    }
+  };
+  const context = (
+    requestId: string = crypto.randomUUID(),
+    threadRequest: WorkspaceToolContext["threadRequest"] = null,
+  ): WorkspaceToolContext => ({
+    documentEpoch,
+    documentId,
+    documentIds: selectedDocumentIds.includes(documentId) ? selectedDocumentIds : [documentId, ...selectedDocumentIds].slice(0, 12),
+    documentText,
+    documentTitle,
+    motion,
+    requestId,
+    returnUrl: `/app/workspaces/${workspaceId}`,
+    side,
+    sourceIds: selectedSourceIds.slice(0, 20),
+    threadRequest,
+    threadId: selectedThread,
+    workspaceId,
+  });
+  const launch = (tool: WorkspaceTool, route: string) => {
+    const session = useSessionStore.getState();
+    if (tool === "generate") session.setGenerateForm({ motion, side });
+    if (tool === "factoids") session.setFactoidsForm({ claim: documentText || motion, direction: side === "pro" ? "for" : "against" });
+    if (tool === "brainstorm") session.setBrainstormForm({ context: documentText, motion, side });
+    if (tool === "attack") session.setAttackForm({ caseText: documentText });
+    if (tool === "flowchart") session.setPendingFlowchartData({
+      edges: [],
+      nodes: [{ id: `workspace-${documentId}`, position: { x: 300, y: 80 }, data: { description: documentText, label: documentTitle, type: "thesis" }, type: "custom" }],
+    });
+    const workspaceContext = context();
+    navigate(route, {
+      state: {
+        ...workspaceRouteState(workspaceContext),
+        ...(tool === "crossfire" ? { argument: documentText, resolution: motion } : {}),
+      },
+    });
+  };
+  const resume = (artifact: NonNullable<typeof practice.data>["artifacts"][number]) => {
+    if (artifact.document_id !== documentId || artifact.document_epoch !== documentEpoch) return;
+    navigate(TOOL_ROUTES.find(({ tool }) => tool === artifact.tool)?.route ?? context().returnUrl, {
+      state: { workspaceArtifact: artifact.progress, workspaceContext: context(artifact.request_id) },
+    });
+  };
+
+  const addSource = (event: FormEvent) => {
+    event.preventDefault();
+    const title = sourceTitle.trim();
+    const content = sourceContent.trim();
+    if (!title || !content) return;
+    void run(async () => {
+      await saveWorkspaceSource(workspaceId, { content, metadata: { capturedVia: "workspace" }, title, type: "text" });
+      setSourceTitle("");
+      setSourceContent("");
+    });
+  };
+
+  const sendThreadMessage = (event: FormEvent) => {
+    event.preventDefault();
+    const content = message.trim();
+    if (!selectedThread || !content) return;
+    const requestId = crypto.randomUUID();
+    const assistantMessageId = crypto.randomUUID();
+    const userMessageId = crypto.randomUUID();
+    setMessage("");
+    void run(async () => {
+      await askChat(
+        content,
+        threadMessages.filter(({ status }) => status === "complete").map(({ role, content: item }) => ({ role, content: item })),
+        "general",
+        askConfig,
+        { workspaceContext: context(requestId, { assistantMessageId, userMessageId }) },
+      );
+    });
+  };
+  const suggestRewrite = () => {
+    const requestId = crypto.randomUUID();
+    const workspaceContext = context(requestId);
+    void run(async () => {
+      const result = await askChat(
+        "Rewrite the selected debate document for clarity and persuasive force. Return only the replacement document text.",
+        [],
+        "general",
+        askConfig,
+        { workspaceContext },
+      );
+      await saveWorkspaceArtifact({
+        documentEpoch,
+        documentId,
+        inputSnapshot: { documentText, instruction: "rewrite" },
+        outputSnapshot: result,
+        requestId,
+        status: "complete",
+        tool: "ask",
+        workspaceId,
+      });
+      onSuggestRewrite({ id: requestId, text: result.response });
+    });
+  };
+
+  return (
+    <div className="grid gap-3">
+      <details className="rounded-lg border border-border bg-card p-3">
+        <summary className="cursor-pointer font-medium">{t("workspaces.evidence", "Evidence")}</summary>
+        <form className="mt-3 grid gap-2" onSubmit={addSource}>
+          <Input aria-label={t("workspaces.sourceTitle", "Source title")} value={sourceTitle} onChange={(event) => setSourceTitle(event.target.value)} />
+          <Textarea aria-label={t("workspaces.quotedEvidence", "Quoted evidence")} value={sourceContent} onChange={(event) => setSourceContent(event.target.value)} />
+          <Button type="submit" size="sm" disabled={busy || !sourceTitle.trim() || !sourceContent.trim()}>{t("workspaces.addEvidence", "Add evidence")}</Button>
+        </form>
+        {personalSources.length > 0 && (
+          <div className="mt-3 grid gap-1 border-t border-border pt-3">
+            <p className="text-xs font-medium">{t("workspaces.copyPrivateSource", "Copy from private library")}</p>
+            {personalSources.slice(0, 10).map((source) => (
+              <Button key={source.id} type="button" size="sm" variant="ghost" className="justify-start" disabled={busy} onClick={() => void run(async () => { await saveWorkspaceSource(workspaceId, source); })}>
+                {source.title}
+              </Button>
+            ))}
+          </div>
+        )}
+        <Input className="mt-3" aria-label={t("workspaces.searchEvidence", "Search evidence")} value={sourceSearch} onChange={(event) => setSourceSearch(event.target.value)} />
+        <div className="mt-2 grid gap-2">
+          {visibleSources.map((source) => (
+            <div key={source.id} className="rounded-md border border-border p-2 text-sm">
+              <p className="font-medium">{source.title}</p>
+              <blockquote className="mt-1 line-clamp-3 border-l-2 border-border pl-2 text-xs text-muted-foreground">{source.content}</blockquote>
+              <div className="mt-2 flex gap-1">
+                <Button type="button" size="sm" variant="outline" onClick={() => onInsertCitation(source)}>{t("workspaces.insertCitation", "Insert citation")}</Button>
+                <Button
+                  type="button"
+                  size="sm"
+                  variant={selectedSourceIds.includes(source.id) ? "secondary" : "ghost"}
+                  aria-pressed={selectedSourceIds.includes(source.id)}
+                  onClick={() => setSelectedSourceIds((current) => current.includes(source.id) ? current.filter((id) => id !== source.id) : [...current, source.id])}
+                >
+                  {t("workspaces.useInContext", "Use in AI context")}
+                </Button>
+              </div>
+            </div>
+          ))}
+        </div>
+      </details>
+
+      <details className="rounded-lg border border-border bg-card p-3">
+        <summary className="cursor-pointer font-medium">{t("workspaces.teamThreads", "Team threads")}</summary>
+        <form className="mt-3 flex gap-2" onSubmit={(event) => {
+          event.preventDefault();
+          const name = threadName.trim();
+          if (!name) return;
+          void run(async () => { const id = await createWorkspaceThread(workspaceId, name); setThreadId(id); setThreadName(""); });
+        }}>
+          <Input aria-label={t("workspaces.threadName", "Thread name")} value={threadName} onChange={(event) => setThreadName(event.target.value)} />
+          <Button type="submit" size="sm" disabled={busy || !threadName.trim()}>{t("workspaces.createThread", "Create")}</Button>
+        </form>
+        <div className="mt-2 flex flex-wrap gap-1">
+          {practice.data?.threads.map((thread) => <Button key={thread.id} type="button" size="sm" variant={selectedThread === thread.id ? "secondary" : "ghost"} onClick={() => setThreadId(thread.id)}>{thread.name}</Button>)}
+        </div>
+        {selectedThread && (
+          <>
+            <div className="mt-3 grid max-h-56 gap-2 overflow-y-auto">
+              {threadMessages.map((item) => <p key={item.id} className="rounded-md bg-accent px-2 py-1 text-sm"><span className="font-medium">{item.role === "user" ? t("workspaces.you", "You") : "DebateLab"}:</span> {item.content} {item.status !== "complete" && <span className="text-xs text-muted-foreground">({item.status})</span>}</p>)}
+            </div>
+            <form className="mt-2 flex gap-2" onSubmit={sendThreadMessage}>
+              <Input aria-label={t("workspaces.threadMessage", "Team message")} value={message} onChange={(event) => setMessage(event.target.value)} />
+              <Button type="submit" size="sm" disabled={busy || !message.trim()}>{t("workspaces.send", "Send")}</Button>
+            </form>
+          </>
+        )}
+      </details>
+
+      <details className="rounded-lg border border-border bg-card p-3">
+        <summary className="cursor-pointer font-medium">{t("workspaces.practice", "Practice")}</summary>
+        <p className="mt-2 text-xs text-muted-foreground">{t("workspaces.sharedScope", "Workspace-started sessions use shared case context and attach results here.")}</p>
+        <p className="mt-1 text-xs text-muted-foreground">
+          {t("workspaces.contextSummary", "Included: selected document, {{included}} sources{{thread}}. Omitted: {{omitted}} sources.", {
+            included: selectedSourceIds.length,
+            omitted: Math.max(0, (practice.data?.sources.length ?? 0) - selectedSourceIds.length),
+            thread: selectedThread ? t("workspaces.contextThread", ", shared thread") : "",
+          })}
+        </p>
+        <div className="mt-2 flex flex-wrap gap-1" aria-label={t("workspaces.contextDocuments", "AI context documents")}>
+          {documents.map((document) => (
+            <Button
+              key={document.id}
+              type="button"
+              size="sm"
+              variant={selectedDocumentIds.includes(document.id) ? "secondary" : "ghost"}
+              aria-pressed={selectedDocumentIds.includes(document.id)}
+              onClick={() => setSelectedDocumentIds((current) => current.includes(document.id)
+                ? current.length === 1 ? current : current.filter((id) => id !== document.id)
+                : [...current, document.id].slice(0, 12))}
+            >
+              {document.side === "pro" ? t("workspaces.proSide", "For") : t("workspaces.conSide", "Against")} · {document.title}
+            </Button>
+          ))}
+        </div>
+        <div className="mt-3 grid grid-cols-2 gap-2">
+          {TOOL_ROUTES.map(({ tool, route }) => (
+            <Button key={tool} type="button" size="sm" variant="outline" onClick={() => launch(tool, route)}>
+              {t(`nav.${tool}`, tool)}
+            </Button>
+          ))}
+        </div>
+        <Button className="mt-2 w-full" type="button" size="sm" disabled={busy || !documentText.trim()} onClick={suggestRewrite}>
+          {t("workspaces.suggestRewrite", "Suggest AI rewrite")}
+        </Button>
+        {privateResults.length > 0 && (
+          <div className="mt-3 grid gap-1 border-t border-border pt-3">
+            <p className="text-xs font-medium">{t("workspaces.sharePrivateResult", "Share a private result")}</p>
+            {privateResults.map((item) => (
+              <Button key={`${item.tool}:${item.id}`} type="button" size="sm" variant="ghost" className="justify-start" disabled={busy} onClick={() => void run(async () => {
+                await saveWorkspaceArtifact({
+                  documentEpoch,
+                  documentId,
+                  inputSnapshot: { copiedFromPrivate: true, title: item.title },
+                  outputSnapshot: item.data,
+                  requestId: crypto.randomUUID(),
+                  status: "complete",
+                  tool: item.tool,
+                  workspaceId,
+                });
+              })}>
+                {t("workspaces.shareResult", "Share")} · {item.title}
+              </Button>
+            ))}
+          </div>
+        )}
+        <div className="mt-3 grid gap-2">
+          {practice.data?.artifacts.slice(0, 10).map((artifact) => (
+            <details key={artifact.id} className="rounded-md border border-border px-2 py-1 text-xs">
+              <summary className="cursor-pointer"><span className="font-medium">{t(`nav.${artifact.tool}`, artifact.tool)}</span> · {artifact.status}</summary>
+              {artifact.output_snapshot !== null && <pre className="mt-2 max-h-48 overflow-auto whitespace-pre-wrap text-xs">{JSON.stringify(artifact.output_snapshot, null, 2)}</pre>}
+              {artifact.status !== "complete" && (artifact.tool === "crossfire" || artifact.tool === "sparring") && artifact.document_id === documentId && artifact.document_epoch === documentEpoch && (
+                <Button className="mt-2" type="button" size="sm" variant="outline" onClick={() => resume(artifact)}>
+                  {t("workspaces.resumePractice", "Resume")}
+                </Button>
+              )}
+            </details>
+          ))}
+        </div>
+      </details>
+      {error && <p role="alert" className="text-sm text-destructive">{error}</p>}
+    </div>
+  );
+}
diff --git a/src/components/features/workspace/WorkspaceToolScope.tsx b/src/components/features/workspace/WorkspaceToolScope.tsx
new file mode 100644
index 000000000..c80da2c3f
--- /dev/null
+++ b/src/components/features/workspace/WorkspaceToolScope.tsx
@@ -0,0 +1,31 @@
+import { useCallback, useMemo } from "react";
+import { Link, useLocation } from "react-router-dom";
+import { useTranslation } from "react-i18next";
+import { attachWorkspaceResult, parseWorkspaceToolContext, type WorkspaceTool } from "@/lib/workspace/tool-context";
+
+// eslint-disable-next-line react-refresh/only-export-components
+export function useWorkspaceToolScope(tool: WorkspaceTool) {
+  const location = useLocation();
+  const context = useMemo(
+    () => parseWorkspaceToolContext((location.state as { workspaceContext?: unknown } | null)?.workspaceContext),
+    [location.state],
+  );
+  const attach = useCallback(
+    (input: unknown, output: unknown) => attachWorkspaceResult(context, tool, input, output),
+    [context, tool],
+  );
+  return { attach, context };
+}
+
+export function WorkspaceToolScope({ context }: { context: ReturnType<typeof parseWorkspaceToolContext> }) {
+  const { t } = useTranslation();
+  if (!context) return null;
+  return (
+    <div className="mb-4 flex flex-wrap items-center justify-between gap-3 rounded-lg border border-primary/20 bg-primary/5 px-4 py-3 text-sm">
+      <span>{t("workspaces.sharedToolScope", "Shared workspace session · {{document}}", { document: context.documentTitle })}</span>
+      <Link className="font-medium text-primary underline-offset-4 hover:underline" to={context.returnUrl}>
+        {t("workspaces.returnToWorkspace", "Return to workspace")}
+      </Link>
+    </div>
+  );
+}
diff --git a/src/lib/ai/client.ts b/src/lib/ai/client.ts
index a727f6738..ef6da4df5 100644
--- a/src/lib/ai/client.ts
+++ b/src/lib/ai/client.ts
@@ -48,6 +48,7 @@ import {
   type CrossfireSignalInput,
   type CrossfireTurnSignal,
 } from '@/lib/crossfire/schemas';
+import type { WorkspaceToolContext } from '@/lib/workspace/tool-context';
 
 // Request timeout in milliseconds (200 seconds)
 export const REQUEST_TIMEOUT_MS = 200 * 1000;
@@ -63,6 +64,7 @@ interface AIRequestOptions<T = unknown> {
   timeoutMs?: number;
   signal?: AbortSignal;
   transformResponse?: (data: unknown) => T;
+  workspaceContext?: WorkspaceToolContext;
 }
 
 function selectedOutputLanguage(): AppLanguage {
@@ -432,7 +434,7 @@ async function callSupabaseAI<T = unknown>(
   const settings = useSettingsStore.getState();
   const session = useSessionStore.getState();
 
-  const selectedSources = options.includeActiveSources === false || feature === 'sparring'
+  const selectedSources = options.workspaceContext || options.includeActiveSources === false || feature === 'sparring'
     ? []
     : session.sourceLibrary
       .filter((s) => s.isActive)
@@ -500,8 +502,9 @@ async function callSupabaseAI<T = unknown>(
       model: config.model,
       temperature: config.temperature,
       reasoningEffort: config.reasoningEffort ?? 'low',
-      customSystemPrompt: options.includeCustomSystemPrompt === false ? null : settings.customSystemPrompt || null,
+      customSystemPrompt: options.workspaceContext || options.includeCustomSystemPrompt === false ? null : settings.customSystemPrompt || null,
       sources: activeSources,
+      workspaceContext: options.workspaceContext,
     };
 
     const { data, error } = await supabase.functions.invoke('ai', {
@@ -740,7 +743,7 @@ function validateCrossfireTurnReferences(input: CrossfireAIInput, debrief: Cross
 export async function crossfire(
   rawInput: CrossfireAIInput,
   config: ProviderConfig,
-  options: Pick<AIRequestOptions, 'signal'> = {},
+  options: Pick<AIRequestOptions, 'signal' | 'workspaceContext'> = {},
 ): Promise<(CrossfireReply & { signalToken?: string }) | CrossfireDebrief> {
   const input = CrossfireAIInputSchema.safeParse(rawInput);
   if (!input.success) {
@@ -758,6 +761,7 @@ export async function crossfire(
       includeCustomSystemPrompt: false,
       timeoutMs: CROSSFIRE_REQUEST_TIMEOUT_MS,
       signal: options.signal,
+      workspaceContext: options.workspaceContext,
       transformResponse: (rawData) => {
         const data = rawData as { output: unknown; signalToken?: unknown };
         if (input.data.operation === 'next-turn') {
@@ -1213,12 +1217,13 @@ function expectedContentionCount(length: GenerateInput['length']): number {
   }
 }
 
-export async function generateCase(input: GenerateInput, config: ProviderConfig): Promise<ResultWithSources<GenerateOutput>> {
+export async function generateCase(input: GenerateInput, config: ProviderConfig, workspaceContext?: WorkspaceToolContext): Promise<ResultWithSources<GenerateOutput>> {
   if (config.provider === 'mock') {
     return { result: await mockGenerateCase(input.motion, input.side, input.length), discoveredSources: [] };
   }
   const inputWithLanguage = withOutputLanguage(input as unknown as Record<string, unknown>);
   const response = await callSupabaseAI<ResultWithSources<GenerateOutput>>('generate', inputWithLanguage, config, {
+    workspaceContext,
     transformResponse: (rawData) => {
       const data = rawData as { output: unknown; discoveredSources?: unknown };
       const result = validateGenerateOutput(transformGenerateResponse(data.output as Record<string, unknown>));
@@ -1235,9 +1240,10 @@ export async function generateCase(input: GenerateInput, config: ProviderConfig)
   return response;
 }
 
-export async function attackCase(input: AttackInput, config: ProviderConfig): Promise<ResultWithSources<AttackOutput>> {
+export async function attackCase(input: AttackInput, config: ProviderConfig, workspaceContext?: WorkspaceToolContext): Promise<ResultWithSources<AttackOutput>> {
   if (config.provider === 'mock') return { result: await mockAttackCase(input.caseText), discoveredSources: [] };
   const response = await callSupabaseAI<ResultWithSources<AttackOutput>>('attack', withOutputLanguage(input as unknown as Record<string, unknown>), config, {
+    workspaceContext,
     transformResponse: (rawData) => {
       const data = rawData as { output: unknown; discoveredSources?: unknown };
       return {
@@ -1250,9 +1256,10 @@ export async function attackCase(input: AttackInput, config: ProviderConfig): Pr
   return response;
 }
 
-export async function brainstorm(input: BrainstormInput, config: ProviderConfig): Promise<ResultWithSources<BrainstormOutput>> {
+export async function brainstorm(input: BrainstormInput, config: ProviderConfig, workspaceContext?: WorkspaceToolContext): Promise<ResultWithSources<BrainstormOutput>> {
   if (config.provider === 'mock') return { result: await mockBrainstorm(input.motion, input.outputMode), discoveredSources: [] };
   const response = await callSupabaseAI<ResultWithSources<BrainstormOutput>>('brainstorm', withOutputLanguage(input as unknown as Record<string, unknown>), config, {
+    workspaceContext,
     transformResponse: (rawData) => {
       const data = rawData as { output: unknown; discoveredSources?: unknown };
       return {
@@ -1265,7 +1272,7 @@ export async function brainstorm(input: BrainstormInput, config: ProviderConfig)
   return response;
 }
 
-export async function factoids(input: FactoidsInput, config: ProviderConfig): Promise<ResultWithSources<FactoidsOutput>> {
+export async function factoids(input: FactoidsInput, config: ProviderConfig, workspaceContext?: WorkspaceToolContext): Promise<ResultWithSources<FactoidsOutput>> {
   if (config.provider === 'mock') return { result: await mockFactoids(input.claim), discoveredSources: [] };
   const inputWithLanguage = withOutputLanguage({
     ...input,
@@ -1273,6 +1280,7 @@ export async function factoids(input: FactoidsInput, config: ProviderConfig): Pr
     sourceCount: input.sourceCount || 5,
   });
   const response = await callSupabaseAI<ResultWithSources<FactoidsOutput>>('factoids', inputWithLanguage, config, {
+    workspaceContext,
     transformResponse: (rawData) => {
       const data = rawData as { output: unknown; discoveredSources?: unknown };
       const parsed = FactoidsOutputSchema.safeParse(data.output);
@@ -1304,6 +1312,7 @@ export interface AskChatOptions {
   webSearch?: boolean;
   prosConsMode?: boolean;
   argumentMapMode?: boolean;
+  workspaceContext?: WorkspaceToolContext;
 }
 
 export async function askChat(
@@ -1324,6 +1333,7 @@ export async function askChat(
       prosConsMode: Boolean(options.prosConsMode),
       argumentMapMode: Boolean(options.argumentMapMode),
     }), config, {
+      workspaceContext: options.workspaceContext,
       transformResponse: (rawData) => {
         const data = rawData as { output: unknown };
         const parsed = AskOutputSchema.safeParse(data.output);
@@ -1371,16 +1381,18 @@ const pendingSparringScores = new Map<string, Promise<SparringScoreResponse>>();
 async function sparringRequestKey(
   input: SparringRespondInput | SparringScoreInput,
   config: ProviderConfig,
+  workspaceContext?: WorkspaceToolContext,
 ): Promise<string> {
   const { data } = await supabase.auth.getSession();
   const authScope = data.session?.user?.id ?? data.session?.access_token ?? 'signed-out';
-  return JSON.stringify([authScope, input, config.provider, config.model, config.temperature, config.reasoningEffort]);
+  return JSON.stringify([authScope, workspaceContext?.workspaceId ?? null, input, config.provider, config.model, config.temperature, config.reasoningEffort]);
 }
 
 /** Generate the opponent's next speech for a validated sparring turn. */
 export async function generateSparringTurn(
   input: SparringRespondInput,
   config: ProviderConfig,
+  workspaceContext?: WorkspaceToolContext,
 ): Promise<SparringTurnResponse> {
   const requestInput: SparringRespondInput = {
     ...input,
@@ -1392,11 +1404,11 @@ export async function generateSparringTurn(
       details: { issues: inputResult.success ? [{ message: 'Expected respond action.' }] : inputResult.error.issues },
     });
   }
-  const requestKey = await sparringRequestKey(inputResult.data, config);
+  const requestKey = await sparringRequestKey(inputResult.data, config, workspaceContext);
   const pending = pendingSparringTurns.get(requestKey);
   if (pending) return pending;
 
-  const request = generateSparringTurnOnce(inputResult.data, config);
+  const request = generateSparringTurnOnce(inputResult.data, config, workspaceContext);
   pendingSparringTurns.set(requestKey, request);
   try {
     return await request;
@@ -1408,6 +1420,7 @@ export async function generateSparringTurn(
 async function generateSparringTurnOnce(
   input: SparringRespondInput,
   config: ProviderConfig,
+  workspaceContext?: WorkspaceToolContext,
 ): Promise<SparringTurnResponse> {
   const requestInput: SparringRespondInput = {
     ...input,
@@ -1425,6 +1438,7 @@ async function generateSparringTurnOnce(
   }
 
   return await callSupabaseAI<SparringTurnResponse>('sparring', inputResult.data, config, {
+    workspaceContext,
     transformResponse: (rawData) => validateSparringTurnResponse((rawData as { output: unknown }).output),
   });
 }
@@ -1433,6 +1447,7 @@ async function generateSparringTurnOnce(
 export async function judgeSparringSession(
   input: SparringScoreInput,
   config: ProviderConfig,
+  workspaceContext?: WorkspaceToolContext,
 ): Promise<SparringScoreResponse> {
   const requestInput: SparringScoreInput = {
     ...input,
@@ -1444,11 +1459,11 @@ export async function judgeSparringSession(
       details: { issues: inputResult.success ? [{ message: 'Expected score action.' }] : inputResult.error.issues },
     });
   }
-  const requestKey = await sparringRequestKey(inputResult.data, config);
+  const requestKey = await sparringRequestKey(inputResult.data, config, workspaceContext);
   const pending = pendingSparringScores.get(requestKey);
   if (pending) return pending;
 
-  const request = judgeSparringSessionOnce(inputResult.data, config);
+  const request = judgeSparringSessionOnce(inputResult.data, config, workspaceContext);
   pendingSparringScores.set(requestKey, request);
   try {
     return await request;
@@ -1460,6 +1475,7 @@ export async function judgeSparringSession(
 async function judgeSparringSessionOnce(
   input: SparringScoreInput,
   config: ProviderConfig,
+  workspaceContext?: WorkspaceToolContext,
 ): Promise<SparringScoreResponse> {
   const requestInput: SparringScoreInput = {
     ...input,
@@ -1477,6 +1493,7 @@ async function judgeSparringSessionOnce(
   }
 
   return await callSupabaseAI<SparringScoreResponse>('sparring', inputResult.data, config, {
+    workspaceContext,
     transformResponse: (rawData) => validateSparringScoreResponse((rawData as { output: unknown }).output),
   });
 }
diff --git a/src/lib/stores/sparring-store.ts b/src/lib/stores/sparring-store.ts
index dd898ddb9..49f8532c4 100644
--- a/src/lib/stores/sparring-store.ts
+++ b/src/lib/stores/sparring-store.ts
@@ -47,9 +47,13 @@ interface StartSessionInput {
 interface SparringStoreState {
   ownerUserId: string | null;
   currentSession: SparringSession | null;
+  privateSessionBackup: SparringSession | null;
   savedSessions: SparringSession[];
   hydrated: boolean;
+  beginWorkspaceSession: () => void;
+  endWorkspaceSession: () => void;
   startSession: (input: StartSessionInput) => SparringSession;
+  restoreWorkspaceSession: (input: unknown) => boolean;
   setDraft: (draft: string) => void;
   tickTimer: (now?: number) => void;
   pauseTimer: (now?: number) => void;
@@ -105,10 +109,11 @@ const PersistedSparringSessionSchema = z.object({
 const PersistedSparringStateSchema = z.object({
   ownerUserId: z.string().nullable().optional(),
   currentSession: PersistedSparringSessionSchema.nullable().optional(),
+  privateSessionBackup: PersistedSparringSessionSchema.nullable().optional(),
   savedSessions: z.array(PersistedSparringSessionSchema).optional(),
 });
 
-type PersistedSparringState = Pick<SparringStoreState, 'ownerUserId' | 'currentSession' | 'savedSessions'>;
+type PersistedSparringState = Pick<SparringStoreState, 'ownerUserId' | 'currentSession' | 'privateSessionBackup' | 'savedSessions'>;
 const MAX_SAVED_SESSIONS = 50;
 const PERSIST_DELAY_MS = 250;
 let pendingStorageWrite: { name: string; value: string } | null = null;
@@ -162,18 +167,22 @@ const debouncedSessionStorage = {
 
 if (typeof window !== 'undefined') window.addEventListener('pagehide', flushPendingStorageWrite);
 
-function migratePersistedSparringState(value: unknown): PersistedSparringState {
-  const parsed = PersistedSparringStateSchema.safeParse(value);
-  if (!parsed.success) return { ownerUserId: null, currentSession: null, savedSessions: [] };
-  const rebuildTurns = (session: z.output<typeof PersistedSparringSessionSchema>): SparringSession => ({
+function rebuildSession(session: z.output<typeof PersistedSparringSessionSchema>): SparringSession {
+  return {
     ...session,
     timerDeadline: session.timerDeadline ?? null,
     turns: buildSparringTurns(session.format, session.userSide),
-  });
+  };
+}
+
+function migratePersistedSparringState(value: unknown): PersistedSparringState {
+  const parsed = PersistedSparringStateSchema.safeParse(value);
+  if (!parsed.success) return { ownerUserId: null, currentSession: null, privateSessionBackup: null, savedSessions: [] };
   return {
     ownerUserId: parsed.data.ownerUserId ?? null,
-    currentSession: parsed.data.currentSession ? rebuildTurns(parsed.data.currentSession) : null,
-    savedSessions: (parsed.data.savedSessions ?? []).map(rebuildTurns),
+    currentSession: parsed.data.currentSession ? rebuildSession(parsed.data.currentSession) : null,
+    privateSessionBackup: parsed.data.privateSessionBackup ? rebuildSession(parsed.data.privateSessionBackup) : null,
+    savedSessions: (parsed.data.savedSessions ?? []).map(rebuildSession),
   };
 }
 
@@ -279,9 +288,19 @@ export const useSparringStore = create<SparringStoreState>()(
     (set, get) => ({
       ownerUserId: null as string | null,
       currentSession: null as SparringSession | null,
+      privateSessionBackup: null as SparringSession | null,
       savedSessions: [] as SparringSession[],
       hydrated: false,
 
+      beginWorkspaceSession: () => set((state) => ({
+        currentSession: null,
+        privateSessionBackup: state.privateSessionBackup ?? state.currentSession,
+      })),
+      endWorkspaceSession: () => set((state) => ({
+        currentSession: state.privateSessionBackup,
+        privateSessionBackup: null,
+      })),
+
       startSession: (input) => {
         const now = Date.now();
         const turns = buildSparringTurns(input.format, input.userSide);
@@ -304,6 +323,13 @@ export const useSparringStore = create<SparringStoreState>()(
         return session;
       },
 
+      restoreWorkspaceSession: (input) => {
+        const parsed = PersistedSparringSessionSchema.safeParse(input);
+        if (!parsed.success) return false;
+        set({ currentSession: rebuildSession(parsed.data) });
+        return true;
+      },
+
       setDraft: (draft) => set((state) => state.currentSession
         ? { currentSession: { ...state.currentSession, draft, updatedAt: Date.now() } }
         : state),
@@ -410,7 +436,7 @@ export const useSparringStore = create<SparringStoreState>()(
       prepareForUser: (userId) => {
         if (get().ownerUserId === userId) return;
         hydrationEpoch += 1;
-        set({ ownerUserId: userId, currentSession: null, savedSessions: [], hydrated: false });
+        set({ ownerUserId: userId, currentSession: null, privateSessionBackup: null, savedSessions: [], hydrated: false });
       },
 
       hydrateSavedSessions: async () => {
@@ -455,13 +481,13 @@ export const useSparringStore = create<SparringStoreState>()(
       abandonSession: () => set({ currentSession: null }),
       resetLocalData: () => {
         hydrationEpoch += 1;
-        set({ ownerUserId: null, currentSession: null, savedSessions: [], hydrated: false });
+        set({ ownerUserId: null, currentSession: null, privateSessionBackup: null, savedSessions: [], hydrated: false });
       },
     }),
     {
       name: 'debate-sparring-storage',
       storage: createJSONStorage(() => debouncedSessionStorage),
-      version: 3,
+      version: 4,
       migrate: (persistedState) => migratePersistedSparringState(persistedState),
       merge: (persistedState, currentState) => ({
         ...currentState,
@@ -470,6 +496,7 @@ export const useSparringStore = create<SparringStoreState>()(
       partialize: (state) => ({
         ownerUserId: state.ownerUserId,
         currentSession: state.currentSession,
+        privateSessionBackup: state.privateSessionBackup,
         savedSessions: state.savedSessions.slice(0, MAX_SAVED_SESSIONS),
       }),
     },
diff --git a/src/lib/workspace/practice-client.ts b/src/lib/workspace/practice-client.ts
new file mode 100644
index 000000000..4602627de
--- /dev/null
+++ b/src/lib/workspace/practice-client.ts
@@ -0,0 +1,135 @@
+import { z } from "zod";
+import { supabase } from "@/lib/supabase/client";
+import type { Source } from "@/lib/stores/session-store";
+
+const sourceSchema = z.object({
+  citation_snapshot: z.record(z.string(), z.unknown()),
+  content: z.string(),
+  created_at: z.string(),
+  id: z.string().uuid(),
+  provenance: z.record(z.string(), z.unknown()),
+  source_type: z.enum(["url", "file", "text"]),
+  title: z.string(),
+});
+const threadSchema = z.object({ created_at: z.string(), id: z.string().uuid(), name: z.string(), updated_at: z.string() });
+const messageSchema = z.object({
+  author_id: z.string().uuid(),
+  content: z.string(),
+  created_at: z.string(),
+  id: z.string().uuid(),
+  request_id: z.string().uuid(),
+  role: z.enum(["user", "assistant"]),
+  status: z.enum(["progress", "interrupted", "complete"]),
+  thread_id: z.string().uuid(),
+});
+const artifactSchema = z.object({
+  created_at: z.string(),
+  document_epoch: z.number().int().nonnegative().nullable(),
+  document_id: z.string().uuid().nullable(),
+  id: z.string().uuid(),
+  input_snapshot: z.unknown(),
+  output_snapshot: z.unknown().nullable(),
+  progress: z.unknown(),
+  request_id: z.string().uuid(),
+  status: z.enum(["progress", "interrupted", "complete"]),
+  tool: z.enum(["generate", "factoids", "brainstorm", "attack", "ask", "flowchart", "crossfire", "sparring"]),
+  updated_at: z.string(),
+});
+
+export type WorkspaceSource = z.infer<typeof sourceSchema>;
+export type WorkspaceThread = z.infer<typeof threadSchema>;
+export type WorkspaceThreadMessage = z.infer<typeof messageSchema>;
+export type WorkspaceArtifact = z.infer<typeof artifactSchema>;
+
+export async function listWorkspacePractice(workspaceId: string) {
+  const [sources, threads, messages, artifacts] = await Promise.all([
+    supabase.from("workspace_sources").select("citation_snapshot,content,created_at,id,provenance,source_type,title").eq("workspace_id", workspaceId).order("created_at"),
+    supabase.from("workspace_threads").select("created_at,id,name,updated_at").eq("workspace_id", workspaceId).order("updated_at", { ascending: false }),
+    supabase.from("workspace_thread_messages").select("author_id,content,created_at,id,request_id,role,status,thread_id").eq("workspace_id", workspaceId).order("created_at"),
+    supabase.from("workspace_artifacts").select("created_at,document_epoch,document_id,id,input_snapshot,output_snapshot,progress,request_id,status,tool,updated_at").eq("workspace_id", workspaceId).order("updated_at", { ascending: false }),
+  ]);
+  for (const result of [sources, threads, messages, artifacts]) if (result.error) throw result.error;
+  return {
+    artifacts: artifactSchema.array().parse(artifacts.data ?? []),
+    messages: messageSchema.array().parse(messages.data ?? []),
+    sources: sourceSchema.array().parse(sources.data ?? []),
+    threads: threadSchema.array().parse(threads.data ?? []),
+  };
+}
+
+export async function saveWorkspaceSource(workspaceId: string, source: Pick<Source, "content" | "metadata" | "origin" | "title" | "type">) {
+  const id = crypto.randomUUID();
+  const provenance = { ...(source.metadata ?? {}), ...(source.origin ? { origin: source.origin } : {}) };
+  const { data, error } = await supabase.rpc("save_workspace_source", {
+    p_citation_snapshot: { ...provenance, title: source.title, capturedAt: new Date().toISOString() },
+    p_content: source.content,
+    p_provenance: provenance,
+    p_source_id: id,
+    p_source_type: source.type,
+    p_title: source.title,
+    p_workspace_id: workspaceId,
+  });
+  if (error) throw error;
+  return z.string().uuid().parse(data);
+}
+
+export async function createWorkspaceThread(workspaceId: string, name: string) {
+  const id = crypto.randomUUID();
+  const { data, error } = await supabase.rpc("create_workspace_thread", {
+    p_name: name,
+    p_thread_id: id,
+    p_workspace_id: workspaceId,
+  });
+  if (error) throw error;
+  return z.string().uuid().parse(data);
+}
+
+export async function saveWorkspaceThreadMessage(input: {
+  content: string;
+  messageId?: string;
+  requestId: string;
+  role: "user" | "assistant";
+  status: "progress" | "interrupted" | "complete";
+  threadId: string;
+  workspaceId: string;
+}) {
+  const { data, error } = await supabase.rpc("save_workspace_thread_message", {
+    p_content: input.content,
+    p_message_id: input.messageId ?? crypto.randomUUID(),
+    p_request_id: input.requestId,
+    p_role: input.role,
+    p_status: input.status,
+    p_thread_id: input.threadId,
+    p_workspace_id: input.workspaceId,
+  });
+  if (error) throw error;
+  return z.string().uuid().parse(data);
+}
+
+export async function saveWorkspaceArtifact(input: {
+  artifactId?: string;
+  documentEpoch: number | null;
+  documentId: string | null;
+  inputSnapshot: unknown;
+  outputSnapshot?: unknown;
+  progress?: unknown;
+  requestId: string;
+  status: "progress" | "interrupted" | "complete";
+  tool: WorkspaceArtifact["tool"];
+  workspaceId: string;
+}) {
+  const { data, error } = await supabase.rpc("save_workspace_artifact", {
+    p_artifact_id: input.artifactId ?? crypto.randomUUID(),
+    p_document_epoch: input.documentEpoch,
+    p_document_id: input.documentId,
+    p_input_snapshot: input.inputSnapshot,
+    p_output_snapshot: input.outputSnapshot ?? null,
+    p_progress: input.progress ?? {},
+    p_request_id: input.requestId,
+    p_status: input.status,
+    p_tool: input.tool,
+    p_workspace_id: input.workspaceId,
+  });
+  if (error) throw error;
+  return z.string().uuid().parse(data);
+}
diff --git a/src/lib/workspace/review.ts b/src/lib/workspace/review.ts
index c7b921df5..7b551e3ba 100644
--- a/src/lib/workspace/review.ts
+++ b/src/lib/workspace/review.ts
@@ -48,19 +48,20 @@ export interface WorkspaceProposal {
 }
 
 const bytesSchema = z.array(z.number().int().min(0).max(255)).transform((bytes) => Uint8Array.from(bytes));
+const contentSchema = z.array(z.unknown()).nullable().transform((content) => content ?? []);
 const serializedProposalSchema = z.object({
   authorId: z.string().uuid(),
   baseStateVector: bytesSchema,
   documentEpoch: z.number().int().nonnegative(),
   hunks: z.array(z.object({
-    contextAfter: z.array(z.unknown()),
-    contextBefore: z.array(z.unknown()),
+    contextAfter: contentSchema,
+    contextBefore: contentSchema,
     absoluteFrom: z.number().int().nonnegative(),
     absoluteTo: z.number().int().nonnegative(),
     from: bytesSchema,
     id: z.string().min(1).max(100),
     kind: z.enum(["insert", "delete", "format"]),
-    original: z.array(z.unknown()),
+    original: contentSchema,
     replacement: z.array(z.unknown()),
     status: z.enum(["pending", "accepted", "rejected", "stale"]),
     to: bytesSchema,
@@ -83,7 +84,19 @@ export function serializeProposal(proposal: WorkspaceProposal) {
 }
 
 export function deserializeProposal(input: unknown): WorkspaceProposal {
-  return serializedProposalSchema.parse(input) as WorkspaceProposal;
+  const proposal = serializedProposalSchema.parse(input);
+  return {
+    ...proposal,
+    baseStateVector: new Uint8Array(proposal.baseStateVector),
+    hunks: proposal.hunks.map((hunk) => ({
+      ...hunk,
+      contextAfter: hunk.contextAfter ?? [],
+      contextBefore: hunk.contextBefore ?? [],
+      from: new Uint8Array(hunk.from),
+      original: hunk.original ?? [],
+      to: new Uint8Array(hunk.to),
+    })),
+  };
 }
 
 export interface QuoteAnchor {
@@ -144,13 +157,13 @@ function resolvedRange(editor: Editor, hunk: ProposalHunk) {
   const { from, to } = range;
 
   const documentEnd = editor.state.doc.content.size;
-  const original = editor.state.doc.slice(from, to).content.toJSON();
+  const original = editor.state.doc.slice(from, to).content.toJSON() ?? [];
   const contextBefore = editor.state.doc
     .slice(Math.max(0, from - 1), from)
-    .content.toJSON();
+    .content.toJSON() ?? [];
   const contextAfter = editor.state.doc
     .slice(to, Math.min(documentEnd, to + 1))
-    .content.toJSON();
+    .content.toJSON() ?? [];
 
   return sameContent(original, hunk.original) &&
     sameContent(contextBefore, hunk.contextBefore) &&
@@ -224,14 +237,14 @@ export function createProposal({
         to: Y.encodeRelativePosition(
           createMappablePosition(to, editor.state).yRelativePosition,
         ),
-        original: editor.state.doc.slice(from, to).content.toJSON(),
+        original: editor.state.doc.slice(from, to).content.toJSON() ?? [],
         replacement,
         contextBefore: editor.state.doc
           .slice(Math.max(0, from - 1), from)
-          .content.toJSON(),
+          .content.toJSON() ?? [],
         contextAfter: editor.state.doc
           .slice(to, Math.min(documentEnd, to + 1))
-          .content.toJSON(),
+          .content.toJSON() ?? [],
       };
     }),
   };
@@ -258,9 +271,9 @@ export function acceptProposalHunkInDocument({
   });
   const { absoluteFrom: from, absoluteTo: to } = hunk;
   const documentEnd = state.doc.content.size;
-  const original = state.doc.slice(from, to).content.toJSON();
-  const contextBefore = state.doc.slice(Math.max(0, from - 1), from).content.toJSON();
-  const contextAfter = state.doc.slice(to, Math.min(documentEnd, to + 1)).content.toJSON();
+  const original = state.doc.slice(from, to).content.toJSON() ?? [];
+  const contextBefore = state.doc.slice(Math.max(0, from - 1), from).content.toJSON() ?? [];
+  const contextAfter = state.doc.slice(to, Math.min(documentEnd, to + 1)).content.toJSON() ?? [];
   if (
     documentEpoch !== proposal.documentEpoch ||
     !sameContent(original, hunk.original) ||
diff --git a/src/lib/workspace/tool-context.ts b/src/lib/workspace/tool-context.ts
new file mode 100644
index 000000000..fed42d39d
--- /dev/null
+++ b/src/lib/workspace/tool-context.ts
@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { saveWorkspaceArtifact, type WorkspaceArtifact } from "./practice-client";
+
+const contextSchema = z.object({
+  documentEpoch: z.number().int().nonnegative(),
+  documentId: z.string().uuid(),
+  documentIds: z.array(z.string().uuid()).min(1).max(12),
+  documentText: z.string().max(100000),
+  documentTitle: z.string(),
+  motion: z.string(),
+  requestId: z.string().uuid(),
+  returnUrl: z.string().regex(/^\/app\/workspaces\/[0-9a-f-]+$/),
+  side: z.enum(["pro", "con"]),
+  sourceIds: z.array(z.string().uuid()).max(20),
+  threadRequest: z.object({
+    assistantMessageId: z.string().uuid(),
+    userMessageId: z.string().uuid(),
+  }).nullable(),
+  threadId: z.string().uuid().nullable(),
+  workspaceId: z.string().uuid(),
+});
+
+export type WorkspaceToolContext = z.infer<typeof contextSchema>;
+export type WorkspaceTool = WorkspaceArtifact["tool"];
+
+export function parseWorkspaceToolContext(value: unknown) {
+  return contextSchema.safeParse(value).data ?? null;
+}
+
+export function workspaceRouteState(context: WorkspaceToolContext) {
+  return { workspaceContext: context, workspaceLaunch: true };
+}
+
+export async function attachWorkspaceResult(
+  context: WorkspaceToolContext | null,
+  tool: WorkspaceTool,
+  input: unknown,
+  output: unknown,
+) {
+  if (!context) return;
+  await saveWorkspaceArtifact({
+    documentEpoch: context.documentEpoch,
+    documentId: context.documentId,
+    inputSnapshot: input,
+    outputSnapshot: output,
+    requestId: crypto.randomUUID(),
+    status: "complete",
+    tool,
+    workspaceId: context.workspaceId,
+  });
+}
diff --git a/src/locales/en.json b/src/locales/en.json
index c07090379..17f85807c 100644
--- a/src/locales/en.json
+++ b/src/locales/en.json
@@ -177,6 +177,32 @@
     "original": "Original",
     "proposed": "Proposed",
     "emptyChange": "Empty",
+    "evidence": "Evidence",
+    "sourceTitle": "Source title",
+    "quotedEvidence": "Quoted evidence",
+    "addEvidence": "Add evidence",
+    "copyPrivateSource": "Copy from private library",
+    "searchEvidence": "Search evidence",
+    "insertCitation": "Insert citation",
+    "useInContext": "Use in AI context",
+    "teamThreads": "Team threads",
+    "threadName": "Thread name",
+    "createThread": "Create",
+    "threadMessage": "Team message",
+    "send": "Send",
+    "you": "You",
+    "practice": "Practice",
+    "sharedScope": "Workspace-started sessions use shared case context and attach results here.",
+    "practiceFailed": "The workspace practice item could not be saved.",
+    "sharedToolScope": "Shared workspace session · {{document}}",
+    "returnToWorkspace": "Return to workspace",
+    "suggestRewrite": "Suggest AI rewrite",
+    "sharePrivateResult": "Share a private result",
+    "shareResult": "Share",
+    "resumePractice": "Resume",
+    "contextSummary": "Included: selected document, {{included}} sources{{thread}}. Omitted: {{omitted}} sources.",
+    "contextThread": ", shared thread",
+    "contextDocuments": "AI context documents",
     "proposal": {
       "insert": "Proposed insertion",
       "delete": "Proposed deletion",
diff --git a/src/locales/es.json b/src/locales/es.json
index 8935ddc47..11b5151fe 100644
--- a/src/locales/es.json
+++ b/src/locales/es.json
@@ -177,6 +177,32 @@
     "original": "Original",
     "proposed": "Propuesto",
     "emptyChange": "Vacío",
+    "evidence": "Evidencia",
+    "sourceTitle": "Título de la fuente",
+    "quotedEvidence": "Evidencia citada",
+    "addEvidence": "Añadir evidencia",
+    "copyPrivateSource": "Copiar de la biblioteca privada",
+    "searchEvidence": "Buscar evidencia",
+    "insertCitation": "Insertar cita",
+    "useInContext": "Usar en el contexto de IA",
+    "teamThreads": "Hilos del equipo",
+    "threadName": "Nombre del hilo",
+    "createThread": "Crear",
+    "threadMessage": "Mensaje del equipo",
+    "send": "Enviar",
+    "you": "Tú",
+    "practice": "Práctica",
+    "sharedScope": "Las sesiones iniciadas aquí usan el contexto compartido y adjuntan sus resultados.",
+    "practiceFailed": "No se pudo guardar el elemento de práctica.",
+    "sharedToolScope": "Sesión compartida · {{document}}",
+    "returnToWorkspace": "Volver al espacio",
+    "suggestRewrite": "Proponer reescritura con IA",
+    "sharePrivateResult": "Compartir un resultado privado",
+    "shareResult": "Compartir",
+    "resumePractice": "Reanudar",
+    "contextSummary": "Incluido: documento seleccionado, {{included}} fuentes{{thread}}. Omitido: {{omitted}} fuentes.",
+    "contextThread": ", hilo compartido",
+    "contextDocuments": "Documentos del contexto de IA",
     "proposal": {
       "insert": "Inserción propuesta",
       "delete": "Eliminación propuesta",
diff --git a/src/locales/hu.json b/src/locales/hu.json
index f4da98fc4..9943ac957 100644
--- a/src/locales/hu.json
+++ b/src/locales/hu.json
@@ -177,6 +177,32 @@
     "original": "Eredeti",
     "proposed": "Javasolt",
     "emptyChange": "Üres",
+    "evidence": "Bizonyíték",
+    "sourceTitle": "Forrás címe",
+    "quotedEvidence": "Idézett bizonyíték",
+    "addEvidence": "Bizonyíték hozzáadása",
+    "copyPrivateSource": "Másolás a privát könyvtárból",
+    "searchEvidence": "Bizonyíték keresése",
+    "insertCitation": "Hivatkozás beszúrása",
+    "useInContext": "Használat az AI-kontextusban",
+    "teamThreads": "Csapatbeszélgetések",
+    "threadName": "Beszélgetés neve",
+    "createThread": "Létrehozás",
+    "threadMessage": "Csapatüzenet",
+    "send": "Küldés",
+    "you": "Te",
+    "practice": "Gyakorlás",
+    "sharedScope": "Az innen indított gyakorlatok közös kontextust használnak, és ide mentik az eredményt.",
+    "practiceFailed": "A gyakorlási elem nem menthető.",
+    "sharedToolScope": "Közös munkatér-menet · {{document}}",
+    "returnToWorkspace": "Vissza a munkatérhez",
+    "suggestRewrite": "AI-átírás javaslata",
+    "sharePrivateResult": "Privát eredmény megosztása",
+    "shareResult": "Megosztás",
+    "resumePractice": "Folytatás",
+    "contextSummary": "Bevonva: kijelölt dokumentum, {{included}} forrás{{thread}}. Kihagyva: {{omitted}} forrás.",
+    "contextThread": ", közös beszélgetés",
+    "contextDocuments": "AI-kontextus dokumentumai",
     "proposal": {
       "insert": "Javasolt beszúrás",
       "delete": "Javasolt törlés",
diff --git a/src/pages/AskPage.tsx b/src/pages/AskPage.tsx
index a93e09935..28beca108 100644
--- a/src/pages/AskPage.tsx
+++ b/src/pages/AskPage.tsx
@@ -13,10 +13,12 @@ import { AnimatedSection } from '@/components/ui/animated-section';
 import { ToastAction } from '@/components/ui/toast';
 import { useCallback, useEffect, useRef } from 'react';
 import type { AskOutput } from '@/lib/ai/schemas/ask';
+import { WorkspaceToolScope, useWorkspaceToolScope } from '@/components/features/workspace/WorkspaceToolScope';
 
 const MAX_AI_INPUT_LENGTH = 50000;
 
 export default function AskPage() {
+  const workspace = useWorkspaceToolScope('ask');
   const {
     askMessages,
     askLoading,
@@ -107,7 +109,7 @@ export default function AskPage() {
         fileContext = contents.join('\n');
       }
 
-      const history = askMessages.map(m => ({ role: m.role, content: m.content }));
+      const history = workspace.context ? [] : askMessages.map(m => ({ role: m.role, content: m.content }));
       const fullMessage = fileContext ? `CONTEXT:\n${fileContext}\n\nQUESTION: ${message}` : message;
       if (fullMessage.length > MAX_AI_INPUT_LENGTH) {
         toast({
@@ -127,12 +129,13 @@ export default function AskPage() {
         webSearch,
         prosConsMode,
         argumentMapMode,
+        workspaceContext: workspace.context ?? undefined,
       };
 
       let result: AskOutput;
       const askStartTime = Date.now();
 
-      if (isAskStreamingSupported(config, { ...options, mode })) {
+      if (!workspace.context && isAskStreamingSupported(config, { ...options, mode })) {
         let receivedStreamText = false;
         let partialResponse = '';
         const streamingMessage = {
@@ -220,6 +223,7 @@ export default function AskPage() {
           generatedAt: result.generatedAt || new Date().toISOString(),
         }
       });
+      await workspace.attach({ fullMessage, history, mode }, result);
     } catch (error) {
       if (!isCurrentRequest()) return;
       setAskStreamingAssistant(null);
@@ -309,6 +313,7 @@ export default function AskPage() {
 
   return (
     <div className="container py-8 px-4">
+      <WorkspaceToolScope context={workspace.context} />
       <div className="max-w-5xl mx-auto">
         <AnimatedSection className="mb-8">
           <h1 className="text-3xl font-bold text-foreground">{t('nav.ask')}</h1>
diff --git a/src/pages/AttackPage.tsx b/src/pages/AttackPage.tsx
index f0ab29780..32a90abaf 100644
--- a/src/pages/AttackPage.tsx
+++ b/src/pages/AttackPage.tsx
@@ -15,8 +15,11 @@ import { useNavigate } from 'react-router-dom';
 import { StreamingIndicator } from '@/components/ui/streaming-indicator';
 import { AnimatedSection } from '@/components/ui/animated-section';
 import { prefillFromAttack } from '@/lib/crossfire/prefill';
+import { WorkspaceToolScope, useWorkspaceToolScope } from '@/components/features/workspace/WorkspaceToolScope';
+import { workspaceRouteState } from '@/lib/workspace/tool-context';
 
 export default function AttackPage() {
+  const workspace = useWorkspaceToolScope('attack');
   const { attackResult, attackLoading, attackForm, setAttackResult, setAttackLoading, addAskMessage, setAskLoading, askMessages } = useSessionStore();
   const { getFeatureConfig } = useSettingsStore();
   const config = getFeatureConfig('attack'); // Actually we should use 'ask' config for the chat part
@@ -30,9 +33,10 @@ export default function AttackPage() {
   const handleSubmit = async (data: AttackInput) => {
     setAttackLoading(true);
     try {
-      const { result, discoveredSources } = await attackCase(data, config);
+      const { result, discoveredSources } = await attackCase(data, config, workspace.context ?? undefined);
       setDiscoveredSources(discoveredSources);
       setAttackResult(result);
+      await workspace.attach(data, result);
       toast({ title: t('attack.complete', 'Attack analysis complete'), description: t('attack.completeDesc', 'The critique is ready.'), variant: 'success' });
     } catch (error) {
       console.error('Failed to attack case:', error);
@@ -96,12 +100,16 @@ export default function AttackPage() {
   const handlePracticeCrossfire = () => {
     if (!attackResult) return;
     navigate('/app/crossfire', {
-      state: prefillFromAttack(attackForm?.caseText ?? '', attackResult),
+      state: {
+        ...prefillFromAttack(attackForm?.caseText ?? '', attackResult),
+        ...(workspace.context ? workspaceRouteState(workspace.context) : {}),
+      },
     });
   };
 
   return (
     <div className="container py-8 px-4">
+      <WorkspaceToolScope context={workspace.context} />
       <div className="max-w-6xl mx-auto">
         <AnimatedSection className="mb-8 flex flex-col sm:flex-row sm:items-end justify-between gap-4">
           <div>
diff --git a/src/pages/BrainstormPage.tsx b/src/pages/BrainstormPage.tsx
index c78c91519..1a245b89d 100644
--- a/src/pages/BrainstormPage.tsx
+++ b/src/pages/BrainstormPage.tsx
@@ -14,8 +14,10 @@ import type { BrainstormInput } from '@/lib/ai/schemas/brainstorm';
 import { useToast } from '@/hooks/use-toast';
 import { StreamingIndicator } from '@/components/ui/streaming-indicator';
 import { AnimatedSection } from '@/components/ui/animated-section';
+import { WorkspaceToolScope, useWorkspaceToolScope } from '@/components/features/workspace/WorkspaceToolScope';
 
 export default function BrainstormPage() {
+  const workspace = useWorkspaceToolScope('brainstorm');
   const { brainstormResult, brainstormLoading, setBrainstormResult, setBrainstormLoading, addAskMessage, setAskLoading, askMessages } = useSessionStore();
   const { getFeatureConfig } = useSettingsStore();
   const config = getFeatureConfig('brainstorm');
@@ -29,9 +31,10 @@ export default function BrainstormPage() {
   const handleSubmit = async (data: BrainstormInput) => {
     setBrainstormLoading(true);
     try {
-      const { result, discoveredSources } = await brainstorm(data, config);
+      const { result, discoveredSources } = await brainstorm(data, config, workspace.context ?? undefined);
       setDiscoveredSources(discoveredSources);
       setBrainstormResult(result);
+      await workspace.attach(data, result);
       toast({ title: t('brainstorm.complete', 'Brainstorm complete'), description: t('brainstorm.completeDesc', 'Your argument angles are ready.'), variant: 'success' });
     } catch (error) {
       console.error('Failed to brainstorm:', error);
@@ -93,6 +96,7 @@ export default function BrainstormPage() {
 
   return (
     <div className="container py-8 px-4">
+      <WorkspaceToolScope context={workspace.context} />
       <div className="max-w-6xl mx-auto">
         <AnimatedSection className="mb-8 flex flex-col sm:flex-row sm:items-end justify-between gap-4">
           <div>
diff --git a/src/pages/CrossfirePage.tsx b/src/pages/CrossfirePage.tsx
index b29e322ed..632539698 100644
--- a/src/pages/CrossfirePage.tsx
+++ b/src/pages/CrossfirePage.tsx
@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useMemo, useReducer, useRef, useState, type KeyboardEvent as ReactKeyboardEvent } from 'react';
-import { useLocation } from 'react-router-dom';
+import { useLocation, useNavigate } from 'react-router-dom';
 import { motion, useReducedMotion } from 'framer-motion';
 import { useTranslation } from 'react-i18next';
 import {
@@ -33,6 +33,7 @@ import {
 import {
   CrossfireConfigSchema,
   CrossfirePrefillSchema,
+  CrossfireStateSchema,
   MAX_CROSSFIRE_ARGUMENT_CHARS,
   MAX_CROSSFIRE_RESOLUTION_CHARS,
   MAX_CROSSFIRE_TURN_CHARS,
@@ -50,16 +51,22 @@ import { useSessionStore } from '@/lib/stores/session-store';
 import { useSettingsStore } from '@/lib/stores/settings-store';
 import { useAuth } from '@/lib/supabase/AuthProvider';
 import { cn } from '@/lib/utils';
+import { WorkspaceToolScope, useWorkspaceToolScope } from '@/components/features/workspace/WorkspaceToolScope';
+import { saveWorkspaceArtifact } from '@/lib/workspace/practice-client';
 
 const SESSION_ID_PREFIX = 'crossfire';
 
 function routePrefill(value: unknown): CrossfirePrefill | undefined {
-  const parsed = CrossfirePrefillSchema.safeParse(value);
+  const input = value && typeof value === 'object'
+    ? (({ argument, resolution, seedQuestions, source }) => ({ argument, resolution, seedQuestions, source }))(value as Record<string, unknown>)
+    : value;
+  const parsed = CrossfirePrefillSchema.safeParse(input);
   return parsed.success ? parsed.data : undefined;
 }
 
-function restoreState(userId: string | undefined, prefill: CrossfirePrefill | undefined): CrossfireState {
-  const restored = userId ? loadCrossfireDraft(userId) : null;
+function restoreState(userId: string | undefined, prefill: CrossfirePrefill | undefined, fresh = false, resumed?: CrossfireState): CrossfireState {
+  const restored = resumed ?? (userId ? loadCrossfireDraft(userId) : null);
+  if (fresh && prefill) return createCrossfireSetupState(prefill);
   if (restored?.phase === 'active') {
     return restored.request.status === 'pending'
       ? {
@@ -242,15 +249,24 @@ function CrossfireDebriefView({ debrief, onRestart }: { debrief: CrossfireDebrie
 }
 
 export default function CrossfirePage() {
+  const workspace = useWorkspaceToolScope('crossfire');
   const { t } = useTranslation();
   const { user } = useAuth();
   const location = useLocation();
+  const navigate = useNavigate();
+  const workspaceLaunch = (location.state as { workspaceLaunch?: unknown } | null)?.workspaceLaunch === true;
+  const workspaceArtifact = CrossfireStateSchema.safeParse((location.state as { workspaceArtifact?: unknown } | null)?.workspaceArtifact).data;
   const importedPrefill = useMemo(() => routePrefill(location.state), [location.state]);
   const [state, dispatch] = useReducer(
     crossfireReducer,
     undefined,
-    () => restoreState(user?.id, importedPrefill),
+    () => restoreState(user?.id, importedPrefill, workspaceLaunch, workspaceArtifact),
   );
+
+  useEffect(() => {
+    if ((!workspaceLaunch && !workspaceArtifact) || !workspace.context) return;
+    navigate(location.pathname, { replace: true, state: { workspaceContext: workspace.context } });
+  }, [location.pathname, navigate, workspace.context, workspaceArtifact, workspaceLaunch]);
   const previousPhaseRef = useRef(state.phase);
   const phaseChanged = previousPhaseRef.current !== state.phase;
   useEffect(() => {
@@ -263,6 +279,7 @@ export default function CrossfirePage() {
   const [storageError, setStorageError] = useState(false);
   const [stateOwnerId, setStateOwnerId] = useState(user?.id);
   const requestRef = useRef<AbortController | null>(null);
+  const artifactRequestIdRef = useRef(workspace.context?.requestId ?? crypto.randomUUID());
   const signalRequestsRef = useRef(new Set<AbortController>());
   const shouldReduceMotion = useReducedMotion();
   const activeSourceCount = useSessionStore((session) => session.sourceLibrary.filter((source) => source.isActive).length);
@@ -295,6 +312,21 @@ export default function CrossfirePage() {
     setStorageError(!saved && state.phase !== 'complete');
   }, [state, stateOwnerId, user?.id]);
 
+  useEffect(() => {
+    if (!workspace.context) return;
+    void saveWorkspaceArtifact({
+      documentEpoch: workspace.context.documentEpoch,
+      documentId: workspace.context.documentId,
+      inputSnapshot: state.phase === 'setup' ? state.config : { config: state.config },
+      outputSnapshot: state.phase === 'complete' ? state : undefined,
+      progress: state,
+      requestId: artifactRequestIdRef.current,
+      status: state.phase === 'complete' ? 'complete' : 'progress',
+      tool: 'crossfire',
+      workspaceId: workspace.context.workspaceId,
+    });
+  }, [state, workspace.context]);
+
   useEffect(() => {
     if (state.phase !== 'active') return;
     setNow(Date.now());
@@ -315,7 +347,7 @@ export default function CrossfirePage() {
         config: snapshot.config,
         transcript: snapshot.turns,
         expectedReply,
-      }, modelConfig, { signal: controller.signal });
+      }, modelConfig, { signal: controller.signal, workspaceContext: workspace.context ?? undefined });
       if (controller.signal.aborted) return;
       if (!('type' in result)) {
         dispatch({
@@ -351,7 +383,7 @@ export default function CrossfirePage() {
       const classified = classifyError(error);
       dispatch({ type: 'request-failed', expectedReply, errorKind: classified.kind, message: classified.message });
     }
-  }, [modelConfig]);
+  }, [modelConfig, workspace.context]);
 
   const runDebrief = useCallback(async (snapshot: Extract<CrossfireState, { phase: 'debriefing' }>) => {
     requestRef.current?.abort();
@@ -362,7 +394,7 @@ export default function CrossfirePage() {
         operation: 'debrief',
         config: snapshot.config,
         transcript: snapshot.turns,
-      }, modelConfig, { signal: controller.signal });
+      }, modelConfig, { signal: controller.signal, workspaceContext: workspace.context ?? undefined });
       if (controller.signal.aborted) return;
       if ('type' in result) {
         dispatch({
@@ -378,7 +410,7 @@ export default function CrossfirePage() {
       const classified = classifyError(error);
       dispatch({ type: 'debrief-failed', errorKind: classified.kind, message: classified.message });
     }
-  }, [modelConfig]);
+  }, [modelConfig, workspace.context]);
 
   const endSession = useCallback((reason: 'manual' | 'timer') => {
     if (state.phase !== 'active') return;
@@ -412,6 +444,7 @@ export default function CrossfirePage() {
       return;
     }
     setFormError('');
+    artifactRequestIdRef.current = crypto.randomUUID();
     const action = {
       type: 'session-started' as const,
       sessionId: `${SESSION_ID_PREFIX}-${Date.now()}`,
@@ -460,6 +493,7 @@ export default function CrossfirePage() {
     requestRef.current?.abort();
     abortSignalRequests();
     if (user?.id) clearCrossfireDraft(user.id);
+    artifactRequestIdRef.current = crypto.randomUUID();
     dispatch({ type: 'session-reset' });
     setDraftTurn('');
     setFormError('');
@@ -477,6 +511,7 @@ export default function CrossfirePage() {
   if (state.phase === 'setup') {
     return (
       <div className={cn(stateMotionClass, 'container px-4 py-8')}>
+        <WorkspaceToolScope context={workspace.context} />
         <div className="mx-auto max-w-5xl space-y-6">
           <header className="max-w-2xl">
             <div className="mb-3 flex h-11 w-11 items-center justify-center rounded-lg bg-primary/10 text-primary">
@@ -682,6 +717,7 @@ export default function CrossfirePage() {
   if (state.phase === 'complete') {
     return (
       <div className={cn(stateMotionClass, 'container px-4 py-8')}>
+        <WorkspaceToolScope context={workspace.context} />
         <div className="mx-auto max-w-5xl space-y-10">
           <CrossfireDebriefView debrief={state.debrief} onRestart={restart} />
           <Transcript turns={state.turns} reduceMotion={shouldReduceMotion} />
@@ -693,6 +729,7 @@ export default function CrossfirePage() {
   if (state.phase === 'debriefing') {
     return (
       <div className={cn(stateMotionClass, 'container px-4 py-8')}>
+        <WorkspaceToolScope context={workspace.context} />
         <div className="mx-auto max-w-4xl space-y-6">
           <Transcript turns={state.turns} reduceMotion={shouldReduceMotion} />
           <Card>
@@ -731,6 +768,7 @@ export default function CrossfirePage() {
   const remaining = state.endsAt - now;
   return (
     <div className={cn(stateMotionClass, 'container px-4 py-6 md:py-8')}>
+      <WorkspaceToolScope context={workspace.context} />
       <div className="mx-auto max-w-5xl space-y-5">
         <header className="flex flex-col gap-4 border-b border-border/70 pb-5 sm:flex-row sm:items-center sm:justify-between">
           <div>
diff --git a/src/pages/FactoidsPage.tsx b/src/pages/FactoidsPage.tsx
index d1827ab4e..9e2ab0ca8 100644
--- a/src/pages/FactoidsPage.tsx
+++ b/src/pages/FactoidsPage.tsx
@@ -13,8 +13,10 @@ import type { FactoidsInput } from '@/lib/ai/schemas/factoids';
 import { useToast } from '@/hooks/use-toast';
 import { StreamingIndicator } from '@/components/ui/streaming-indicator';
 import { AnimatedSection } from '@/components/ui/animated-section';
+import { WorkspaceToolScope, useWorkspaceToolScope } from '@/components/features/workspace/WorkspaceToolScope';
 
 export default function FactoidsPage() {
+  const workspace = useWorkspaceToolScope('factoids');
   const { factoidsResult, factoidsLoading, factoidsForm, setFactoidsResult, setFactoidsLoading, addAskMessage, setAskLoading, askMessages, addSource, setFactoidsForm } = useSessionStore();
   const { getFeatureConfig } = useSettingsStore();
   const config = getFeatureConfig('factoids');
@@ -29,9 +31,10 @@ export default function FactoidsPage() {
     setDiscoveredSources([]);
     setFactoidsLoading(true);
     try {
-      const { result, discoveredSources: sources } = await factoids(data, config);
+      const { result, discoveredSources: sources } = await factoids(data, config, workspace.context ?? undefined);
       setDiscoveredSources(sources);
       setFactoidsResult(result);
+      await workspace.attach(data, result);
       toast({ title: t('factoids.complete', 'Research complete'), description: t('factoids.completeDesc', 'Verified evidence is ready.'), variant: 'success' });
     } catch (error) {
       console.error('Failed to find factoids:', error);
@@ -108,6 +111,7 @@ export default function FactoidsPage() {
 
   return (
     <div className="container py-8 px-4">
+      <WorkspaceToolScope context={workspace.context} />
       <div className="max-w-6xl mx-auto">
         <AnimatedSection className="mb-8 flex flex-col sm:flex-row sm:items-end justify-between gap-4">
           <div>
diff --git a/src/pages/FlowchartPage.tsx b/src/pages/FlowchartPage.tsx
index b740d268a..bfa1ce253 100644
--- a/src/pages/FlowchartPage.tsx
+++ b/src/pages/FlowchartPage.tsx
@@ -68,6 +68,7 @@ import { toPng } from 'html-to-image';
 import { formatRelativeDate } from '@/lib/date-format';
 import { toast } from 'sonner';
 import type { TFunction } from 'i18next';
+import { WorkspaceToolScope, useWorkspaceToolScope } from '@/components/features/workspace/WorkspaceToolScope';
 
 // Custom node types
 type NodeType = 'thesis' | 'contention' | 'attack' | 'rebuttal' | 'dropped';
@@ -201,6 +202,7 @@ const initialEdges: Edge[] = [
 ];
 
 export default function FlowchartPage() {
+    const workspace = useWorkspaceToolScope('flowchart');
     const { t } = useTranslation();
     const {
         pendingFlowchartData,
@@ -302,6 +304,7 @@ export default function FlowchartPage() {
 
         try {
             await saveFlowchart(saveTitle, { nodes, edges });
+            await workspace.attach({ title: saveTitle }, { nodes, edges });
             setIsSaveDialogOpen(false);
             setSaveTitle('');
             toast.success(t('flowchart.savedToast'));
@@ -417,6 +420,7 @@ export default function FlowchartPage() {
 
     return (
         <div className="space-y-6">
+            <WorkspaceToolScope context={workspace.context} />
             <Card>
                 <CardHeader className="bg-gradient-to-br from-primary/5 to-transparent">
                     <div className="flex items-center justify-between">
diff --git a/src/pages/GeneratePage.tsx b/src/pages/GeneratePage.tsx
index 99e74850a..55c460373 100644
--- a/src/pages/GeneratePage.tsx
+++ b/src/pages/GeneratePage.tsx
@@ -23,8 +23,11 @@ import { StreamingIndicator } from '@/components/ui/streaming-indicator';
 import { AnimatedSection } from '@/components/ui/animated-section';
 import { prefillFromGenerate } from '@/lib/crossfire/prefill';
 import { useReducedMotion } from 'framer-motion';
+import { WorkspaceToolScope, useWorkspaceToolScope } from '@/components/features/workspace/WorkspaceToolScope';
+import { workspaceRouteState } from '@/lib/workspace/tool-context';
 
 export default function GeneratePage() {
+  const workspace = useWorkspaceToolScope('generate');
   const { generateResult, generateLoading, generateForm, setGenerateResult, setGenerateLoading, saveCurrentCase, addAskMessage, setAskLoading, askMessages, setPendingFlowchartData, autosavedCases } = useSessionStore();
   const { getFeatureConfig } = useSettingsStore();
   const config = getFeatureConfig('generate');
@@ -64,7 +67,7 @@ export default function GeneratePage() {
   const handleSubmit = async (data: GenerateInput) => {
     setGenerateLoading(true);
     try {
-      const { result, discoveredSources: sources } = await generateCase(data, config);
+      const { result, discoveredSources: sources } = await generateCase(data, config, workspace.context ?? undefined);
       // Always stamp with real local time and motion
       if (result.metadata) {
         result.metadata.generatedAt = new Date().toISOString();
@@ -72,6 +75,7 @@ export default function GeneratePage() {
       }
       setDiscoveredSources(sources);
       setGenerateResult(result);
+      await workspace.attach(data, result);
       setSuccessfulGenerationSequence((sequence) => sequence + 1);
       toast({ title: t('generate.complete', 'Generate complete'), description: t('generate.completeDesc', 'Your debate case is ready.'), variant: 'success' });
     } catch (error) {
@@ -111,9 +115,9 @@ export default function GeneratePage() {
     };
 
     setGenerateLoading(true);
-    void generateCase(data, config)
-      .then(({ result: next, discoveredSources: sources }) => {
-        setGenerateResult({
+    void generateCase(data, config, workspace.context ?? undefined)
+      .then(async ({ result: next, discoveredSources: sources }) => {
+        const regenerated = {
           ...generateResult,
           ...(section === 'structure' ? { caseStructure: next.caseStructure } : {}),
           ...(section === 'contentions' ? { contentions: next.contentions } : {}),
@@ -121,8 +125,10 @@ export default function GeneratePage() {
           ...(section === 'counters' ? { counters: next.counters } : {}),
           ...(section === 'exordio' ? { exordio: next.exordio } : {}),
           metadata: next.metadata,
-        });
+        };
+        setGenerateResult(regenerated);
         setDiscoveredSources(sources);
+        await workspace.attach({ ...data, regeneratedSection: section }, regenerated);
         toast({ title: t('generate.regenerated', 'Section regenerated'), description: t('generate.regeneratedDesc', 'The selected section has been refreshed.'), variant: 'success' });
       })
       .catch((error) => {
@@ -197,7 +203,10 @@ export default function GeneratePage() {
   const handlePracticeCrossfire = () => {
     if (!generateResult) return;
     navigate('/app/crossfire', {
-      state: prefillFromGenerate(generateForm?.motion ?? generateResult.caseStructure.thesis, generateResult),
+      state: {
+        ...prefillFromGenerate(generateForm?.motion ?? generateResult.caseStructure.thesis, generateResult),
+        ...(workspace.context ? workspaceRouteState(workspace.context) : {}),
+      },
     });
   };
 
@@ -326,6 +335,7 @@ export default function GeneratePage() {
   return (
     <>
     <div className="container py-8 px-4">
+      <WorkspaceToolScope context={workspace.context} />
       <div className="max-w-6xl mx-auto">
         <AnimatedSection className="mb-8 flex flex-col sm:flex-row sm:items-end justify-between gap-4">
           <div>
diff --git a/src/pages/SparringPage.tsx b/src/pages/SparringPage.tsx
index 8e77e927c..fffeb1e51 100644
--- a/src/pages/SparringPage.tsx
+++ b/src/pages/SparringPage.tsx
@@ -1,7 +1,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { ArrowLeft, CircleHelp } from 'lucide-react';
-import { useNavigate } from 'react-router-dom';
+import { useLocation, useNavigate } from 'react-router-dom';
 import { useSparringStore } from '@/lib/stores/sparring-store';
 import { useSettingsStore } from '@/lib/stores/settings-store';
 import { generateSparringTurn, judgeSparringSession } from '@/lib/ai/client';
@@ -11,6 +11,8 @@ import { SparringRound } from '@/components/features/sparring/SparringRound';
 import { SparringScorecard } from '@/components/features/sparring/SparringScorecard';
 import { Button } from '@/components/ui/button';
 import { cn } from '@/lib/utils';
+import { WorkspaceToolScope, useWorkspaceToolScope } from '@/components/features/workspace/WorkspaceToolScope';
+import { saveWorkspaceArtifact } from '@/lib/workspace/practice-client';
 
 function readableError(error: unknown, fallback: string) {
   if (error instanceof Error && error.message.trim()) return error.message;
@@ -23,9 +25,14 @@ function estimateAiTimeUsedSeconds(content: string, limit: number) {
 }
 
 export default function SparringPage() {
+  const workspace = useWorkspaceToolScope('sparring');
   const { t } = useTranslation();
   const navigate = useNavigate();
-  const session = useSparringStore((state) => state.currentSession);
+  const location = useLocation();
+  const workspaceLaunch = (location.state as { workspaceLaunch?: unknown } | null)?.workspaceLaunch === true;
+  const workspaceArtifact = (location.state as { workspaceArtifact?: unknown } | null)?.workspaceArtifact;
+  const storedSession = useSparringStore((state) => state.currentSession);
+  const session = workspaceLaunch || workspaceArtifact !== undefined ? null : storedSession;
   const currentView = !session ? 'setup' : session.phase === 'complete' && session.scorecard ? 'scorecard' : 'round';
   const previousViewRef = useRef(currentView);
   const viewChanged = previousViewRef.current !== currentView;
@@ -34,10 +41,13 @@ export default function SparringPage() {
   }, [currentView]);
   const stateMotionClass = viewChanged ? 'motion-swap' : undefined;
   const startSession = useSparringStore((state) => state.startSession);
+  const restoreWorkspaceSession = useSparringStore((state) => state.restoreWorkspaceSession);
   const submitUserSpeech = useSparringStore((state) => state.submitUserSpeech);
   const appendAiSpeech = useSparringStore((state) => state.appendAiSpeech);
   const completeSession = useSparringStore((state) => state.completeSession);
   const abandonSession = useSparringStore((state) => state.abandonSession);
+  const beginWorkspaceSession = useSparringStore((state) => state.beginWorkspaceSession);
+  const endWorkspaceSession = useSparringStore((state) => state.endWorkspaceSession);
   const getFeatureConfig = useSettingsStore((state) => state.getFeatureConfig);
   const outputLanguage = useSettingsStore((state) => state.outputLanguage);
   const [aiLoading, setAiLoading] = useState(false);
@@ -50,8 +60,22 @@ export default function SparringPage() {
   const judgeRequestRef = useRef<string | null>(null);
   const aiInFlightRef = useRef(false);
   const judgeInFlightRef = useRef(false);
+  const artifactRequestIdRef = useRef(workspace.context?.requestId ?? crypto.randomUUID());
   const isOnlineRef = useRef(isOnline);
 
+  const workspaceRequestId = workspace.context?.requestId;
+  useEffect(() => {
+    if (!workspaceRequestId) return;
+    beginWorkspaceSession();
+    return endWorkspaceSession;
+  }, [beginWorkspaceSession, endWorkspaceSession, workspaceRequestId]);
+
+  useEffect(() => {
+    if (!workspace.context || (!workspaceLaunch && workspaceArtifact === undefined)) return;
+    if (workspaceArtifact !== undefined) restoreWorkspaceSession(workspaceArtifact);
+    navigate(location.pathname, { replace: true, state: { workspaceContext: workspace.context } });
+  }, [location.pathname, navigate, restoreWorkspaceSession, workspace.context, workspaceArtifact, workspaceLaunch]);
+
   useEffect(() => {
     const handleOnline = () => {
       isOnlineRef.current = true;
@@ -125,7 +149,7 @@ export default function SparringPage() {
       currentTurn: turnInput,
     };
 
-    void generateSparringTurn(input, config)
+    void generateSparringTurn(input, config, workspace.context ?? undefined)
       .then((result) => {
         if (aiRequestRef.current !== requestKey) return;
         if (useSparringStore.getState().currentSession?.id !== session.id) return;
@@ -154,7 +178,7 @@ export default function SparringPage() {
           setAiLoading(false);
         }
       });
-  }, [appendAiSpeech, config, outputLanguage, retryNonce, session, t]);
+  }, [appendAiSpeech, config, outputLanguage, retryNonce, session, t, workspace.context]);
 
   useEffect(() => {
     if (!session || session.phase !== 'judging') return;
@@ -177,7 +201,7 @@ export default function SparringPage() {
       speeches: session.speeches,
       language: outputLanguage,
     };
-    void judgeSparringSession(input, config)
+    void judgeSparringSession(input, config, workspace.context ?? undefined)
       .then((result) => {
         if (judgeRequestRef.current !== requestKey) return;
         if (useSparringStore.getState().currentSession?.id !== session.id) return;
@@ -190,9 +214,25 @@ export default function SparringPage() {
       .finally(() => {
         if (judgeRequestRef.current === requestKey) judgeInFlightRef.current = false;
       });
-  }, [completeSession, config, outputLanguage, retryNonce, session, t]);
+  }, [completeSession, config, outputLanguage, retryNonce, session, t, workspace.context]);
+
+  useEffect(() => {
+    if (!workspace.context || !session) return;
+    void saveWorkspaceArtifact({
+      documentEpoch: workspace.context.documentEpoch,
+      documentId: workspace.context.documentId,
+      inputSnapshot: { motion: session.motion, side: session.userSide, format: session.format, difficulty: session.difficulty },
+      outputSnapshot: session.phase === 'complete' ? session : undefined,
+      progress: session,
+      requestId: artifactRequestIdRef.current,
+      status: session.phase === 'complete' ? 'complete' : 'progress',
+      tool: 'sparring',
+      workspaceId: workspace.context.workspaceId,
+    });
+  }, [session, workspace.context]);
 
   const handleStart = (values: SparringSetupValues) => {
+    artifactRequestIdRef.current = crypto.randomUUID();
     startSession(values);
     setAiError(null);
     setJudgingError(null);
@@ -203,6 +243,7 @@ export default function SparringPage() {
   };
 
   const handleRestart = () => {
+    artifactRequestIdRef.current = crypto.randomUUID();
     abandonSession();
     setAiError(null);
     setJudgingError(null);
@@ -232,7 +273,11 @@ export default function SparringPage() {
   if (!session) {
     return (
       <div className={cn(stateMotionClass, 'container px-4 py-8 sm:py-10')}>
-        <SparringSetup onStart={handleStart} />
+        <WorkspaceToolScope context={workspace.context} />
+        <SparringSetup
+          initialValues={workspace.context ? { motion: workspace.context.motion, userSide: workspace.context.side } : undefined}
+          onStart={handleStart}
+        />
       </div>
     );
   }
@@ -240,6 +285,7 @@ export default function SparringPage() {
   if (session.phase === 'complete' && session.scorecard) {
     return (
       <div className={cn(stateMotionClass, 'container px-4 py-8 sm:py-10')}>
+        <WorkspaceToolScope context={workspace.context} />
         <SparringScorecard session={session} scorecard={session.scorecard} onRestart={handleRestart} onExport={handleExportDocx} onExportPdf={handleExportPdf} />
       </div>
     );
@@ -247,6 +293,7 @@ export default function SparringPage() {
 
   return (
     <div className={cn(stateMotionClass, 'container px-4 py-6 sm:py-8')}>
+      <WorkspaceToolScope context={workspace.context} />
       <div className="mb-4 flex items-center justify-between gap-3">
         <Button type="button" variant="ghost" size="sm" onClick={() => navigate('/app')} className="-ml-2 text-muted-foreground"><ArrowLeft className="h-4 w-4" aria-hidden="true" />{t('sparring.round.backToWorkspace', 'Back to workspace')}</Button>
         <span className={cn('flex items-center gap-1.5 text-xs text-muted-foreground', !isOnline && 'text-amber-600 dark:text-amber-400')}><CircleHelp className="h-3.5 w-3.5" aria-hidden="true" />{t('sparring.round.draftSavedNotice', 'Drafts save in this tab')}</span>
diff --git a/src/pages/WorkspacePage.tsx b/src/pages/WorkspacePage.tsx
index aa46276ec..a624f58ba 100644
--- a/src/pages/WorkspacePage.tsx
+++ b/src/pages/WorkspacePage.tsx
@@ -10,6 +10,7 @@ import { WorkspaceEditor, type SaveStatus } from "@/components/features/workspac
 import { WorkspaceAccessPanel } from "@/components/features/workspace/WorkspaceAccessPanel";
 import { WorkspaceReviewPanel } from "@/components/features/workspace/WorkspaceReviewPanel";
 import { WorkspaceVersions } from "@/components/features/workspace/WorkspaceVersions";
+import { WorkspacePracticePanel } from "@/components/features/workspace/WorkspacePracticePanel";
 import { useAuth } from "@/lib/supabase/AuthProvider";
 import {
   changeWorkspaceState,
@@ -18,6 +19,7 @@ import {
   updateWorkspaceDocument,
 } from "@/lib/workspace/client";
 import { loadWorkspacePreference, saveWorkspacePreference } from "@/lib/workspace/preferences";
+import type { WorkspaceSource } from "@/lib/workspace/practice-client";
 
 type DocumentView = "active" | "archived" | "trashed";
 
@@ -36,6 +38,9 @@ export default function WorkspacePage() {
   const [renameTitle, setRenameTitle] = useState("");
   const [busy, setBusy] = useState(false);
   const [operationError, setOperationError] = useState<string | null>(null);
+  const [documentText, setDocumentText] = useState("");
+  const [citationToInsert, setCitationToInsert] = useState<WorkspaceSource | null>(null);
+  const [aiSuggestion, setAiSuggestion] = useState<{ id: string; text: string } | null>(null);
   const [preferenceLoaded, setPreferenceLoaded] = useState(false);
   const workspace = useQuery({
     queryKey: ["workspace", user?.id, workspaceId],
@@ -79,6 +84,9 @@ export default function WorkspacePage() {
 
   useEffect(() => {
     setEditorStatus("Saving");
+    setDocumentText("");
+    setCitationToInsert(null);
+    setAiSuggestion(null);
   }, [selectedDocument?.id]);
 
   useEffect(() => {
@@ -343,6 +351,8 @@ export default function WorkspacePage() {
             )}
             {selectedDocument && session && user ? (
               <WorkspaceEditor
+                aiSuggestion={aiSuggestion}
+                citationToInsert={citationToInsert}
                 documentId={selectedDocument.id}
                 editable={workspace.data.workspace.status === "active" && view === "active"}
                 epoch={selectedDocument.document_epoch}
@@ -356,7 +366,10 @@ export default function WorkspacePage() {
                 }
                 workspaceId={workspace.data.workspace.id}
                 onDurableSequence={setDurableSequence}
+                onCitationInserted={() => setCitationToInsert(null)}
+                onAiSuggestionConsumed={() => setAiSuggestion(null)}
                 onSaveStatus={setEditorStatus}
+                onTextChange={setDocumentText}
               />
             ) : (
               <p role="alert" className="p-4 text-sm text-destructive">
@@ -380,6 +393,22 @@ export default function WorkspacePage() {
               )}
               {selectedDocument && (
                 <>
+                  {user && (
+                    <WorkspacePracticePanel
+                      key={`practice:${selectedDocument.id}`}
+                      documentEpoch={selectedDocument.document_epoch}
+                      documentId={selectedDocument.id}
+                      documents={workspace.data.documents.filter((document) => document.state === "active").map(({ id, side, title }) => ({ id, side, title }))}
+                      documentText={documentText}
+                      documentTitle={selectedDocument.title}
+                      motion={workspace.data.workspace.motion}
+                      onInsertCitation={setCitationToInsert}
+                      onSuggestRewrite={setAiSuggestion}
+                      side={selectedDocument.side}
+                      userId={user.id}
+                      workspaceId={workspace.data.workspace.id}
+                    />
+                  )}
                   {session && (
                     <WorkspaceReviewPanel
                       key={`review:${selectedDocument.id}`}
diff --git a/src/test/ai/client.test.ts b/src/test/ai/client.test.ts
index 1d6699702..6e4370aac 100644
--- a/src/test/ai/client.test.ts
+++ b/src/test/ai/client.test.ts
@@ -8,6 +8,7 @@ import type { GenerateInput, GenerateOutput } from '@/lib/ai/schemas/generate';
 import type { AttackInput, AttackOutput } from '@/lib/ai/schemas/attack';
 import type { BrainstormInput } from '@/lib/ai/schemas/brainstorm';
 import i18n from '@/i18n';
+import type { WorkspaceToolContext } from '@/lib/workspace/tool-context';
 
 const clientMocks = vi.hoisted(() => ({
     toast: vi.fn(),
@@ -267,6 +268,31 @@ describe('AI Client Integration', () => {
         });
     });
 
+    it('keeps private sources and personal prompts out of workspace requests', async () => {
+        setMockInvokeResponse({ output: { response: 'Workspace answer', followUpQuestions: [], uncertainties: [] } });
+        const workspaceContext: WorkspaceToolContext = {
+            documentEpoch: 1,
+            documentId: '11111111-1111-4111-8111-111111111111',
+            documentIds: ['11111111-1111-4111-8111-111111111111'],
+            documentText: 'Accepted text',
+            documentTitle: 'R1',
+            motion: 'Motion',
+            requestId: '22222222-2222-4222-8222-222222222222',
+            returnUrl: '/app/workspaces/33333333-3333-4333-8333-333333333333',
+            side: 'pro' as const,
+            sourceIds: [],
+            threadRequest: null,
+            threadId: null,
+            workspaceId: '33333333-3333-4333-8333-333333333333',
+        };
+
+        await askChat('Question', [], 'general', mockConfig, { workspaceContext });
+
+        expect(supabaseMock.functions.invoke).toHaveBeenCalledWith('ai', expect.objectContaining({
+            body: expect.objectContaining({ customSystemPrompt: null, sources: [], workspaceContext }),
+        }));
+    });
+
     describe('Error Handling', () => {
         it('should throw AIAuthError when no session token exists', async () => {
             setMockSessionToken(null);
diff --git a/src/test/ai/sparring.test.ts b/src/test/ai/sparring.test.ts
index 76941ae55..a10a6736a 100644
--- a/src/test/ai/sparring.test.ts
+++ b/src/test/ai/sparring.test.ts
@@ -177,4 +177,17 @@ describe('sparring AI client', () => {
     expect(response.speech.content).toContain(SESSION.motion);
     expect(supabaseMock.functions.invoke).not.toHaveBeenCalled();
   });
+
+  it('scores with the local provider adapter without calling the Edge function', async () => {
+    const response = await judgeSparringSession(SCORE_INPUT, { ...CONFIG, provider: 'mock' });
+
+    expect(response).toMatchObject({ action: 'score', scorecard: { winner: expect.any(String) } });
+    expect(supabaseMock.functions.invoke).not.toHaveBeenCalled();
+  });
+
+  it('rejects a turn request passed to the scoring operation', async () => {
+    await expect(judgeSparringSession(RESPOND_INPUT as unknown as SparringScoreInput, CONFIG))
+      .rejects.toMatchObject({ name: 'AIResponseError' });
+    expect(supabaseMock.functions.invoke).not.toHaveBeenCalled();
+  });
 });
diff --git a/src/test/deno-assert-shim.ts b/src/test/deno-assert-shim.ts
index 193915bf8..fcb61c7f1 100644
--- a/src/test/deno-assert-shim.ts
+++ b/src/test/deno-assert-shim.ts
@@ -4,6 +4,10 @@
 
 import { isDeepStrictEqual } from "node:util";
 
+export function assert(condition: unknown, msg = "Assertion failed"): asserts condition {
+  if (!condition) throw new Error(msg);
+}
+
 export function assertStringIncludes(actual: string, expected: string, msg = ""): void {
   if (!actual.includes(expected)) {
     throw new Error(
@@ -19,3 +23,20 @@ export function assertEquals(actual: unknown, expected: unknown, msg = ""): void
     );
   }
 }
+
+export async function assertRejects(
+  fn: () => Promise<unknown>,
+  ErrorClass: typeof Error = Error,
+  msgIncludes = "",
+): Promise<Error> {
+  try {
+    await fn();
+  } catch (error) {
+    if (!(error instanceof ErrorClass)) throw error;
+    if (msgIncludes && !error.message.includes(msgIncludes)) {
+      throw new Error(`Expected error message to include: ${msgIncludes}\nActual message: ${error.message}`);
+    }
+    return error;
+  }
+  throw new Error("Expected function to reject");
+}
diff --git a/src/test/pages/ConversationPages.test.tsx b/src/test/pages/ConversationPages.test.tsx
index f4903aef8..64496729f 100644
--- a/src/test/pages/ConversationPages.test.tsx
+++ b/src/test/pages/ConversationPages.test.tsx
@@ -1,8 +1,9 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
-import { BrowserRouter } from 'react-router-dom';
+import { BrowserRouter, MemoryRouter } from 'react-router-dom';
 import type { FactoidsOutput } from '@/lib/ai/schemas/factoids';
+import type { WorkspaceToolContext } from '@/lib/workspace/tool-context';
 
 vi.mock('@/hooks/use-subscription', () => ({
   useSubscription: () => ({ isPro: false, tier: 'trial', loading: false }),
@@ -210,6 +211,37 @@ describe('Conversation Pages', () => {
     expect(sessionState.setAskLoading).toHaveBeenCalledWith(false);
   });
 
+  it('AskPage excludes private chat history from workspace requests', async () => {
+    sessionState.askMessages = [{ role: 'user', content: 'Private question' }];
+    mockAskChat.mockResolvedValueOnce({ response: 'Workspace answer', followUpQuestions: [], uncertainties: [] });
+    const workspaceContext: WorkspaceToolContext = {
+      documentEpoch: 2,
+      documentId: 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb',
+      documentIds: ['bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb'],
+      documentText: 'Accepted text',
+      documentTitle: 'R1',
+      motion: 'Motion',
+      requestId: 'dddddddd-dddd-4ddd-8ddd-dddddddddddd',
+      returnUrl: '/app/workspaces/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa',
+      side: 'pro',
+      sourceIds: [],
+      threadRequest: null,
+      threadId: null,
+      workspaceId: 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa',
+    };
+
+    render(
+      <MemoryRouter initialEntries={[{ pathname: '/app/ask', state: { workspaceContext } }]}>
+        <AskPage />
+      </MemoryRouter>,
+    );
+    fireEvent.click(screen.getByTestId('ask-send'));
+
+    await waitFor(() => expect(mockAskChat).toHaveBeenCalled());
+    expect(mockAskChat.mock.calls[0][1]).toEqual([]);
+    expect(mockAskChat.mock.calls[0][4]).toEqual(expect.objectContaining({ workspaceContext }));
+  });
+
   it('AskPage shows timeout toast for timeout errors', async () => {
     mockAskChat.mockRejectedValueOnce(new Error('timeout'));
     mockIsTimeoutError.mockReturnValueOnce(true);
diff --git a/src/test/pages/FlowchartPage.test.tsx b/src/test/pages/FlowchartPage.test.tsx
index 257faefae..4905f6c2c 100644
--- a/src/test/pages/FlowchartPage.test.tsx
+++ b/src/test/pages/FlowchartPage.test.tsx
@@ -1,4 +1,5 @@
 import { fireEvent, render, screen } from '@testing-library/react';
+import { MemoryRouter } from 'react-router-dom';
 import { beforeEach, expect, test, vi } from 'vitest';
 import FlowchartPage from '@/pages/FlowchartPage';
 import i18n from '@/i18n';
@@ -66,8 +67,10 @@ beforeEach(async () => {
   await i18n.changeLanguage('en');
 });
 
+const renderPage = () => render(<MemoryRouter><FlowchartPage /></MemoryRouter>);
+
 test('keeps a selected node when deletion is cancelled', () => {
-  render(<FlowchartPage />);
+  renderPage();
 
   fireEvent.click(screen.getByRole('button', { name: 'Argument 1' }));
   fireEvent.click(screen.getAllByRole('button', { name: 'Delete' })[0]);
@@ -79,7 +82,7 @@ test('keeps a selected node when deletion is cancelled', () => {
 });
 
 test('deletes a selected node only after confirmation and reports success', () => {
-  render(<FlowchartPage />);
+  renderPage();
 
   fireEvent.click(screen.getByRole('button', { name: 'Argument 1' }));
   fireEvent.click(screen.getAllByRole('button', { name: 'Delete' })[0]);
@@ -104,7 +107,7 @@ test('clears a stale node selection when a saved flowchart is loaded', () => {
       edges: [],
     },
   });
-  render(<FlowchartPage />);
+  renderPage();
 
   fireEvent.click(screen.getByRole('button', { name: 'Argument 1' }));
   fireEvent.click(screen.getByRole('button', { name: 'Load' }));
@@ -125,7 +128,7 @@ test('formats saved-flowchart relative time in Hungarian', async () => {
     data: { nodes: [], edges: [] },
   });
 
-  render(<FlowchartPage />);
+  renderPage();
 
   fireEvent.click(screen.getByRole('button', { name: 'Betöltés' }));
   expect(screen.getByText('körülbelül 1 órával ezelőtt')).toBeInTheDocument();
@@ -133,7 +136,7 @@ test('formats saved-flowchart relative time in Hungarian', async () => {
 
 test('localizes starter flowchart nodes in Hungarian', async () => {
   await i18n.changeLanguage('hu');
-  render(<FlowchartPage />);
+  renderPage();
 
   expect(screen.getByRole('button', { name: '1. érv' })).toBeInTheDocument();
   expect(screen.getByText('Az első érved')).toBeInTheDocument();
diff --git a/src/test/stores/sparring-store.test.ts b/src/test/stores/sparring-store.test.ts
index baee03b32..51ef763a7 100644
--- a/src/test/stores/sparring-store.test.ts
+++ b/src/test/stores/sparring-store.test.ts
@@ -87,7 +87,7 @@ describe('sparring-store', () => {
     sessionStorage.clear();
     resetMockState();
     captureProductEventMock.mockClear();
-    useSparringStore.setState({ ownerUserId: null, currentSession: null, savedSessions: [], hydrated: false });
+    useSparringStore.setState({ ownerUserId: null, currentSession: null, privateSessionBackup: null, savedSessions: [], hydrated: false });
   });
 
   it('starts a session with a live user timer and preserves the draft without writing on every keystroke', () => {
@@ -122,6 +122,44 @@ describe('sparring-store', () => {
     expect(persisted.state?.currentSession?.draft).toBe('My opening claim and warrant.');
   });
 
+  it('keeps a private draft while a workspace session runs', () => {
+    const privateSession = useSparringStore.getState().startSession({
+      motion: 'Private motion',
+      userSide: 'pro',
+      format: 'standard',
+      difficulty: 'medium',
+    });
+
+    useSparringStore.getState().beginWorkspaceSession();
+    expect(useSparringStore.getState()).toMatchObject({ currentSession: null, privateSessionBackup: { id: privateSession.id } });
+    useSparringStore.getState().startSession({
+      motion: 'Workspace motion',
+      userSide: 'con',
+      format: 'ld',
+      difficulty: 'hard',
+    });
+    useSparringStore.getState().endWorkspaceSession();
+
+    expect(useSparringStore.getState().currentSession?.id).toBe(privateSession.id);
+    expect(useSparringStore.getState().privateSessionBackup).toBeNull();
+  });
+
+  it('restores and abandons a persisted workspace session safely', () => {
+    const session = useSparringStore.getState().startSession({
+      motion: 'Workspace motion',
+      userSide: 'con',
+      format: 'ld',
+      difficulty: 'hard',
+    });
+    useSparringStore.setState({ currentSession: null });
+
+    expect(useSparringStore.getState().restoreWorkspaceSession(session)).toBe(true);
+    expect(getSession()).toMatchObject({ id: session.id, motion: 'Workspace motion' });
+    useSparringStore.getState().abandonSession();
+    expect(useSparringStore.getState().currentSession).toBeNull();
+    expect(useSparringStore.getState().restoreWorkspaceSession({ id: 'invalid' })).toBe(false);
+  });
+
   it('migrates an in-progress legacy standard round to the school roles', async () => {
     const session = useSparringStore.getState().startSession({
       motion: 'This House would make public transport free.',
diff --git a/src/test/workspace/review.test.ts b/src/test/workspace/review.test.ts
index 1b9461e0e..1fbcf0e02 100644
--- a/src/test/workspace/review.test.ts
+++ b/src/test/workspace/review.test.ts
@@ -49,6 +49,30 @@ describe("workspace review model", () => {
     };
   }
 
+  it("restores binary proposal anchors after a JSON round trip", () => {
+    const editor = createEditor();
+    editor.commands.setContent("<p>Accepted text</p>");
+    const proposal = review.createProposal({
+      authorId: "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb",
+      documentEpoch: 1,
+      editor,
+      hunks: [{
+        content: [{ type: "paragraph", content: [{ type: "text", text: "Improved text" }] }],
+        from: 0,
+        id: "format",
+        kind: "format",
+        to: editor.state.doc.content.size,
+      }],
+      id: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+    });
+
+    const restored = review.deserializeProposal(JSON.parse(JSON.stringify(review.serializeProposal(proposal))));
+
+    expect(restored.baseStateVector).toBeInstanceOf(Uint8Array);
+    expect(restored.hunks[0].from).toBeInstanceOf(Uint8Array);
+    expect(restored.hunks[0].to).toBeInstanceOf(Uint8Array);
+  });
+
   it("keeps the representative multilingual document structured", () => {
     const editor = createEditor();
 
diff --git a/src/test/workspace/tool-context.test.ts b/src/test/workspace/tool-context.test.ts
new file mode 100644
index 000000000..5469dbd64
--- /dev/null
+++ b/src/test/workspace/tool-context.test.ts
@@ -0,0 +1,45 @@
+import { describe, expect, it, vi } from "vitest";
+
+const saveArtifact = vi.hoisted(() => vi.fn().mockResolvedValue("artifact"));
+vi.mock("@/lib/workspace/practice-client", () => ({ saveWorkspaceArtifact: saveArtifact }));
+
+import { attachWorkspaceResult, parseWorkspaceToolContext, type WorkspaceToolContext } from "@/lib/workspace/tool-context";
+
+const context: WorkspaceToolContext = {
+  documentEpoch: 3,
+  documentId: "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb",
+  documentIds: ["bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb"],
+  documentText: "R1 text",
+  documentTitle: "R1",
+  motion: "Schools should ban phones",
+  requestId: "dddddddd-dddd-4ddd-8ddd-dddddddddddd",
+  returnUrl: "/app/workspaces/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+  side: "pro" as const,
+  sourceIds: ["cccccccc-cccc-4ccc-8ccc-cccccccccccc"],
+  threadRequest: null,
+  threadId: null,
+  workspaceId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+};
+
+describe("workspace tool context", () => {
+  it("preserves the pinned motion, side, document version, and origin", async () => {
+    const parsed = parseWorkspaceToolContext(context);
+    expect(parsed).toMatchObject({ documentEpoch: 3, motion: context.motion, side: "pro", workspaceId: context.workspaceId });
+
+    await attachWorkspaceResult(parsed, "attack", { caseText: "R1 text" }, { score: 80 });
+
+    expect(saveArtifact).toHaveBeenCalledOnce();
+    expect(saveArtifact).toHaveBeenCalledWith(expect.objectContaining({
+      documentEpoch: 3,
+      documentId: context.documentId,
+      requestId: expect.stringMatching(/^[0-9a-f-]{36}$/),
+      tool: "attack",
+      workspaceId: context.workspaceId,
+    }));
+    expect(saveArtifact.mock.calls[0][0].requestId).not.toBe(context.requestId);
+  });
+
+  it("rejects a foreign return route instead of attaching late output elsewhere", () => {
+    expect(parseWorkspaceToolContext({ ...context, returnUrl: "/app/workspaces/not-a-uuid" })).toBeNull();
+  });
+});
diff --git a/supabase/functions/_shared/workspace-context.test.ts b/supabase/functions/_shared/workspace-context.test.ts
new file mode 100644
index 000000000..761d93cd6
--- /dev/null
+++ b/supabase/functions/_shared/workspace-context.test.ts
@@ -0,0 +1,86 @@
+import { assert, assertEquals, assertRejects } from "jsr:@std/assert@1.0.19";
+import { isWorkspaceMember, loadAuthorizedWorkspaceContext } from "./workspace-context.ts";
+
+const workspaceId = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
+const documentId = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb";
+const sourceId = "cccccccc-cccc-4ccc-8ccc-cccccccccccc";
+const userId = "dddddddd-dddd-4ddd-8ddd-dddddddddddd";
+const requestId = "eeeeeeee-eeee-4eee-8eee-eeeeeeeeeeee";
+
+class Query {
+  constructor(private readonly value: () => { data: unknown; error: null }) {}
+  select() { return this; }
+  eq() { return this; }
+  in() { return this; }
+  order() { return this; }
+  limit() { return this; }
+  single() { return Promise.resolve(this.value()); }
+  maybeSingle() { return Promise.resolve(this.value()); }
+  then(resolve: (value: { data: unknown; error: null }) => unknown) { return Promise.resolve(this.value()).then(resolve); }
+}
+
+function database({ member = true, sources = 1 }: { member?: boolean; sources?: number } = {}) {
+  return {
+    from(table: string) {
+      return new Query(() => ({
+        data: table === "workspaces"
+          ? { id: workspaceId, motion: "Motion", status: "active" }
+          : table === "workspace_members"
+            ? member ? { user_id: userId } : null
+            : table === "workspace_documents"
+              ? { document_epoch: 2, id: documentId, side: "pro", title: "R1" }
+              : table === "workspace_sources"
+                ? Array.from({ length: sources }, () => ({ content: "Evidence", id: sourceId, provenance: {}, title: "Source" }))
+                : [],
+        error: null,
+      }));
+    },
+    rpc() {
+      return Promise.resolve({
+        data: {
+          documents: [{ epoch: 2, id: documentId, side: "pro", text: "Durable accepted text", title: "R1" }],
+          messages: [],
+          sources: [],
+          workspace: { motion: "Motion" },
+        },
+        error: null,
+      });
+    },
+  };
+}
+
+function input() {
+  return {
+    documentEpoch: 2,
+    documentId,
+    documentIds: [documentId],
+    documentText: "FORGED CLIENT TEXT",
+    documentTitle: "R1",
+    motion: "Motion",
+    requestId,
+    side: "pro",
+    sourceIds: [sourceId],
+    threadRequest: null,
+    threadId: null,
+    workspaceId,
+  };
+}
+
+Deno.test("workspace AI context uses server durable text after authorizing every ID", async () => {
+  const loaded = await loadAuthorizedWorkspaceContext(database() as never, userId, input());
+  assert(loaded.context.includes("Durable accepted text"));
+  assert(!loaded.context.includes("FORGED CLIENT TEXT"));
+  assertEquals(loaded.meta.includedSources, 1);
+});
+
+Deno.test("workspace AI context rejects a foreign requested source", async () => {
+  await assertRejects(() => loadAuthorizedWorkspaceContext(database({ sources: 0 }) as never, userId, input()), Error, "Workspace unavailable");
+});
+
+Deno.test("workspace AI context rejects a restored document epoch", async () => {
+  await assertRejects(() => loadAuthorizedWorkspaceContext(database() as never, userId, { ...input(), documentEpoch: 1 }), Error, "Workspace unavailable");
+});
+
+Deno.test("workspace access recheck denies a revoked requester", async () => {
+  assertEquals(await isWorkspaceMember(database({ member: false }) as never, userId, workspaceId), false);
+});
diff --git a/supabase/functions/_shared/workspace-context.ts b/supabase/functions/_shared/workspace-context.ts
new file mode 100644
index 000000000..9ae97260e
--- /dev/null
+++ b/supabase/functions/_shared/workspace-context.ts
@@ -0,0 +1,140 @@
+type QueryResult = { data: unknown; error: { message?: string } | null };
+type Query = PromiseLike<QueryResult>;
+type QueryBuilder = Query & {
+  eq(column: string, value: unknown): QueryBuilder;
+  in(column: string, values: unknown[]): QueryBuilder;
+  limit(count: number): QueryBuilder;
+  maybeSingle(): Query;
+  order(column: string, options?: { ascending?: boolean }): QueryBuilder;
+  single(): Query;
+};
+type Database = { from(table: string): { select(columns: string): QueryBuilder } };
+type RpcDatabase = Database & { rpc(name: string, parameters: Record<string, unknown>): Query };
+
+export type AuthorizedWorkspaceContext = {
+  documentEpoch: number;
+  documentId: string;
+  documentIds: string[];
+  documentText: string;
+  documentTitle: string;
+  motion: string;
+  requestId: string;
+  side: "pro" | "con";
+  sourceIds: string[];
+  threadRequest: { assistantMessageId: string; userMessageId: string } | null;
+  threadId: string | null;
+  workspaceId: string;
+};
+
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+function record(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : null;
+}
+
+export function parseWorkspaceContext(value: unknown): AuthorizedWorkspaceContext | null {
+  const input = record(value);
+  if (!input || !UUID.test(String(input.workspaceId)) || !UUID.test(String(input.documentId)) || !UUID.test(String(input.requestId))) return null;
+  const documentEpoch = Number(input.documentEpoch);
+  if (!Number.isSafeInteger(documentEpoch) || documentEpoch < 0) return null;
+  const sourceIds = Array.isArray(input.sourceIds) ? input.sourceIds.filter((id): id is string => typeof id === "string" && UUID.test(id)).slice(0, 20) : [];
+  const documentIds = Array.isArray(input.documentIds) ? input.documentIds.filter((id): id is string => typeof id === "string" && UUID.test(id)).slice(0, 12) : [];
+  const threadId = input.threadId === null || input.threadId === undefined ? null : String(input.threadId);
+  const rawThreadRequest = record(input.threadRequest);
+  const threadRequest = rawThreadRequest
+    && UUID.test(String(rawThreadRequest.assistantMessageId))
+    && UUID.test(String(rawThreadRequest.userMessageId))
+    ? { assistantMessageId: String(rawThreadRequest.assistantMessageId), userMessageId: String(rawThreadRequest.userMessageId) }
+    : null;
+  if (threadId && !UUID.test(threadId) || documentIds.length === 0 || !documentIds.includes(String(input.documentId))) return null;
+  if ((input.threadRequest !== null && input.threadRequest !== undefined && !threadRequest) || (threadRequest && !threadId)) return null;
+  if (input.side !== "pro" && input.side !== "con") return null;
+  return {
+    documentEpoch,
+    documentId: String(input.documentId),
+    documentIds,
+    documentText: String(input.documentText ?? "").slice(0, 24000),
+    documentTitle: String(input.documentTitle ?? "").slice(0, 300),
+    motion: String(input.motion ?? "").slice(0, 1200),
+    requestId: String(input.requestId),
+    side: input.side,
+    sourceIds,
+    threadRequest,
+    threadId,
+    workspaceId: String(input.workspaceId),
+  };
+}
+
+export async function loadAuthorizedWorkspaceContext(database: RpcDatabase, userId: string, raw: unknown) {
+  const input = parseWorkspaceContext(raw);
+  if (!input) throw new Error("Invalid workspace context");
+  const client = database;
+  const [workspace, membership, document, sources, messages, durable] = await Promise.all([
+    client.from("workspaces").select("id,motion,status").eq("id", input.workspaceId).single() as Query,
+    client.from("workspace_members").select("user_id").eq("workspace_id", input.workspaceId).eq("user_id", userId).maybeSingle() as Query,
+    client.from("workspace_documents").select("document_epoch,id,side,title").eq("workspace_id", input.workspaceId).eq("id", input.documentId).single() as Query,
+    input.sourceIds.length
+      ? client.from("workspace_sources").select("content,id,title,provenance").eq("workspace_id", input.workspaceId).in("id", input.sourceIds) as Query
+      : Promise.resolve({ data: [], error: null }),
+    input.threadId
+      ? client.from("workspace_thread_messages").select("content,role,status").eq("workspace_id", input.workspaceId).eq("thread_id", input.threadId).eq("status", "complete").order("created_at", { ascending: false }).limit(12) as Query
+      : Promise.resolve({ data: [], error: null }),
+    database.rpc("get_workspace_ai_context", {
+      p_document_ids: input.documentIds,
+      p_source_ids: input.sourceIds,
+      p_thread_id: input.threadId,
+      p_user_id: userId,
+      p_workspace_id: input.workspaceId,
+    }),
+  ]);
+  if (workspace.error || membership.error || document.error || sources.error || messages.error || durable.error) throw new Error("Workspace unavailable");
+  const workspaceRow = record(workspace.data);
+  const memberRow = record(membership.data);
+  const documentRow = record(document.data);
+  const sourceRows = Array.isArray(sources.data) ? sources.data.map(record).filter(Boolean) as Record<string, unknown>[] : [];
+  const messageRows = Array.isArray(messages.data) ? messages.data.map(record).filter(Boolean) as Record<string, unknown>[] : [];
+  const durableContext = record(durable.data);
+  const durableDocuments = Array.isArray(durableContext?.documents)
+    ? durableContext.documents.map(record).filter(Boolean) as Record<string, unknown>[]
+    : [];
+  if (!workspaceRow || workspaceRow.status !== "active" || !memberRow || !documentRow || documentRow.side !== input.side || Number(documentRow.document_epoch) !== input.documentEpoch) {
+    throw new Error("Workspace unavailable");
+  }
+  if (sourceRows.length !== input.sourceIds.length) throw new Error("Workspace unavailable");
+  if (input.threadId && messageRows.length === 0) {
+    const thread = await client.from("workspace_threads").select("id").eq("workspace_id", input.workspaceId).eq("id", input.threadId).maybeSingle();
+    if (thread.error || !thread.data) throw new Error("Workspace unavailable");
+  }
+  if (durableDocuments.length !== input.documentIds.length) throw new Error("Workspace unavailable");
+  const sourceText = sourceRows.map((source) => `SOURCE: ${String(source.title)}\n${String(source.content).slice(0, 8000)}`).join("\n\n");
+  const threadText = messageRows.reverse().map((message) => `${String(message.role).toUpperCase()}: ${String(message.content).slice(0, 4000)}`).join("\n");
+  const documentText = durableDocuments.map((item) => [
+    `${String(item.side).toUpperCase()} DOCUMENT: ${String(item.title)}`,
+    String(item.text ?? "").slice(0, 24000),
+  ].join("\n")).join("\n\n");
+  return {
+    context: [
+      `WORKSPACE MOTION: ${String(workspaceRow.motion).slice(0, 1200)}`,
+      `SELECTED ${input.side.toUpperCase()} DOCUMENT: ${String(documentRow.title ?? input.documentTitle)}`,
+      documentText ? `DURABLE DOCUMENT CONTENT:\n${documentText}` : "",
+      sourceText,
+      threadText ? `SHARED THREAD:\n${threadText}` : "",
+    ].filter(Boolean).join("\n\n").slice(0, 50000),
+    input,
+    meta: {
+      includedDocuments: durableDocuments.length,
+      includedSources: sourceRows.length,
+      includedThreadMessages: messageRows.length,
+      omittedSources: Math.max(0, input.sourceIds.length - sourceRows.length),
+    },
+  };
+}
+
+export async function isWorkspaceMember(database: Database, userId: string, workspaceId: string) {
+  const client = database;
+  const [workspace, member] = await Promise.all([
+    client.from("workspaces").select("status").eq("id", workspaceId).single(),
+    client.from("workspace_members").select("user_id").eq("workspace_id", workspaceId).eq("user_id", userId).maybeSingle(),
+  ]);
+  return !workspace.error && !member.error && record(workspace.data)?.status === "active" && Boolean(member.data);
+}
diff --git a/supabase/functions/ai/index.ts b/supabase/functions/ai/index.ts
index 7090c0113..f44c485fd 100644
--- a/supabase/functions/ai/index.ts
+++ b/supabase/functions/ai/index.ts
@@ -138,10 +138,12 @@ import {
   MAX_CROSSFIRE_REPLY_CHARS,
   validateCrossfireDebrief,
 } from "../_shared/crossfire-response.ts";
+import { isWorkspaceMember, loadAuthorizedWorkspaceContext } from "../_shared/workspace-context.ts";
 
 const supabaseUrl = Deno.env.get("SUPABASE_URL")!;
 const supabaseServiceKey = Deno.env.get("SUPABASE_SERVICE_ROLE_KEY")!;
 const supabase = createClient(supabaseUrl, supabaseServiceKey);
+const workspaceDatabase = supabase as unknown as Parameters<typeof loadAuthorizedWorkspaceContext>[0];
 const sparringSupabase = createClient<SparringDatabaseSchema>(supabaseUrl, supabaseServiceKey);
 const sparringIntegritySecret = Deno.env.get("SPARRING_INTEGRITY_SECRET")?.trim()
   || await deriveSparringIntegritySecret(supabaseServiceKey);
@@ -1198,10 +1200,36 @@ export async function handleRequest(req: Request): Promise<Response> {
     validatedSparringRequest = sparringResult.request;
   }
   let sourceAssessments: SourceAssessment[] = [];
-  const successBody = (payload: Record<string, unknown>) => {
+  let workspaceAccess: {
+    meta: Record<string, unknown>;
+    requestId: string;
+    threadId: string | null;
+    threadRequest: { assistantMessageId: string; userMessageId: string } | null;
+    workspaceId: string;
+  } | null = null;
+  let workspaceThreadSettled = false;
+  const successBody = async (payload: Record<string, unknown>) => {
+    if (workspaceAccess && !await isWorkspaceMember(workspaceDatabase, userId, workspaceAccess.workspaceId)) {
+      throw new Error("Workspace access revoked");
+    }
+    if (workspaceAccess?.threadId && workspaceAccess.threadRequest && !workspaceThreadSettled) {
+      const output = payload.output && typeof payload.output === "object" ? payload.output as Record<string, unknown> : null;
+      if (typeof output?.response !== "string") throw new Error("Workspace thread response unavailable");
+      const settled = await supabase.rpc("complete_workspace_thread_generation", {
+        p_content: output.response,
+        p_request_id: workspaceAccess.requestId,
+        p_status: "complete",
+        p_thread_id: workspaceAccess.threadId,
+        p_user_id: userId,
+        p_workspace_id: workspaceAccess.workspaceId,
+      });
+      if (settled.error) throw new Error("Workspace thread response unavailable");
+      workspaceThreadSettled = true;
+    }
     const meta = {
       ...(responseTruncated ? { truncated: true } : {}),
       ...(resolvedModelMeta ? { requestedModel, resolvedModel: resolvedModelMeta } : {}),
+      ...(workspaceAccess ? { workspaceContext: workspaceAccess.meta } : {}),
     };
     const enriched = sourceAssessments.length > 0 ? { ...payload, sourceAssessments } : payload;
     return Object.keys(meta).length > 0 ? { ...enriched, meta } : enriched;
@@ -1231,7 +1259,6 @@ export async function handleRequest(req: Request): Promise<Response> {
 
   const userId: string = user.id;
   log(requestId, "INFO", "User authenticated", { userId });
-
   if (crossfireInput?.operation === "signal") {
     if (await checkUserBanned(userId)) return badRequest("Your account has been suspended. Please contact support.", corsHeaders, 403);
     if (!(await verifyCrossfireSignalToken(userId, crossfireInput))) return badRequest("Invalid or expired Crossfire signal token", corsHeaders, 403);
@@ -1251,11 +1278,73 @@ export async function handleRequest(req: Request): Promise<Response> {
     });
     const signalUsage = evaluated.jev?.usage ?? evaluated.jevUsage;
     if (signalUsage) await logUsage(userId, "jev_crossfire_signal", provider, JEV_MODEL, signalUsage, undefined, evaluated.jevUsage ? "error" : "success", evaluated.jevUsage ? "jev_incomplete" : undefined);
-    return new Response(JSON.stringify(successBody({ output: evaluated.signal ? { signal: evaluated.signal } : {} })), {
+    return new Response(JSON.stringify(await successBody({ output: evaluated.signal ? { signal: evaluated.signal } : {} })), {
       headers: { ...corsHeaders, "Content-Type": "application/json" },
     });
   }
 
+  if (body.workspaceContext !== undefined) {
+    try {
+      const loaded = await loadAuthorizedWorkspaceContext(workspaceDatabase, userId, body.workspaceContext);
+      workspaceAccess = {
+        meta: loaded.meta,
+        requestId: loaded.input.requestId,
+        threadId: loaded.input.threadId,
+        threadRequest: loaded.input.threadRequest,
+        workspaceId: loaded.input.workspaceId,
+      };
+      sources = boundPromptSources([{
+        title: "Authorized workspace context",
+        content: loaded.context,
+        type: "workspace",
+      }]);
+      if (loaded.input.threadRequest) {
+        const threadMessage = sanitizedInput && typeof sanitizedInput === "object"
+          ? (sanitizedInput as Record<string, unknown>).message
+          : null;
+        if (feature !== "ask" || !loaded.input.threadId || typeof threadMessage !== "string") {
+          return badRequest("Workspace unavailable", corsHeaders, 403);
+        }
+      }
+    } catch {
+      return badRequest("Workspace unavailable", corsHeaders, 403);
+    }
+  }
+  const interruptWorkspaceThread = async () => {
+    if (!workspaceAccess?.threadId || !workspaceAccess.threadRequest || workspaceThreadSettled) return;
+    await supabase.rpc("complete_workspace_thread_generation", {
+      p_content: "Generation interrupted",
+      p_request_id: workspaceAccess.requestId,
+      p_status: "interrupted",
+      p_thread_id: workspaceAccess.threadId,
+      p_user_id: userId,
+      p_workspace_id: workspaceAccess.workspaceId,
+    });
+    workspaceThreadSettled = true;
+  };
+  if (workspaceAccess?.threadRequest && workspaceAccess.threadId) {
+    const threadMessage = (sanitizedInput as Record<string, unknown>).message;
+    const started = await supabase.rpc("start_workspace_thread_generation", {
+      p_assistant_message_id: workspaceAccess.threadRequest.assistantMessageId,
+      p_content: threadMessage,
+      p_request_id: workspaceAccess.requestId,
+      p_thread_id: workspaceAccess.threadId,
+      p_user_id: userId,
+      p_user_message_id: workspaceAccess.threadRequest.userMessageId,
+      p_workspace_id: workspaceAccess.workspaceId,
+    });
+    const claim = started.data && typeof started.data === "object" ? started.data as Record<string, unknown> : null;
+    if (started.error || !claim) return badRequest("Workspace thread unavailable", corsHeaders, 409);
+    if (claim.claimed !== true) {
+      workspaceThreadSettled = true;
+      if (claim.status === "complete" && typeof claim.content === "string") {
+        return new Response(JSON.stringify(await successBody({
+          output: { response: claim.content, followUpQuestions: [], uncertainties: [] },
+        })), { headers: { ...corsHeaders, "Content-Type": "application/json" } });
+      }
+      return badRequest("Workspace thread generation is already in progress", corsHeaders, 409);
+    }
+  }
   const sparringDatabase = narrowSparringDatabase(sparringSupabase);
   let sparringScoreClaimed = false;
   let sparringScoreClaimToken: string | undefined;
@@ -1284,7 +1373,7 @@ export async function handleRequest(req: Request): Promise<Response> {
       });
     }
     if (claim.status === "complete") {
-      return new Response(JSON.stringify(successBody({
+      return new Response(JSON.stringify(await successBody({
         output: { action: "score", scorecard: claim.scorecard },
         sessionId: validatedSparringRequest.sessionId,
       })), { headers: { ...corsHeaders, "Content-Type": "application/json" } });
@@ -1316,6 +1405,7 @@ export async function handleRequest(req: Request): Promise<Response> {
   try {
     rateLimit = await checkRateLimit(userId, requestedModel);
   } catch (error) {
+    await interruptWorkspaceThread();
     if (sparringScoreClaimed && sparringScoreClaimToken && validatedSparringRequest) {
       await releaseSparringScoreClaim(sparringDatabase, validatedSparringRequest.sessionId, userId, sparringScoreClaimToken);
     }
@@ -1327,6 +1417,7 @@ export async function handleRequest(req: Request): Promise<Response> {
     });
   }
   if (!rateLimit.allowed) {
+    await interruptWorkspaceThread();
     if (sparringScoreClaimed && sparringScoreClaimToken && validatedSparringRequest) {
       await releaseSparringScoreClaim(sparringDatabase, validatedSparringRequest.sessionId, userId, sparringScoreClaimToken);
       sparringScoreClaimed = false;
@@ -1362,6 +1453,7 @@ export async function handleRequest(req: Request): Promise<Response> {
       await logUsage(userId, "jev_model_router", provider, JEV_MODEL, routingUsage, Date.now() - routingStartedAt, resolution.jevUsage ? "error" : "success", resolution.jevUsage ? "jev_incomplete" : undefined);
     }
   } catch (error) {
+    await interruptWorkspaceThread();
     if (sparringScoreClaimed && sparringScoreClaimToken && validatedSparringRequest) {
       await releaseSparringScoreClaim(sparringDatabase, validatedSparringRequest.sessionId, userId, sparringScoreClaimToken);
       sparringScoreClaimed = false;
@@ -1396,16 +1488,21 @@ export async function handleRequest(req: Request): Promise<Response> {
     })
     : [];
   if (feature !== "sparring" && feature !== "crossfire" && sourceDecisionCandidates.length > 0) {
-    const ranked = await rankSourcesForRequest({
-      feature,
-      requestText: JSON.stringify(sanitizedInput),
-      sources: sourceDecisionCandidates,
-      signal: req.signal,
-    });
-    sourceAssessments = ranked.assessments;
-    sources = ranked.sources.map(({ title, content, origin, type }) => ({ title, content, ...(origin ? { origin } : {}), type }));
-    const rankingUsage = ranked.jev?.usage ?? ranked.jevUsage;
-    if (rankingUsage) await logUsage(userId, "jev_source_ranking", provider, JEV_MODEL, rankingUsage, undefined, ranked.jevUsage ? "error" : "success", ranked.jevUsage ? "jev_incomplete" : undefined);
+    try {
+      const ranked = await rankSourcesForRequest({
+        feature,
+        requestText: JSON.stringify(sanitizedInput),
+        sources: sourceDecisionCandidates,
+        signal: req.signal,
+      });
+      sourceAssessments = ranked.assessments;
+      sources = ranked.sources.map(({ title, content, origin, type }) => ({ title, content, ...(origin ? { origin } : {}), type }));
+      const rankingUsage = ranked.jev?.usage ?? ranked.jevUsage;
+      if (rankingUsage) await logUsage(userId, "jev_source_ranking", provider, JEV_MODEL, rankingUsage, undefined, ranked.jevUsage ? "error" : "success", ranked.jevUsage ? "jev_incomplete" : undefined);
+    } catch {
+      await interruptWorkspaceThread();
+      return badRequest("Unable to rank sources", corsHeaders, 500);
+    }
   }
 
   const reasoningEffort = effectiveReasoningEffort(model, requestedReasoningEffort ?? undefined, Boolean(rateLimit.canAccessProModels));
@@ -1472,7 +1569,7 @@ export async function handleRequest(req: Request): Promise<Response> {
       customPrompt: feature === "sparring" ? null : customSystemPrompt ?? null,
       // Sparring is transcript-only. Do not let unrelated saved evidence alter
       // an opponent response or a judge's scorecard.
-      sources: feature === "sparring" ? [] : promptSources,
+      sources: feature === "sparring" && !workspaceAccess ? [] : promptSources,
       researchContext: hasResearch(research)
         ? "WEB RESEARCH RESULTS are attached to this request."
         : undefined,
@@ -1525,7 +1622,7 @@ export async function handleRequest(req: Request): Promise<Response> {
 
       const latencyMs = Date.now() - startTime;
       await logUsage(userId, feature, provider, model, mergeNormalizedUsage([aiResult.usage, ...researchUsageForLog()]), latencyMs);
-      return new Response(JSON.stringify(successBody({
+      return new Response(JSON.stringify(await successBody({
         output: responseOutput,
         sessionId: sparringRequest.sessionId,
       })), { headers: { ...corsHeaders, "Content-Type": "application/json" } });
@@ -1542,7 +1639,9 @@ export async function handleRequest(req: Request): Promise<Response> {
       const systemPrompt = buildSystemPrompt({
         feature: "crossfire",
         dateContext: getCurrentDateContext(),
-        sources: crossfireSources,
+        sources: workspaceAccess
+          ? sources.map((source) => ({ ...source, content: source.content.slice(0, 8_000) }))
+          : crossfireSources,
       });
       if (systemPrompt.length + userPrompt.length > MAX_CROSSFIRE_PROMPT_CHARS) {
         throw new Error(`Crossfire prompt exceeds ${MAX_CROSSFIRE_PROMPT_CHARS} characters`);
@@ -1574,7 +1673,7 @@ export async function handleRequest(req: Request): Promise<Response> {
 
       const latencyMs = Date.now() - startTime;
       await logUsage(userId, feature, provider, model, aiResult.usage, latencyMs);
-      return new Response(JSON.stringify(successBody({ output: output.value, ...(signalToken ? { signalToken } : {}) })), { headers: { ...corsHeaders, "Content-Type": "application/json" } });
+      return new Response(JSON.stringify(await successBody({ output: output.value, ...(signalToken ? { signalToken } : {}) })), { headers: { ...corsHeaders, "Content-Type": "application/json" } });
     }
 
     // FACTOIDS: Use deep research with multiple searches
@@ -1630,7 +1729,7 @@ export async function handleRequest(req: Request): Promise<Response> {
 
       // Log usage and return
       await logUsage(userId, feature, provider, model, mergeNormalizedUsage([aiResult.usage, ...researchUsageForLog()]), latencyMs);
-      return new Response(JSON.stringify(successBody({ output, discoveredSources })), { headers: { ...corsHeaders, "Content-Type": "application/json" } });
+      return new Response(JSON.stringify(await successBody({ output, discoveredSources })), { headers: { ...corsHeaders, "Content-Type": "application/json" } });
     }
 
     // ASK: Optionally run web search and include URL context from chat
@@ -1767,7 +1866,7 @@ export async function handleRequest(req: Request): Promise<Response> {
       // Log usage and return
       const latencyMs = Date.now() - startTime;
       await logUsage(userId, feature, provider, model, mergeNormalizedUsage([aiResult.usage, ...researchUsageForLog()]), latencyMs);
-      return new Response(JSON.stringify(successBody({ output })), { headers: { ...corsHeaders, "Content-Type": "application/json" } });
+      return new Response(JSON.stringify(await successBody({ output })), { headers: { ...corsHeaders, "Content-Type": "application/json" } });
     }
 
     // GENERATE: Use deep research for evidence-backed arguments
@@ -1903,7 +2002,7 @@ export async function handleRequest(req: Request): Promise<Response> {
         metadata.durationMs = latencyMs;
       }
       await logUsage(userId, feature, provider, model, mergeNormalizedUsage([aiResult.usage, ...researchUsageForLog()]), latencyMs);
-      return new Response(JSON.stringify(successBody({ output, discoveredSources: rankedDiscoveredSources, sourceAssessments })), { headers: { ...corsHeaders, "Content-Type": "application/json" } });
+      return new Response(JSON.stringify(await successBody({ output, discoveredSources: rankedDiscoveredSources, sourceAssessments })), { headers: { ...corsHeaders, "Content-Type": "application/json" } });
     }
 
     // BRAINSTORM: Use research to inform argument angles
@@ -1932,7 +2031,7 @@ export async function handleRequest(req: Request): Promise<Response> {
       // Log usage and return with sources
       const latencyMs = Date.now() - startTime;
       await logUsage(userId, feature, provider, model, mergeNormalizedUsage([aiResult.usage, ...researchUsageForLog()]), latencyMs);
-      return new Response(JSON.stringify(successBody({ output, discoveredSources })), { headers: { ...corsHeaders, "Content-Type": "application/json" } });
+      return new Response(JSON.stringify(await successBody({ output, discoveredSources })), { headers: { ...corsHeaders, "Content-Type": "application/json" } });
     }
 
     // ATTACK: Use deep research for evidence-based critique
@@ -1958,7 +2057,7 @@ export async function handleRequest(req: Request): Promise<Response> {
 
       const latencyMs = Date.now() - startTime;
       await logUsage(userId, feature, provider, model, mergeNormalizedUsage([aiResult.usage, ...researchUsageForLog()]), latencyMs);
-      return new Response(JSON.stringify(successBody({ output, discoveredSources })), { headers: { ...corsHeaders, "Content-Type": "application/json" } });
+      return new Response(JSON.stringify(await successBody({ output, discoveredSources })), { headers: { ...corsHeaders, "Content-Type": "application/json" } });
     }
 
     // Fallback for any other feature
@@ -1970,11 +2069,23 @@ export async function handleRequest(req: Request): Promise<Response> {
 
     const latencyMs = Date.now() - startTime;
     await logUsage(userId, feature, provider, model, mergeNormalizedUsage([fallbackResult.usage, ...researchUsageForLog()]), latencyMs);
-    return new Response(JSON.stringify(successBody({ output })), { headers: { ...corsHeaders, "Content-Type": "application/json" } });
+    return new Response(JSON.stringify(await successBody({ output })), { headers: { ...corsHeaders, "Content-Type": "application/json" } });
   } catch (err) {
     const message = err instanceof Error ? err.message : "Unknown error";
     console.error("[ERROR]", message);
 
+    if (workspaceAccess?.threadId && workspaceAccess.threadRequest && !workspaceThreadSettled) {
+      await supabase.rpc("complete_workspace_thread_generation", {
+        p_content: "Generation interrupted",
+        p_request_id: workspaceAccess.requestId,
+        p_status: "interrupted",
+        p_thread_id: workspaceAccess.threadId,
+        p_user_id: userId,
+        p_workspace_id: workspaceAccess.workspaceId,
+      });
+      workspaceThreadSettled = true;
+    }
+
     if (sparringScoreClaimed && sparringScoreClaimToken && validatedSparringRequest) {
       await releaseSparringScoreClaim(sparringDatabase, validatedSparringRequest.sessionId, userId, sparringScoreClaimToken);
       sparringScoreClaimed = false;
diff --git a/supabase/migrations/20260921161000_workspace_evidence_practice.sql b/supabase/migrations/20260921161000_workspace_evidence_practice.sql
new file mode 100644
index 000000000..49d6b8394
--- /dev/null
+++ b/supabase/migrations/20260921161000_workspace_evidence_practice.sql
@@ -0,0 +1,479 @@
+ALTER TABLE private.workspace_document_state
+  ADD COLUMN text_projection text NOT NULL DEFAULT '' CHECK (length(text_projection) <= 100000);
+ALTER TABLE private.workspace_version_data
+  ADD COLUMN text_projection text NOT NULL DEFAULT '' CHECK (length(text_projection) <= 100000);
+
+CREATE FUNCTION private.capture_workspace_version_text()
+RETURNS trigger
+LANGUAGE plpgsql
+SECURITY DEFINER
+SET search_path = ''
+AS $$
+BEGIN
+  SELECT state.text_projection INTO NEW.text_projection
+  FROM public.workspace_versions AS version
+  JOIN private.workspace_document_state AS state ON state.document_id = version.document_id
+  WHERE version.id = NEW.version_id;
+  RETURN NEW;
+END;
+$$;
+CREATE TRIGGER workspace_version_data_capture_text_before_insert
+  BEFORE INSERT ON private.workspace_version_data
+  FOR EACH ROW EXECUTE FUNCTION private.capture_workspace_version_text();
+
+CREATE FUNCTION private.restore_workspace_state_text()
+RETURNS trigger
+LANGUAGE plpgsql
+SECURITY DEFINER
+SET search_path = ''
+AS $$
+BEGIN
+  IF NEW.snapshot IS DISTINCT FROM OLD.snapshot AND NEW.text_projection IS NOT DISTINCT FROM OLD.text_projection THEN
+    SELECT data.text_projection INTO NEW.text_projection
+    FROM private.workspace_version_data AS data
+    JOIN public.workspace_versions AS version ON version.id = data.version_id
+    WHERE version.document_id = NEW.document_id AND data.snapshot = NEW.snapshot
+    ORDER BY version.created_at DESC LIMIT 1;
+    NEW.text_projection := coalesce(NEW.text_projection, '');
+  END IF;
+  RETURN NEW;
+END;
+$$;
+CREATE TRIGGER workspace_document_state_restore_text_before_update
+  BEFORE UPDATE OF snapshot ON private.workspace_document_state
+  FOR EACH ROW EXECUTE FUNCTION private.restore_workspace_state_text();
+
+CREATE TABLE public.workspace_sources (
+  id uuid PRIMARY KEY,
+  workspace_id uuid NOT NULL REFERENCES public.workspaces(id) ON DELETE CASCADE,
+  created_by uuid NOT NULL REFERENCES auth.users(id) ON DELETE RESTRICT,
+  title text NOT NULL CHECK (length(btrim(title)) BETWEEN 1 AND 300),
+  content text NOT NULL CHECK (length(content) BETWEEN 1 AND 100000),
+  source_type text NOT NULL CHECK (source_type IN ('url', 'file', 'text')),
+  provenance jsonb NOT NULL DEFAULT '{}'::jsonb,
+  citation_snapshot jsonb NOT NULL DEFAULT '{}'::jsonb,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now(),
+  UNIQUE (workspace_id, id)
+);
+
+CREATE TABLE public.workspace_threads (
+  id uuid PRIMARY KEY,
+  workspace_id uuid NOT NULL REFERENCES public.workspaces(id) ON DELETE CASCADE,
+  created_by uuid NOT NULL REFERENCES auth.users(id) ON DELETE RESTRICT,
+  name text NOT NULL CHECK (length(btrim(name)) BETWEEN 1 AND 200),
+  active_request_id uuid,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now(),
+  UNIQUE (workspace_id, id)
+);
+
+CREATE TABLE public.workspace_thread_messages (
+  id uuid PRIMARY KEY,
+  workspace_id uuid NOT NULL REFERENCES public.workspaces(id) ON DELETE CASCADE,
+  thread_id uuid NOT NULL,
+  author_id uuid NOT NULL REFERENCES auth.users(id) ON DELETE RESTRICT,
+  request_id uuid NOT NULL,
+  role text NOT NULL CHECK (role IN ('user', 'assistant')),
+  content text NOT NULL CHECK (length(content) BETWEEN 1 AND 50000),
+  status text NOT NULL CHECK (status IN ('progress', 'interrupted', 'complete')),
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now(),
+  FOREIGN KEY (workspace_id, thread_id) REFERENCES public.workspace_threads(workspace_id, id) ON DELETE CASCADE,
+  UNIQUE (thread_id, request_id, role)
+);
+
+CREATE TABLE public.workspace_artifacts (
+  id uuid PRIMARY KEY,
+  workspace_id uuid NOT NULL REFERENCES public.workspaces(id) ON DELETE CASCADE,
+  document_id uuid,
+  document_epoch bigint CHECK (document_epoch IS NULL OR document_epoch >= 0),
+  created_by uuid NOT NULL REFERENCES auth.users(id) ON DELETE RESTRICT,
+  request_id uuid NOT NULL,
+  tool text NOT NULL CHECK (tool IN ('generate', 'factoids', 'brainstorm', 'attack', 'ask', 'flowchart', 'crossfire', 'sparring')),
+  status text NOT NULL CHECK (status IN ('progress', 'interrupted', 'complete')),
+  input_snapshot jsonb NOT NULL DEFAULT '{}'::jsonb,
+  output_snapshot jsonb,
+  progress jsonb NOT NULL DEFAULT '{}'::jsonb,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now(),
+  FOREIGN KEY (workspace_id, document_id) REFERENCES public.workspace_documents(workspace_id, id) ON DELETE CASCADE,
+  UNIQUE (created_by, request_id)
+);
+
+CREATE INDEX workspace_sources_workspace_created_idx ON public.workspace_sources(workspace_id, created_at DESC);
+CREATE INDEX workspace_threads_workspace_updated_idx ON public.workspace_threads(workspace_id, updated_at DESC);
+CREATE INDEX workspace_thread_messages_thread_created_idx ON public.workspace_thread_messages(thread_id, created_at);
+CREATE INDEX workspace_artifacts_workspace_updated_idx ON public.workspace_artifacts(workspace_id, updated_at DESC);
+
+ALTER TABLE public.workspace_sources ENABLE ROW LEVEL SECURITY;
+ALTER TABLE public.workspace_threads ENABLE ROW LEVEL SECURITY;
+ALTER TABLE public.workspace_thread_messages ENABLE ROW LEVEL SECURITY;
+ALTER TABLE public.workspace_artifacts ENABLE ROW LEVEL SECURITY;
+
+CREATE POLICY workspace_sources_select_member ON public.workspace_sources
+  FOR SELECT TO authenticated USING ((SELECT private.is_current_workspace_member(workspace_id)));
+CREATE POLICY workspace_threads_select_member ON public.workspace_threads
+  FOR SELECT TO authenticated USING ((SELECT private.is_current_workspace_member(workspace_id)));
+CREATE POLICY workspace_thread_messages_select_member ON public.workspace_thread_messages
+  FOR SELECT TO authenticated USING ((SELECT private.is_current_workspace_member(workspace_id)));
+CREATE POLICY workspace_artifacts_select_member ON public.workspace_artifacts
+  FOR SELECT TO authenticated USING ((SELECT private.is_current_workspace_member(workspace_id)));
+
+REVOKE ALL ON TABLE public.workspace_sources, public.workspace_threads,
+  public.workspace_thread_messages, public.workspace_artifacts FROM PUBLIC, anon, authenticated;
+GRANT SELECT ON TABLE public.workspace_sources, public.workspace_threads,
+  public.workspace_thread_messages, public.workspace_artifacts TO authenticated;
+
+CREATE FUNCTION private.require_active_workspace_member(p_workspace_id uuid)
+RETURNS public.workspaces
+LANGUAGE plpgsql
+SECURITY DEFINER
+SET search_path = ''
+AS $$
+DECLARE v_workspace public.workspaces%ROWTYPE;
+BEGIN
+  SELECT * INTO v_workspace FROM public.workspaces WHERE id = p_workspace_id FOR UPDATE;
+  IF NOT FOUND OR v_workspace.status <> 'active' OR NOT EXISTS (
+    SELECT 1 FROM public.workspace_members
+    WHERE workspace_id = p_workspace_id AND user_id = auth.uid()
+  ) THEN RAISE EXCEPTION 'workspace unavailable'; END IF;
+  RETURN v_workspace;
+END;
+$$;
+REVOKE ALL ON FUNCTION private.require_active_workspace_member(uuid) FROM PUBLIC, anon, authenticated;
+
+CREATE FUNCTION public.save_workspace_source(
+  p_workspace_id uuid, p_source_id uuid, p_title text, p_content text,
+  p_source_type text, p_provenance jsonb, p_citation_snapshot jsonb
+)
+RETURNS uuid
+LANGUAGE plpgsql
+SECURITY DEFINER
+SET search_path = ''
+AS $$
+DECLARE v_existing public.workspace_sources%ROWTYPE;
+BEGIN
+  IF auth.uid() IS NULL OR p_source_id IS NULL OR p_provenance IS NULL OR p_citation_snapshot IS NULL
+    OR p_source_type NOT IN ('url', 'file', 'text')
+    OR length(btrim(p_title)) NOT BETWEEN 1 AND 300 OR length(p_content) NOT BETWEEN 1 AND 100000
+    OR octet_length(convert_to(p_provenance::text, 'UTF8')) > 32768
+    OR octet_length(convert_to(p_citation_snapshot::text, 'UTF8')) > 32768 THEN
+    RAISE EXCEPTION 'invalid source';
+  END IF;
+  PERFORM private.require_active_workspace_member(p_workspace_id);
+  SELECT * INTO v_existing FROM public.workspace_sources WHERE id = p_source_id;
+  IF FOUND THEN
+    IF v_existing.workspace_id <> p_workspace_id OR v_existing.created_by <> auth.uid() THEN
+      RAISE EXCEPTION 'operation ID conflict';
+    END IF;
+    RETURN v_existing.id;
+  END IF;
+  INSERT INTO public.workspace_sources (
+    id, workspace_id, created_by, title, content, source_type, provenance, citation_snapshot
+  ) VALUES (
+    p_source_id, p_workspace_id, auth.uid(), btrim(p_title), p_content,
+    p_source_type, p_provenance, p_citation_snapshot
+  );
+  RETURN p_source_id;
+END;
+$$;
+
+CREATE FUNCTION public.create_workspace_thread(p_workspace_id uuid, p_thread_id uuid, p_name text)
+RETURNS uuid
+LANGUAGE plpgsql
+SECURITY DEFINER
+SET search_path = ''
+AS $$
+BEGIN
+  IF auth.uid() IS NULL OR p_thread_id IS NULL OR length(btrim(p_name)) NOT BETWEEN 1 AND 200 THEN
+    RAISE EXCEPTION 'invalid thread';
+  END IF;
+  PERFORM private.require_active_workspace_member(p_workspace_id);
+  INSERT INTO public.workspace_threads (id, workspace_id, created_by, name)
+  VALUES (p_thread_id, p_workspace_id, auth.uid(), btrim(p_name))
+  ON CONFLICT (id) DO NOTHING;
+  IF NOT EXISTS (
+    SELECT 1 FROM public.workspace_threads
+    WHERE id = p_thread_id AND workspace_id = p_workspace_id AND created_by = auth.uid()
+  ) THEN RAISE EXCEPTION 'operation ID conflict'; END IF;
+  RETURN p_thread_id;
+END;
+$$;
+
+CREATE FUNCTION public.save_workspace_thread_message(
+  p_workspace_id uuid, p_thread_id uuid, p_message_id uuid, p_request_id uuid,
+  p_role text, p_content text, p_status text
+)
+RETURNS uuid
+LANGUAGE plpgsql
+SECURITY DEFINER
+SET search_path = ''
+AS $$
+DECLARE
+  v_existing public.workspace_thread_messages%ROWTYPE;
+  v_active_request_id uuid;
+  v_thread_updated_at timestamptz;
+BEGIN
+  IF auth.uid() IS NULL OR p_message_id IS NULL OR p_request_id IS NULL
+    OR p_role <> 'user' OR p_status <> 'complete'
+    OR length(p_content) NOT BETWEEN 1 AND 50000 THEN RAISE EXCEPTION 'invalid message'; END IF;
+  PERFORM private.require_active_workspace_member(p_workspace_id);
+  SELECT active_request_id, updated_at INTO v_active_request_id, v_thread_updated_at FROM public.workspace_threads
+  WHERE id = p_thread_id AND workspace_id = p_workspace_id FOR UPDATE;
+  IF NOT FOUND THEN RAISE EXCEPTION 'workspace unavailable'; END IF;
+  IF v_active_request_id IS NOT NULL AND v_active_request_id <> p_request_id
+    AND v_thread_updated_at > now() - interval '5 minutes' THEN
+    RAISE EXCEPTION 'thread generation in progress';
+  END IF;
+  IF v_active_request_id IS NOT NULL AND v_active_request_id <> p_request_id THEN
+    UPDATE public.workspace_thread_messages SET status = 'interrupted', updated_at = now()
+    WHERE thread_id = p_thread_id AND request_id = v_active_request_id AND status = 'progress';
+  END IF;
+  UPDATE public.workspace_threads SET active_request_id = p_request_id, updated_at = now() WHERE id = p_thread_id;
+  SELECT * INTO v_existing FROM public.workspace_thread_messages
+  WHERE thread_id = p_thread_id AND request_id = p_request_id AND role = p_role;
+  IF FOUND THEN
+    UPDATE public.workspace_thread_messages SET content = p_content, status = p_status, updated_at = now()
+    WHERE id = v_existing.id AND author_id = auth.uid();
+    IF NOT FOUND THEN RAISE EXCEPTION 'workspace unavailable'; END IF;
+    RETURN v_existing.id;
+  END IF;
+  INSERT INTO public.workspace_thread_messages (
+    id, workspace_id, thread_id, author_id, request_id, role, content, status
+  ) VALUES (p_message_id, p_workspace_id, p_thread_id, auth.uid(), p_request_id, p_role, p_content, p_status);
+  RETURN p_message_id;
+END;
+$$;
+
+CREATE FUNCTION public.start_workspace_thread_generation(
+  p_user_id uuid, p_workspace_id uuid, p_thread_id uuid, p_user_message_id uuid,
+  p_assistant_message_id uuid, p_request_id uuid, p_content text
+)
+RETURNS jsonb
+LANGUAGE plpgsql
+SECURITY DEFINER
+SET search_path = ''
+AS $$
+DECLARE
+  v_active_request_id uuid;
+  v_assistant_message public.workspace_thread_messages%ROWTYPE;
+  v_thread_updated_at timestamptz;
+  v_user_message public.workspace_thread_messages%ROWTYPE;
+BEGIN
+  IF p_user_id IS NULL OR p_user_message_id IS NULL OR p_assistant_message_id IS NULL
+    OR p_request_id IS NULL OR length(p_content) NOT BETWEEN 1 AND 50000
+    OR NOT EXISTS (
+      SELECT 1 FROM public.workspaces AS workspace
+      JOIN public.workspace_members AS member ON member.workspace_id = workspace.id
+      WHERE workspace.id = p_workspace_id AND workspace.status = 'active' AND member.user_id = p_user_id
+    )
+  THEN RAISE EXCEPTION 'invalid message'; END IF;
+  SELECT active_request_id, updated_at INTO v_active_request_id, v_thread_updated_at
+  FROM public.workspace_threads
+  WHERE id = p_thread_id AND workspace_id = p_workspace_id FOR UPDATE;
+  IF NOT FOUND THEN RAISE EXCEPTION 'workspace unavailable'; END IF;
+  SELECT * INTO v_user_message FROM public.workspace_thread_messages
+  WHERE thread_id = p_thread_id AND request_id = p_request_id AND role = 'user';
+  SELECT * INTO v_assistant_message FROM public.workspace_thread_messages
+  WHERE thread_id = p_thread_id AND request_id = p_request_id AND role = 'assistant';
+  IF v_user_message.id IS NOT NULL OR v_assistant_message.id IS NOT NULL THEN
+    IF v_user_message.id IS DISTINCT FROM p_user_message_id
+      OR v_assistant_message.id IS DISTINCT FROM p_assistant_message_id
+      OR v_user_message.author_id IS DISTINCT FROM p_user_id
+      OR v_assistant_message.author_id IS DISTINCT FROM p_user_id
+      OR v_user_message.content IS DISTINCT FROM p_content
+    THEN RAISE EXCEPTION 'operation ID conflict'; END IF;
+    RETURN jsonb_build_object(
+      'assistantMessageId', v_assistant_message.id,
+      'claimed', false,
+      'content', v_assistant_message.content,
+      'status', v_assistant_message.status
+    );
+  END IF;
+  IF v_active_request_id IS NOT NULL AND v_active_request_id <> p_request_id
+    AND v_thread_updated_at > now() - interval '5 minutes'
+  THEN RAISE EXCEPTION 'thread generation in progress'; END IF;
+  IF v_active_request_id IS NOT NULL AND v_active_request_id <> p_request_id THEN
+    UPDATE public.workspace_thread_messages SET status = 'interrupted', updated_at = now()
+    WHERE thread_id = p_thread_id AND request_id = v_active_request_id AND status = 'progress';
+  END IF;
+  INSERT INTO public.workspace_thread_messages (
+    id, workspace_id, thread_id, author_id, request_id, role, content, status
+  ) VALUES (
+    p_user_message_id, p_workspace_id, p_thread_id, p_user_id, p_request_id, 'user', p_content, 'complete'
+  ) ON CONFLICT (thread_id, request_id, role) DO NOTHING;
+  IF NOT EXISTS (
+    SELECT 1 FROM public.workspace_thread_messages
+    WHERE thread_id = p_thread_id AND request_id = p_request_id
+      AND role = 'user' AND author_id = p_user_id AND content = p_content
+  ) THEN RAISE EXCEPTION 'operation ID conflict'; END IF;
+  INSERT INTO public.workspace_thread_messages (
+    id, workspace_id, thread_id, author_id, request_id, role, content, status
+  ) VALUES (
+    p_assistant_message_id, p_workspace_id, p_thread_id, p_user_id, p_request_id, 'assistant', 'Thinking…', 'progress'
+  ) ON CONFLICT (thread_id, request_id, role) DO NOTHING;
+  UPDATE public.workspace_threads SET active_request_id = p_request_id, updated_at = now() WHERE id = p_thread_id;
+  RETURN jsonb_build_object(
+    'assistantMessageId', p_assistant_message_id,
+    'claimed', true,
+    'content', 'Thinking…',
+    'status', 'progress'
+  );
+END;
+$$;
+
+CREATE FUNCTION public.complete_workspace_thread_generation(
+  p_user_id uuid, p_workspace_id uuid, p_thread_id uuid,
+  p_request_id uuid, p_content text, p_status text
+)
+RETURNS void
+LANGUAGE plpgsql
+SECURITY DEFINER
+SET search_path = ''
+AS $$
+BEGIN
+  IF p_user_id IS NULL OR p_request_id IS NULL OR p_status NOT IN ('complete', 'interrupted')
+    OR length(p_content) NOT BETWEEN 1 AND 50000
+    OR p_status = 'complete' AND NOT EXISTS (
+      SELECT 1 FROM public.workspaces AS workspace
+      JOIN public.workspace_members AS member ON member.workspace_id = workspace.id
+      WHERE workspace.id = p_workspace_id AND workspace.status = 'active' AND member.user_id = p_user_id
+    ) THEN RAISE EXCEPTION 'workspace unavailable'; END IF;
+  PERFORM 1 FROM public.workspace_threads
+  WHERE id = p_thread_id AND workspace_id = p_workspace_id AND active_request_id = p_request_id
+  FOR UPDATE;
+  IF NOT FOUND THEN RAISE EXCEPTION 'workspace unavailable'; END IF;
+  UPDATE public.workspace_thread_messages
+  SET content = p_content, status = p_status, updated_at = now()
+  WHERE workspace_id = p_workspace_id AND thread_id = p_thread_id
+    AND request_id = p_request_id AND role = 'assistant' AND author_id = p_user_id;
+  IF NOT FOUND THEN RAISE EXCEPTION 'workspace unavailable'; END IF;
+  UPDATE public.workspace_threads SET active_request_id = NULL, updated_at = now() WHERE id = p_thread_id;
+END;
+$$;
+
+CREATE FUNCTION public.save_workspace_artifact(
+  p_workspace_id uuid, p_artifact_id uuid, p_request_id uuid, p_document_id uuid,
+  p_document_epoch bigint, p_tool text, p_status text, p_input_snapshot jsonb,
+  p_output_snapshot jsonb, p_progress jsonb
+)
+RETURNS uuid
+LANGUAGE plpgsql
+SECURITY DEFINER
+SET search_path = ''
+AS $$
+DECLARE v_existing public.workspace_artifacts%ROWTYPE;
+BEGIN
+  IF auth.uid() IS NULL OR p_artifact_id IS NULL OR p_request_id IS NULL
+    OR p_tool NOT IN ('generate', 'factoids', 'brainstorm', 'attack', 'ask', 'flowchart', 'crossfire', 'sparring')
+    OR p_status NOT IN ('progress', 'interrupted', 'complete') OR p_input_snapshot IS NULL OR p_progress IS NULL
+    OR p_document_epoch IS NOT NULL AND p_document_epoch < 0
+    OR octet_length(convert_to(p_input_snapshot::text, 'UTF8')) > 262144
+    OR octet_length(convert_to(coalesce(p_output_snapshot, '{}'::jsonb)::text, 'UTF8')) > 1048576
+    OR octet_length(convert_to(p_progress::text, 'UTF8')) > 262144 THEN
+    RAISE EXCEPTION 'invalid artifact';
+  END IF;
+  PERFORM private.require_active_workspace_member(p_workspace_id);
+  IF p_document_id IS NOT NULL AND NOT EXISTS (
+    SELECT 1 FROM public.workspace_documents
+    WHERE id = p_document_id AND workspace_id = p_workspace_id AND document_epoch = p_document_epoch
+  ) THEN RAISE EXCEPTION 'workspace unavailable'; END IF;
+  SELECT * INTO v_existing FROM public.workspace_artifacts
+  WHERE created_by = auth.uid() AND request_id = p_request_id FOR UPDATE;
+  IF FOUND THEN
+    IF v_existing.workspace_id <> p_workspace_id OR v_existing.tool <> p_tool
+      OR v_existing.document_id IS DISTINCT FROM p_document_id
+      OR v_existing.document_epoch IS DISTINCT FROM p_document_epoch THEN
+      RAISE EXCEPTION 'operation ID conflict';
+    END IF;
+    UPDATE public.workspace_artifacts
+    SET status = p_status, output_snapshot = p_output_snapshot, progress = p_progress, updated_at = now()
+    WHERE id = v_existing.id;
+    RETURN v_existing.id;
+  END IF;
+  INSERT INTO public.workspace_artifacts (
+    id, workspace_id, document_id, document_epoch, created_by, request_id,
+    tool, status, input_snapshot, output_snapshot, progress
+  ) VALUES (
+    p_artifact_id, p_workspace_id, p_document_id, p_document_epoch, auth.uid(), p_request_id,
+    p_tool, p_status, p_input_snapshot, p_output_snapshot, p_progress
+  );
+  RETURN p_artifact_id;
+END;
+$$;
+
+REVOKE ALL ON FUNCTION public.save_workspace_source(uuid, uuid, text, text, text, jsonb, jsonb),
+  public.create_workspace_thread(uuid, uuid, text),
+  public.save_workspace_thread_message(uuid, uuid, uuid, uuid, text, text, text),
+  public.start_workspace_thread_generation(uuid, uuid, uuid, uuid, uuid, uuid, text),
+  public.complete_workspace_thread_generation(uuid, uuid, uuid, uuid, text, text),
+  public.save_workspace_artifact(uuid, uuid, uuid, uuid, bigint, text, text, jsonb, jsonb, jsonb)
+FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.save_workspace_source(uuid, uuid, text, text, text, jsonb, jsonb),
+  public.create_workspace_thread(uuid, uuid, text),
+  public.save_workspace_thread_message(uuid, uuid, uuid, uuid, text, text, text),
+  public.save_workspace_artifact(uuid, uuid, uuid, uuid, bigint, text, text, jsonb, jsonb, jsonb)
+TO authenticated;
+GRANT EXECUTE ON FUNCTION public.start_workspace_thread_generation(uuid, uuid, uuid, uuid, uuid, uuid, text),
+  public.complete_workspace_thread_generation(uuid, uuid, uuid, uuid, text, text)
+TO service_role;
+
+CREATE FUNCTION public.get_workspace_ai_context(
+  p_user_id uuid,
+  p_workspace_id uuid,
+  p_document_ids uuid[],
+  p_source_ids uuid[],
+  p_thread_id uuid
+)
+RETURNS jsonb
+LANGUAGE plpgsql
+SECURITY DEFINER
+SET search_path = ''
+AS $$
+DECLARE
+  v_document_count integer;
+  v_source_count integer;
+BEGIN
+  IF p_user_id IS NULL OR p_workspace_id IS NULL
+    OR coalesce(array_length(p_document_ids, 1), 0) NOT BETWEEN 1 AND 12
+    OR coalesce(array_length(p_source_ids, 1), 0) > 20
+    OR NOT EXISTS (
+      SELECT 1 FROM public.workspaces AS workspace
+      JOIN public.workspace_members AS member ON member.workspace_id = workspace.id
+      WHERE workspace.id = p_workspace_id AND workspace.status = 'active' AND member.user_id = p_user_id
+    ) THEN RAISE EXCEPTION 'workspace unavailable'; END IF;
+
+  SELECT count(*) INTO v_document_count FROM public.workspace_documents
+  WHERE workspace_id = p_workspace_id AND id = ANY(p_document_ids);
+  IF v_document_count <> array_length(p_document_ids, 1) THEN RAISE EXCEPTION 'workspace unavailable'; END IF;
+  SELECT count(*) INTO v_source_count FROM public.workspace_sources
+  WHERE workspace_id = p_workspace_id AND id = ANY(coalesce(p_source_ids, ARRAY[]::uuid[]));
+  IF v_source_count <> coalesce(array_length(p_source_ids, 1), 0) THEN RAISE EXCEPTION 'workspace unavailable'; END IF;
+  IF p_thread_id IS NOT NULL AND NOT EXISTS (
+    SELECT 1 FROM public.workspace_threads WHERE workspace_id = p_workspace_id AND id = p_thread_id
+  ) THEN RAISE EXCEPTION 'workspace unavailable'; END IF;
+
+  RETURN jsonb_build_object(
+    'workspace', (SELECT jsonb_build_object('motion', motion, 'title', title) FROM public.workspaces WHERE id = p_workspace_id),
+    'documents', (SELECT coalesce(jsonb_agg(jsonb_build_object(
+      'id', document.id, 'title', document.title, 'side', document.side,
+      'epoch', state.epoch, 'sequence', state.durable_sequence, 'text', state.text_projection
+    ) ORDER BY document.side, document.position), '[]'::jsonb)
+      FROM public.workspace_documents AS document
+      JOIN private.workspace_document_state AS state ON state.document_id = document.id
+      WHERE document.workspace_id = p_workspace_id AND document.id = ANY(p_document_ids)),
+    'sources', (SELECT coalesce(jsonb_agg(jsonb_build_object(
+      'id', id, 'title', title, 'content', content, 'provenance', provenance,
+      'citationSnapshot', citation_snapshot
+    ) ORDER BY created_at), '[]'::jsonb)
+      FROM public.workspace_sources WHERE workspace_id = p_workspace_id AND id = ANY(coalesce(p_source_ids, ARRAY[]::uuid[]))),
+    'messages', (SELECT coalesce(jsonb_agg(message ORDER BY message.created_at), '[]'::jsonb)
+      FROM (SELECT role, content, created_at FROM public.workspace_thread_messages
+        WHERE workspace_id = p_workspace_id AND thread_id = p_thread_id AND status = 'complete'
+        ORDER BY created_at DESC LIMIT 12) AS message)
+  );
+END;
+$$;
+REVOKE ALL ON FUNCTION public.get_workspace_ai_context(uuid, uuid, uuid[], uuid[], uuid) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.get_workspace_ai_context(uuid, uuid, uuid[], uuid[], uuid) TO service_role;
diff --git a/supabase/tests/workspace_practice_test.sql b/supabase/tests/workspace_practice_test.sql
new file mode 100644
index 000000000..10c9f3e17
--- /dev/null
+++ b/supabase/tests/workspace_practice_test.sql
@@ -0,0 +1,219 @@
+BEGIN;
+SELECT plan(30);
+
+SELECT has_table('public', 'workspace_sources', 'shared sources exist');
+SELECT has_table('public', 'workspace_threads', 'shared threads exist');
+SELECT has_table('public', 'workspace_thread_messages', 'thread messages exist');
+SELECT has_table('public', 'workspace_artifacts', 'practice artifacts exist');
+SELECT has_function('public', 'save_workspace_source', ARRAY['uuid','uuid','text','text','text','jsonb','jsonb'], 'sources use an authorized RPC');
+SELECT has_function('public', 'create_workspace_thread', ARRAY['uuid','uuid','text'], 'threads use an authorized RPC');
+SELECT has_function('public', 'save_workspace_thread_message', ARRAY['uuid','uuid','uuid','uuid','text','text','text'], 'messages use an authorized RPC');
+SELECT has_function('public', 'start_workspace_thread_generation', ARRAY['uuid','uuid','uuid','uuid','uuid','uuid','text'], 'thread generation starts atomically');
+SELECT has_function('public', 'complete_workspace_thread_generation', ARRAY['uuid','uuid','uuid','uuid','text','text'], 'assistant completion stays server-owned');
+SELECT has_function('public', 'save_workspace_artifact', ARRAY['uuid','uuid','uuid','uuid','bigint','text','text','jsonb','jsonb','jsonb'], 'artifacts use an authorized RPC');
+
+INSERT INTO auth.users (id) VALUES
+  ('91111111-1111-4111-8111-111111111111'),
+  ('92222222-2222-4222-8222-222222222222');
+SET LOCAL ROLE authenticated;
+SELECT set_config('request.jwt.claim.sub', '91111111-1111-4111-8111-111111111111', true);
+SELECT set_config('request.jwt.claim.role', 'authenticated', true);
+SELECT lives_ok(
+  $$SELECT public.create_workspace('Practice motion', 'Practice workspace', 'en', '90000000-0000-4000-8000-000000000001')$$,
+  'practice fixture creates a workspace'
+);
+RESET ROLE;
+SELECT set_config('test.practice_workspace', (SELECT id::text FROM public.workspaces WHERE owner_id = '91111111-1111-4111-8111-111111111111'), true);
+SELECT set_config('test.practice_document', (SELECT id::text FROM public.workspace_documents WHERE workspace_id = current_setting('test.practice_workspace')::uuid ORDER BY side, position LIMIT 1), true);
+
+SET LOCAL ROLE authenticated;
+SELECT set_config('request.jwt.claim.sub', '91111111-1111-4111-8111-111111111111', true);
+SELECT set_config('request.jwt.claim.role', 'authenticated', true);
+SELECT lives_ok(
+  $$SELECT public.save_workspace_source(
+    current_setting('test.practice_workspace')::uuid,
+    '90000000-0000-4000-8000-000000000002', 'Study', 'Quoted evidence', 'url',
+    '{"url":"https://example.com/study"}', '{"title":"Study","url":"https://example.com/study"}'
+  )$$,
+  'a member copies evidence with provenance'
+);
+SELECT lives_ok(
+  $$SELECT public.create_workspace_thread(
+    current_setting('test.practice_workspace')::uuid,
+    '90000000-0000-4000-8000-000000000003', 'Both sides'
+  )$$,
+  'a member creates a named shared thread'
+);
+RESET ROLE;
+SET LOCAL ROLE service_role;
+SELECT results_eq(
+  $$SELECT (public.start_workspace_thread_generation(
+    '91111111-1111-4111-8111-111111111111',
+    current_setting('test.practice_workspace')::uuid,
+    '90000000-0000-4000-8000-000000000003',
+    '90000000-0000-4000-8000-000000000004',
+    '90000000-0000-4000-8000-000000000008',
+    '90000000-0000-4000-8000-000000000005',
+    'Compare both sides'
+  )->>'claimed')::boolean$$,
+  ARRAY[true],
+  'the first thread request claims generation'
+);
+SELECT results_eq(
+  $$SELECT (public.start_workspace_thread_generation(
+    '91111111-1111-4111-8111-111111111111',
+    current_setting('test.practice_workspace')::uuid,
+    '90000000-0000-4000-8000-000000000003',
+    '90000000-0000-4000-8000-000000000004',
+    '90000000-0000-4000-8000-000000000008',
+    '90000000-0000-4000-8000-000000000005',
+    'Compare both sides'
+  )->>'claimed')::boolean$$,
+  ARRAY[false],
+  'an identical retry does not claim another provider call'
+);
+SELECT throws_ok(
+  $$SELECT public.start_workspace_thread_generation(
+    '91111111-1111-4111-8111-111111111111',
+    current_setting('test.practice_workspace')::uuid,
+    '90000000-0000-4000-8000-000000000003',
+    '90000000-0000-4000-8000-000000000006',
+    '90000000-0000-4000-8000-000000000013',
+    '90000000-0000-4000-8000-000000000007',
+    'Race'
+  )$$,
+  'P0001', 'thread generation in progress',
+  'a thread serializes generation'
+);
+RESET ROLE;
+SET LOCAL ROLE authenticated;
+SELECT set_config('request.jwt.claim.sub', '91111111-1111-4111-8111-111111111111', true);
+SELECT set_config('request.jwt.claim.role', 'authenticated', true);
+SELECT throws_ok(
+  $$SELECT public.save_workspace_thread_message(
+    current_setting('test.practice_workspace')::uuid,
+    '90000000-0000-4000-8000-000000000003',
+    '90000000-0000-4000-8000-000000000014',
+    '90000000-0000-4000-8000-000000000005',
+    'assistant', 'Forged answer', 'complete'
+  )$$,
+  'P0001', 'invalid message',
+  'members cannot forge assistant messages'
+);
+
+RESET ROLE;
+SET LOCAL ROLE service_role;
+SELECT lives_ok(
+  $$SELECT public.complete_workspace_thread_generation(
+    '91111111-1111-4111-8111-111111111111',
+    current_setting('test.practice_workspace')::uuid,
+    '90000000-0000-4000-8000-000000000003',
+    '90000000-0000-4000-8000-000000000005',
+    'Shared answer', 'complete'
+  )$$,
+  'server-owned assistant completion releases the thread'
+);
+SELECT results_eq(
+  $$SELECT public.start_workspace_thread_generation(
+    '91111111-1111-4111-8111-111111111111',
+    current_setting('test.practice_workspace')::uuid,
+    '90000000-0000-4000-8000-000000000003',
+    '90000000-0000-4000-8000-000000000004',
+    '90000000-0000-4000-8000-000000000008',
+    '90000000-0000-4000-8000-000000000005',
+    'Compare both sides'
+  ) - 'assistantMessageId'$$,
+  ARRAY['{"claimed": false, "content": "Shared answer", "status": "complete"}'::jsonb],
+  'a completed retry returns its cached answer without reclaiming generation'
+);
+RESET ROLE;
+INSERT INTO public.workspace_members (workspace_id, user_id)
+VALUES (current_setting('test.practice_workspace')::uuid, '92222222-2222-4222-8222-222222222222');
+SET LOCAL ROLE service_role;
+SELECT lives_ok(
+  $$SELECT public.start_workspace_thread_generation(
+    '92222222-2222-4222-8222-222222222222',
+    current_setting('test.practice_workspace')::uuid,
+    '90000000-0000-4000-8000-000000000003',
+    '90000000-0000-4000-8000-000000000015',
+    '90000000-0000-4000-8000-000000000016',
+    '90000000-0000-4000-8000-000000000017',
+    'Request before revocation'
+  )$$,
+  'server starts a teammate request'
+);
+RESET ROLE;
+DELETE FROM public.workspace_members WHERE user_id = '92222222-2222-4222-8222-222222222222';
+SET LOCAL ROLE service_role;
+SELECT lives_ok(
+  $$SELECT public.complete_workspace_thread_generation(
+    '92222222-2222-4222-8222-222222222222',
+    current_setting('test.practice_workspace')::uuid,
+    '90000000-0000-4000-8000-000000000003',
+    '90000000-0000-4000-8000-000000000017',
+    'Generation interrupted', 'interrupted'
+  )$$,
+  'revocation still releases a matching pending request'
+);
+SELECT results_eq(
+  $$SELECT active_request_id FROM public.workspace_threads WHERE id = '90000000-0000-4000-8000-000000000003'$$,
+  ARRAY[NULL::uuid],
+  'revoked request no longer blocks the thread'
+);
+RESET ROLE;
+SET LOCAL ROLE authenticated;
+SELECT set_config('request.jwt.claim.sub', '91111111-1111-4111-8111-111111111111', true);
+SELECT set_config('request.jwt.claim.role', 'authenticated', true);
+SELECT throws_ok(
+  $$SELECT public.save_workspace_artifact(
+    current_setting('test.practice_workspace')::uuid,
+    '90000000-0000-4000-8000-000000000018',
+    '90000000-0000-4000-8000-000000000019',
+    current_setting('test.practice_document')::uuid, 99,
+    'attack', 'complete', '{}', '{}', '{}'
+  )$$,
+  'P0001', 'workspace unavailable',
+  'a stale document epoch cannot receive a result'
+);
+SELECT results_eq(
+  $$SELECT public.save_workspace_artifact(
+    current_setting('test.practice_workspace')::uuid,
+    '90000000-0000-4000-8000-000000000009',
+    '90000000-0000-4000-8000-000000000010',
+    current_setting('test.practice_document')::uuid, 0,
+    'attack', 'complete', '{"case":"R1"}', '{"score":80}', '{}'
+  )$$,
+  ARRAY['90000000-0000-4000-8000-000000000009'::uuid],
+  'a completed result stays pinned to its origin'
+);
+SELECT results_eq(
+  $$SELECT count(*)::bigint FROM public.workspace_sources$$,
+  ARRAY[1::bigint],
+  'the member reads shared evidence'
+);
+SELECT results_eq(
+  $$SELECT count(*)::bigint FROM public.workspace_artifacts$$,
+  ARRAY[1::bigint],
+  'the member reads attached feedback'
+);
+
+SET LOCAL ROLE authenticated;
+SELECT set_config('request.jwt.claim.sub', '92222222-2222-4222-8222-222222222222', true);
+SELECT set_config('request.jwt.claim.role', 'authenticated', true);
+SELECT results_eq($$SELECT count(*)::bigint FROM public.workspace_sources$$, ARRAY[0::bigint], 'private outsider reads no workspace sources');
+SELECT results_eq($$SELECT count(*)::bigint FROM public.workspace_threads$$, ARRAY[0::bigint], 'private outsider reads no shared chats');
+SELECT results_eq($$SELECT count(*)::bigint FROM public.workspace_artifacts$$, ARRAY[0::bigint], 'private outsider reads no practice results');
+SELECT throws_ok(
+  $$SELECT public.save_workspace_artifact(
+    current_setting('test.practice_workspace')::uuid,
+    '90000000-0000-4000-8000-000000000011',
+    '90000000-0000-4000-8000-000000000012',
+    current_setting('test.practice_document')::uuid, 0,
+    'attack', 'complete', '{}', '{}', '{}'
+  )$$,
+  'P0001', 'workspace unavailable',
+  'foreign results cannot attach to a workspace'
+);
+
+SELECT * FROM finish();
+ROLLBACK;