diff --git a/apps/local-server/src/constellation-routes.ts b/apps/local-server/src/constellation-routes.ts
index 0176706..5478dba 100644
--- a/apps/local-server/src/constellation-routes.ts
+++ b/apps/local-server/src/constellation-routes.ts
@@ -362,6 +362,32 @@ export function registerConstellationRoutes(
     },
   );
 
+  server.post(
+    "/constellation/reset",
+    {
+      preValidation: strictBody(envelope, [
+        "worldInstanceId",
+        "expectedRevision",
+        "idempotencyKey",
+      ]),
+      schema: {
+        tags,
+        summary: "End the current roster and start an empty World",
+        body: identityBody,
+      },
+    },
+    async (request, reply) => {
+      try {
+        return envelope.success(
+          request,
+          await service.reset(request.body as MutationBody),
+        );
+      } catch (error) {
+        return fail(error, request, reply, envelope);
+      }
+    },
+  );
+
   server.post(
     "/constellation/end",
     {
diff --git a/apps/local-server/src/constellation-service.ts b/apps/local-server/src/constellation-service.ts
index 732b40a..e05eaff 100644
--- a/apps/local-server/src/constellation-service.ts
+++ b/apps/local-server/src/constellation-service.ts
@@ -654,105 +654,143 @@ export class ConstellationService {
   }
 
   end(request: MutationIdentity): Promise<ConstellationState> {
+    return this.#enqueue(() => this.#end(request));
+  }
+
+  reset(request: MutationIdentity): Promise<ConstellationState> {
     return this.#enqueue(async () => {
       validateMutation(request);
-      const payload = this.#requirePayload(request.worldInstanceId);
       const inputHash = sha256(canonical(request));
-      const existing = payload.idempotency.find(
-        (record) => record.key === request.idempotencyKey,
+      const prior = this.#payload?.idempotency.find(
+        (record) =>
+          record.key === request.idempotencyKey &&
+          record.operation === "world-reset",
       );
-      if (existing) {
-        if (
-          existing.operation !== "world-end" ||
-          existing.inputHash !== inputHash
-        )
+      if (prior) {
+        if (prior.inputHash !== inputHash)
           throw new ConstellationServiceError(
             "conflict",
-            "Idempotency identity was reused with different input",
+            "Reset identity was reused with different input",
           );
-        if (existing.status === "completed" && existing.result)
-          return structuredClone(existing.result);
-      } else {
-        this.#assertRevision(request.expectedRevision);
-        this.#setIdempotency({
-          key: request.idempotencyKey,
-          operation: "world-end",
-          inputHash,
-          status: "pending",
-          result: null,
-        });
-        this.#payload = {
-          ...this.#requirePayload(request.worldInstanceId),
-          projection: ConstellationProjectionSchema.parse({
-            ...payload.projection,
-            lifecycle: "ending",
-            revision: payload.projection.revision + 1,
-            entryReady: false,
-            truth: "current",
-          }),
-        };
-        await this.#persist();
+        if (prior.result) return structuredClone(prior.result);
       }
-
-      const current = this.#requirePayload(request.worldInstanceId);
-      for (const agent of current.projection.agents) {
-        const prior = current.terminalOutcomes.find(
-          (outcome) => outcome.rosterId === agent.rosterId,
-        );
-        if (agent.sessionOwnership === "operator-persistent") {
-          if (!prior)
-            await this.#recordOutcome({
-              rosterId: agent.rosterId,
-              status: "skipped-operator-persistent",
-            });
-          continue;
-        }
-        if (prior?.status === "ended") continue;
-        try {
-          await this.#lifecycle.endWorldSession(
-            agent.worldSessionId,
-            request.worldInstanceId,
-          );
-          await this.#recordOutcome({
-            rosterId: agent.rosterId,
-            status: "ended",
-          });
-        } catch {
-          await this.#recordOutcome({
-            rosterId: agent.rosterId,
-            status: "failed",
-          });
-          throw new ConstellationServiceError(
-            "upstream",
-            "A World-owned session could not be ended",
-          );
-        }
-      }
-
-      const finishing = this.#requirePayload(request.worldInstanceId);
+      await this.#end(request);
       this.#payload = {
-        ...finishing,
-        projection: ConstellationProjectionSchema.parse({
-          ...finishing.projection,
-          lifecycle: "ended",
-          revision: finishing.projection.revision + 1,
-          entryReady: false,
-          truth: "current",
-        }),
+        projection: emptyProjection(randomUUID()),
+        terminalOutcomes: [],
+        idempotency: [],
       };
       const result = this.#currentState();
       this.#setIdempotency({
         key: request.idempotencyKey,
-        operation: "world-end",
+        operation: "world-reset",
         inputHash,
         status: "completed",
         result,
       });
       await this.#persist();
-      return this.#currentState();
+      return result;
     });
   }
 
+  async #end(request: MutationIdentity): Promise<ConstellationState> {
+    validateMutation(request);
+    const payload = this.#requirePayload(request.worldInstanceId);
+    const inputHash = sha256(canonical(request));
+    const existing = payload.idempotency.find(
+      (record) => record.key === request.idempotencyKey,
+    );
+    if (existing) {
+      if (
+        existing.operation !== "world-end" ||
+        existing.inputHash !== inputHash
+      )
+        throw new ConstellationServiceError(
+          "conflict",
+          "Idempotency identity was reused with different input",
+        );
+      if (existing.status === "completed" && existing.result)
+        return structuredClone(existing.result);
+    } else {
+      this.#assertRevision(request.expectedRevision);
+      this.#setIdempotency({
+        key: request.idempotencyKey,
+        operation: "world-end",
+        inputHash,
+        status: "pending",
+        result: null,
+      });
+      this.#payload = {
+        ...this.#requirePayload(request.worldInstanceId),
+        projection: ConstellationProjectionSchema.parse({
+          ...payload.projection,
+          lifecycle: "ending",
+          revision: payload.projection.revision + 1,
+          entryReady: false,
+          truth: "current",
+        }),
+      };
+      await this.#persist();
+    }
+
+    const current = this.#requirePayload(request.worldInstanceId);
+    for (const agent of current.projection.agents) {
+      const prior = current.terminalOutcomes.find(
+        (outcome) => outcome.rosterId === agent.rosterId,
+      );
+      if (agent.sessionOwnership === "operator-persistent") {
+        if (!prior)
+          await this.#recordOutcome({
+            rosterId: agent.rosterId,
+            status: "skipped-operator-persistent",
+          });
+        continue;
+      }
+      if (prior?.status === "ended") continue;
+      try {
+        await this.#lifecycle.endWorldSession(
+          agent.worldSessionId,
+          request.worldInstanceId,
+        );
+        await this.#recordOutcome({
+          rosterId: agent.rosterId,
+          status: "ended",
+        });
+      } catch {
+        await this.#recordOutcome({
+          rosterId: agent.rosterId,
+          status: "failed",
+        });
+        throw new ConstellationServiceError(
+          "upstream",
+          "A World-owned session could not be ended",
+        );
+      }
+    }
+
+    const finishing = this.#requirePayload(request.worldInstanceId);
+    this.#payload = {
+      ...finishing,
+      projection: ConstellationProjectionSchema.parse({
+        ...finishing.projection,
+        lifecycle: "ended",
+        revision: finishing.projection.revision + 1,
+        entryReady: false,
+        truth: "current",
+      }),
+    };
+    const result = this.#currentState();
+    this.#setIdempotency({
+      key: request.idempotencyKey,
+      operation: "world-end",
+      inputHash,
+      status: "completed",
+      result,
+    });
+    await this.#persist();
+    return this.#currentState();
+  }
+
   #mutate(
     operation: string,
     request: MutationIdentity,
diff --git a/apps/local-server/test/phase19-constellation-api.test.ts b/apps/local-server/test/phase19-constellation-api.test.ts
index 8205a83..50a02ae 100644
--- a/apps/local-server/test/phase19-constellation-api.test.ts
+++ b/apps/local-server/test/phase19-constellation-api.test.ts
@@ -74,6 +74,117 @@ async function serverWith(
 }
 
 describe("Phase 19 constellation API", () => {
+  it("resets a full roster into a durable fresh World and permits the same agent choices", async () => {
+    const endWorldSession = vi.fn(async () => undefined);
+    const stateDirectory = directory();
+    const { server, service } = await serverWith(
+      lifecyclePort({ endWorldSession }),
+      stateDirectory,
+    );
+    const adapters = ["hermes", "openclaw", "codex", "claude-code"] as const;
+    for (const [index, adapter] of adapters.entries()) {
+      expect(
+        (
+          await server.inject({
+            method: "POST",
+            url: "/constellation/agents",
+            payload: agent(index + 1, adapter),
+          })
+        ).statusCode,
+      ).toBe(201);
+    }
+    const payload = identity(4, "reset-full-world");
+    const reset = await server.inject({
+      method: "POST",
+      url: "/constellation/reset",
+      payload,
+    });
+    expect(reset.statusCode).toBe(200);
+    const fresh = reset.json().data;
+    expect(fresh.projection).toMatchObject({
+      agents: [],
+      revision: 0,
+      lifecycle: "assembling",
+      entryReady: false,
+    });
+    expect(fresh.projection.worldInstanceId).not.toBe("world-api");
+    expect(endWorldSession.mock.calls).toEqual([
+      ["api-world-session-2", "world-api"],
+      ["api-world-session-3", "world-api"],
+      ["api-world-session-4", "world-api"],
+    ]);
+    for (const [index, adapter] of adapters.entries()) {
+      const input = agent(index + 1, adapter);
+      expect(
+        (
+          await server.inject({
+            method: "POST",
+            url: "/constellation/agents",
+            payload: {
+              ...input,
+              worldInstanceId: fresh.projection.worldInstanceId,
+              agent: {
+                ...input.agent,
+                worldSessionId: `replacement-${index}`,
+                nativeRootSessionRef: `replacement-native-${index}`,
+              },
+            },
+          })
+        ).statusCode,
+      ).toBe(201);
+    }
+    const replay = await server.inject({
+      method: "POST",
+      url: "/constellation/reset",
+      payload,
+    });
+    expect(replay.statusCode).toBe(200);
+    expect(replay.json().data).toEqual(fresh);
+    expect(service.current().projection?.agents).toHaveLength(4);
+    expect(endWorldSession).toHaveBeenCalledTimes(3);
+    const reopened = await ConstellationService.open({
+      directory: stateDirectory,
+      lifecycle: lifecyclePort(),
+    });
+    expect(reopened.current().projection?.worldInstanceId).toBe(
+      fresh.projection.worldInstanceId,
+    );
+    expect(reopened.current().projection?.agents).toHaveLength(4);
+  });
+
+  it("keeps failed reset retryable without opening a replacement World", async () => {
+    const endWorldSession = vi
+      .fn()
+      .mockRejectedValueOnce(new Error("busy"))
+      .mockResolvedValue(undefined);
+    const { server, service } = await serverWith(
+      lifecyclePort({ endWorldSession }),
+    );
+    await server.inject({
+      method: "POST",
+      url: "/constellation/agents",
+      payload: agent(1, "codex"),
+    });
+    const payload = identity(1, "reset-retry");
+    const failed = await server.inject({
+      method: "POST",
+      url: "/constellation/reset",
+      payload,
+    });
+    expect(failed.statusCode).toBe(502);
+    expect(service.current().projection).toMatchObject({
+      worldInstanceId: "world-api",
+      lifecycle: "ending",
+    });
+    const retried = await server.inject({
+      method: "POST",
+      url: "/constellation/reset",
+      payload,
+    });
+    expect(retried.statusCode).toBe(200);
+    expect(retried.json().data.projection.agents).toEqual([]);
+    expect(endWorldSession).toHaveBeenCalledTimes(2);
+  });
   it("exposes all six routes with normal envelopes and side-effect-free repeated GET", async () => {
     const validateBinding = vi.fn(async (binding) => ({
       ...binding,
diff --git a/apps/web/src/sessions/session-client.ts b/apps/web/src/sessions/session-client.ts
index da87a8c..f40ac92 100644
--- a/apps/web/src/sessions/session-client.ts
+++ b/apps/web/src/sessions/session-client.ts
@@ -625,6 +625,12 @@ export class AgentSessionClient {
     );
   }
 
+  resetConstellation(
+    input: ConstellationMutation,
+  ): Promise<ConstellationState> {
+    return this.post("/api/constellation/reset", input);
+  }
+
   endConstellation(input: ConstellationMutation): Promise<ConstellationState> {
     return this.post("/api/constellation/end", input);
   }
diff --git a/apps/web/src/world-entry/WorldEntryExperience.tsx b/apps/web/src/world-entry/WorldEntryExperience.tsx
index 7a30cd1..81cfb9a 100644
--- a/apps/web/src/world-entry/WorldEntryExperience.tsx
+++ b/apps/web/src/world-entry/WorldEntryExperience.tsx
@@ -368,6 +368,13 @@ export function WorldEntryExperience({
   const [agentAvatar, setAgentAvatar] = useState<AvatarDraft | null>(null);
   const [constellation, setConstellation] =
     useState<ConstellationProjection | null>(null);
+  const [resetPending, setResetPending] = useState(false);
+  const resetInFlight = useRef(false);
+  const resetRequest = useRef<{
+    worldInstanceId: string;
+    expectedRevision: number;
+    idempotencyKey: string;
+  } | null>(null);
   const [constellationBusyRosterId, setConstellationBusyRosterId] = useState<
     string | null
   >(null);
@@ -2113,6 +2120,58 @@ export function WorldEntryExperience({
     dispatch({ type: "LEAVE_WORLD", destination });
   };
 
+  const resetWorldSession = async () => {
+    if (resetInFlight.current) return;
+    if (chatBusy || processingChat.current) {
+      setError(
+        "Wait for the current agent turn to finish, then retry Reset Session.",
+      );
+      return;
+    }
+    resetInFlight.current = true;
+    setResetPending(true);
+    setError("");
+    try {
+      if (!resetRequest.current) {
+        const current = (await client.currentConstellation()).projection;
+        resetRequest.current = {
+          worldInstanceId: current.worldInstanceId,
+          expectedRevision: current.revision,
+          idempotencyKey: `world-reset-${crypto.randomUUID()}`,
+        };
+      }
+      const next = await client.resetSession(
+        resetRequest.current,
+        state.sessionMode === "single" ? session : null,
+      );
+      setConstellation(next.projection);
+      setConstellationBusyRosterId(null);
+      setAcceptedAgentAvatars({});
+      setSelectedRecipientId(null);
+      setSelectedConnectionId("");
+      setRosterMovementRequests({});
+      setRosterMovementControls({});
+      setRosterWorkFocus({});
+      setAgentWorkFocus(null);
+      processedRosterMovementOutcomes.current.clear();
+      setAvatarEditingAgent(null);
+      setChangeAgentWork(null);
+      setWheelTaskOpen(false);
+      setWorkbenchOpen(false);
+      setWorldViewOpen(false);
+      setRepositoryReadiness("idle");
+      resetRequest.current = null;
+      leaveWorld("session_select");
+    } catch {
+      setError(
+        "Session reset could not finish. Wait for active agent work to finish, then retry Reset Session. Your current session has not been replaced.",
+      );
+    } finally {
+      resetInFlight.current = false;
+      setResetPending(false);
+    }
+  };
+
   const inWorld =
     state.step === "world_entering" ||
     state.step === "world_blank" ||
@@ -3397,7 +3456,7 @@ export function WorldEntryExperience({
             preferences={preferences}
             onPreferences={updatePreferences}
             onLogout={() => leaveWorld("session_select")}
-            onResetSession={() => leaveWorld("session_select")}
+            onResetSession={() => void resetWorldSession()}
             agents={worldAgentAvatars.map((a) => ({
               rosterId: a.rosterId,
               name: a.name,
@@ -3423,6 +3482,18 @@ export function WorldEntryExperience({
             }}
           />
         ) : null}
+        {resetPending ? (
+          <div
+            className="world-loading-overlay"
+            role="status"
+            aria-live="polite"
+          >
+            <WorldLoadingIndicator
+              label="Releasing session agents"
+              reducedMotion={reducedMotion}
+            />
+          </div>
+        ) : null}
         {repositoryLoading ? (
           <div className="world-loading-overlay">
             <WorldLoadingIndicator
diff --git a/apps/web/src/world-entry/WorldEscapeMenu.tsx b/apps/web/src/world-entry/WorldEscapeMenu.tsx
index 163c9e1..1486b3d 100644
--- a/apps/web/src/world-entry/WorldEscapeMenu.tsx
+++ b/apps/web/src/world-entry/WorldEscapeMenu.tsx
@@ -418,8 +418,10 @@ export function WorldEscapeMenu({
             <span className="terminal-kicker">reset_session_</span>
             <h2 id="world-escape-title">Reset current World session?</h2>
             <p>
-              This clears only this browser’s World attachment and presentation.
-              Your saved identity, avatars, and native agent history remain.
+              This ends the current World-owned agent sessions and releases all
+              agent seats so you can choose a new single-agent or multi-agent
+              session. Saved connections, identity, avatars, and native history
+              remain. Operator-persistent agents are not stopped.
             </p>
             <div className="world-escape-actions">
               <button
diff --git a/apps/web/src/world-entry/world-entry-client.ts b/apps/web/src/world-entry/world-entry-client.ts
index f3c2fdd..d9d0fcd 100644
--- a/apps/web/src/world-entry/world-entry-client.ts
+++ b/apps/web/src/world-entry/world-entry-client.ts
@@ -138,6 +138,11 @@ export type WorldEntrySessionPort = {
     rosterId: string,
     input: SetConstellationAvatarInput,
   ): Promise<ConstellationState>;
+  resetConstellation(input: ConstellationMutation): Promise<ConstellationState>;
+  endWorldSession(
+    sessionId: string,
+    worldInstanceId: string,
+  ): Promise<WorldAgentSession>;
   endConstellation(input: ConstellationMutation): Promise<ConstellationState>;
 };
 
@@ -319,6 +324,22 @@ export function createWorldEntryClient(
       return sessionClient.setConstellationAvatar(rosterId, input);
     },
 
+    async resetSession(
+      input: ConstellationMutation,
+      singleSession?: WorldAgentSession | null,
+    ): Promise<ConstellationState> {
+      if (
+        singleSession &&
+        (singleSession.adapterId !== "hermes" || singleSession.connectionId)
+      ) {
+        await sessionClient.endWorldSession(
+          singleSession.sessionId,
+          input.worldInstanceId,
+        );
+      }
+      return sessionClient.resetConstellation(input);
+    },
+
     endConstellation(
       input: ConstellationMutation,
     ): Promise<ConstellationState> {
diff --git a/apps/web/test/world-entry-reset-handler.test.ts b/apps/web/test/world-entry-reset-handler.test.ts
new file mode 100644
index 0000000..4f2faa2
--- /dev/null
+++ b/apps/web/test/world-entry-reset-handler.test.ts
@@ -0,0 +1,114 @@
+import fs from "node:fs";
+import ts from "typescript";
+import { describe, expect, it, vi } from "vitest";
+
+// Execute the actual component callback with its closure ports. This is not a
+// browser journey or React scheduling proof; manual product acceptance remains.
+const source = fs.readFileSync(
+  new URL("../src/world-entry/WorldEntryExperience.tsx", import.meta.url),
+  "utf8",
+);
+const callback = source.slice(
+  source.indexOf("  const resetWorldSession ="),
+  source.indexOf("  const inWorld ="),
+);
+const javascript = ts.transpile(callback, { target: ts.ScriptTarget.ES2022 });
+
+function setup() {
+  const setters = Object.fromEntries(
+    [...callback.matchAll(/\b(set[A-Z]\w*)\(/g)].map((match) => [
+      match[1]!,
+      vi.fn(),
+    ]),
+  );
+  const context = {
+    ...setters,
+    resetInFlight: { current: false },
+    resetRequest: { current: null },
+    chatBusy: false,
+    processingChat: { current: false },
+    client: {
+      currentConstellation: vi.fn().mockResolvedValue({
+        projection: { worldInstanceId: "old", revision: 8 },
+      }),
+      resetSession: vi.fn().mockResolvedValue({
+        projection: { worldInstanceId: "fresh", agents: [], revision: 0 },
+      }),
+    },
+    state: { sessionMode: "multi" },
+    session: { sessionId: "single" },
+    processedRosterMovementOutcomes: { current: new Map([["old", "outcome"]]) },
+    leaveWorld: vi.fn(),
+    crypto: { randomUUID: () => "reset-id" },
+  };
+  const run = new Function(
+    ...Object.keys(context),
+    `${javascript}; return resetWorldSession;`,
+  )(...Object.values(context)) as () => Promise<void>;
+  return { context, setters, run };
+}
+
+describe("World reset component callback", () => {
+  it("does not leave or free local seats until backend teardown succeeds; coalesces double clicks", async () => {
+    const { context, setters, run } = setup();
+    let complete!: (value: unknown) => void;
+    context.client.resetSession.mockImplementation(
+      () =>
+        new Promise((resolve) => {
+          complete = resolve;
+        }),
+    );
+    const pending = run();
+    await vi.waitFor(() =>
+      expect(context.client.resetSession).toHaveBeenCalledTimes(1),
+    );
+    await run();
+    expect(context.leaveWorld).not.toHaveBeenCalled();
+    expect(setters.setConstellation).not.toHaveBeenCalled();
+    const projection = { worldInstanceId: "fresh", agents: [], revision: 0 };
+    complete({ projection });
+    await pending;
+    expect(setters.setConstellation).toHaveBeenCalledWith(projection);
+    expect(setters.setAcceptedAgentAvatars).toHaveBeenCalledWith({});
+    expect(setters.setSelectedRecipientId).toHaveBeenCalledWith(null);
+    expect(setters.setSelectedConnectionId).toHaveBeenCalledWith("");
+    expect(context.processedRosterMovementOutcomes.current.size).toBe(0);
+    expect(context.leaveWorld).toHaveBeenCalledExactlyOnceWith(
+      "session_select",
+    );
+    expect(context.resetRequest.current).toBeNull();
+    expect(context.resetInFlight.current).toBe(false);
+  });
+
+  it("retains the same request identity after failure and only leaves after a successful retry", async () => {
+    const { context, setters, run } = setup();
+    context.client.resetSession.mockRejectedValueOnce(new Error("busy"));
+    await run();
+    const failedRequest = context.resetRequest.current;
+    expect(failedRequest).not.toBeNull();
+    expect(context.leaveWorld).not.toHaveBeenCalled();
+    expect(setters.setConstellation).not.toHaveBeenCalled();
+    expect(setters.setError).toHaveBeenLastCalledWith(
+      expect.stringContaining("retry Reset Session"),
+    );
+    await run();
+    expect(context.client.currentConstellation).toHaveBeenCalledTimes(1);
+    expect(context.client.resetSession.mock.calls[1]?.[0]).toBe(failedRequest);
+    expect(context.leaveWorld).toHaveBeenCalledOnce();
+  });
+
+  it("includes single-session ownership cleanup and blocks known active chat before teardown", async () => {
+    const single = setup();
+    single.context.state.sessionMode = "single";
+    await single.run();
+    expect(single.context.client.resetSession).toHaveBeenCalledWith(
+      expect.any(Object),
+      single.context.session,
+    );
+    const busy = setup();
+    busy.context.processingChat.current = true;
+    await busy.run();
+    expect(busy.context.client.currentConstellation).not.toHaveBeenCalled();
+    expect(busy.context.leaveWorld).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/web/test/world-entry-reset.test.ts b/apps/web/test/world-entry-reset.test.ts
new file mode 100644
index 0000000..9abcec6
--- /dev/null
+++ b/apps/web/test/world-entry-reset.test.ts
@@ -0,0 +1,120 @@
+import fs from "node:fs";
+import { describe, expect, it, vi } from "vitest";
+import { createWorldEntryClient } from "../src/world-entry/world-entry-client.js";
+import { AgentSessionClient } from "../src/sessions/session-client.js";
+
+const mutation = {
+  worldInstanceId: "old-world",
+  expectedRevision: 8,
+  idempotencyKey: "reset-one",
+};
+const fresh = {
+  projection: { worldInstanceId: "new-world", agents: [], revision: 0 },
+  terminalOutcomes: [],
+  unavailableReason: null,
+};
+
+function clientWith(sessionClient: Record<string, unknown>) {
+  return createWorldEntryClient({ sessionClient } as never);
+}
+
+describe("World reset client", () => {
+  it("wires Reset Session to teardown and clears occupied selection state", () => {
+    const source = fs.readFileSync(
+      new URL("../src/world-entry/WorldEntryExperience.tsx", import.meta.url),
+      "utf8",
+    );
+    expect(source).toContain("onResetSession={() => void resetWorldSession()}");
+    const reset = source.slice(
+      source.indexOf("const resetWorldSession ="),
+      source.indexOf("const inWorld ="),
+    );
+    expect(reset).toContain("await client.resetSession(");
+    expect(reset.indexOf("await client.resetSession(")).toBeLessThan(
+      reset.indexOf('leaveWorld("session_select")'),
+    );
+    for (const clear of [
+      "setConstellation(next.projection)",
+      "setAcceptedAgentAvatars({})",
+      "setSelectedRecipientId(null)",
+      'setSelectedConnectionId("")',
+      "setRosterMovementRequests({})",
+      "setRosterWorkFocus({})",
+    ])
+      expect(reset).toContain(clear);
+  });
+  it("waits for authoritative reset before returning the empty roster", async () => {
+    const resetConstellation = vi.fn().mockResolvedValue(fresh);
+    const client = clientWith({ resetConstellation });
+    expect(await client.resetSession(mutation)).toEqual(fresh);
+    expect(resetConstellation).toHaveBeenCalledWith(mutation);
+  });
+
+  it("ends a single World-owned attachment before rolling the World", async () => {
+    const calls: string[] = [];
+    const endWorldSession = vi.fn(async () => {
+      calls.push("end");
+    });
+    const client = clientWith({
+      endWorldSession,
+      resetConstellation: async () => {
+        calls.push("reset");
+        return fresh;
+      },
+    });
+    await client.resetSession(mutation, {
+      sessionId: "single",
+      adapterId: "codex",
+    } as never);
+    expect(endWorldSession).toHaveBeenCalledWith("single", "old-world");
+    expect(calls).toEqual(["end", "reset"]);
+  });
+
+  it("preserves operator-persistent Hermes but closes saved World-owned Hermes", async () => {
+    const endWorldSession = vi.fn();
+    const client = clientWith({
+      endWorldSession,
+      resetConstellation: async () => fresh,
+    });
+    await client.resetSession(mutation, {
+      sessionId: "operator",
+      adapterId: "hermes",
+    } as never);
+    expect(endWorldSession).not.toHaveBeenCalled();
+    await client.resetSession(mutation, {
+      sessionId: "owned",
+      adapterId: "hermes",
+      connectionId: "saved-hermes",
+    } as never);
+    expect(endWorldSession).toHaveBeenCalledWith("owned", "old-world");
+  });
+
+  it("does not report success or rotate after a single attachment fails to end", async () => {
+    const resetConstellation = vi.fn();
+    const client = clientWith({
+      endWorldSession: async () => {
+        throw new Error("active turn");
+      },
+      resetConstellation,
+    });
+    await expect(
+      client.resetSession(mutation, {
+        sessionId: "single",
+        adapterId: "codex",
+      } as never),
+    ).rejects.toThrow("active turn");
+    expect(resetConstellation).not.toHaveBeenCalled();
+  });
+
+  it("posts reset identity to the actual reset route", async () => {
+    const fetcher = vi.fn<typeof fetch>(
+      async () =>
+        new Response(JSON.stringify({ ok: true, data: fresh }), {
+          status: 200,
+        }),
+    );
+    const client = new AgentSessionClient(fetcher as typeof fetch);
+    expect(await client.resetConstellation(mutation)).toEqual(fresh);
+    expect(fetcher.mock.calls[0]?.[0]).toBe("/api/constellation/reset");
+  });
+});
diff --git a/docs/internal/GPU_SESSION_LIFECYCLE_FIX.md b/docs/internal/GPU_SESSION_LIFECYCLE_FIX.md
new file mode 100644
index 0000000..433f85a
--- /dev/null
+++ b/docs/internal/GPU_SESSION_LIFECYCLE_FIX.md
@@ -0,0 +1,28 @@
+# GPU session lifecycle — PR35 follow-up
+
+## Authorized scope (October 6, 2026)
+
+Aaron1557064167465287852 requested the GPU-lifecycle work in the same PR35. Reset/reselection already manually passed repeated sessions, differing repositories, multi→single, and real Claude coding (1557060898697248840). Preserve that behavior and the still-open TEST45493 build/state. Develop separately in /home/mela_ai/AgentIntersect-World-gpu; push to existing fix/reset-session-agent-release, no merge/release/provider changes.
+
+Acceptance: explicitly release retired renderer/device resources through the actual pinned canvas teardown; release clone-owned avatar skeleton resources without disposing shared assets; inspect repository/cache ownership and fix only demonstrated gaps. Focused lifecycle regressions and conventional core gates required. Physical GPU-memory stabilization requires separate controlled human cycles: same reset/scene repeatedly, repository swaps, then avatar swaps. No scripted product journeys or modification of live session authorized.
+
+Read-only baseline: TEST45493 owner/build/health passed; NVIDIA adapter13155 then13073MiB (12.77GiB), total16303MiB. Whole-device snapshots, not tab attribution or before/after proof. Formatted Windows per-process counters were implausible and rejected. User observes growth after transitions despite earlier hour-long idle stability.
+
+Primary candidate: renderer-r3f world-renderer.js creates Three0.186 WebGPURenderer. Fiber9.6.1 unmount calls renderLists?.dispose and forceContextLoss?.(), not renderer.dispose. WebGPURenderer lacks forceContextLoss; its dispose releases renderer managers and owned backend/device. Secondary: SkeletonUtils-cloned avatars rendered as primitives retain clone-owned skeleton textures without explicit disposal; shared source geometries/materials/textures must remain usable. RepositoryCityInstance disposes cloned materials; loaded source model caching is not by itself a physical GPU leak.
+
+## Implementation and verification
+
+- `createWorldRenderer` supplies Fiber9's synchronous `forceContextLoss` teardown hook, delegating once to the renderer's asynchronous `dispose()` and reporting failures. This covers its WebGPU and WebGL2-fallback backends without modifying dependencies.
+- `retainModelResources` reference-counts each cached source scene. Final release is deferred one timer turn so Strict Mode replay and same-commit reuse can cancel disposal. It releases source geometries, materials, textures and skeletons; CPU asset data and images remain reusable, and an active avatar/preview/city instance protects the source. No blanket loader-cache clear or forced GC.
+- Imported-avatar clones and raw-review clones explicitly dispose their own skeleton textures. Existing mixer/batch/impostor cleanup remains; cloned city materials already had owner cleanup. Source ownership is registered in both normal imported-avatar mounts, raw review and loaded city instances.
+- Renderer regression RED: actual installed Fiber canvas unmount called fixture renderer.dispose zero times. GREEN: three successive teardowns call it once each, including the fallback-backend fixture and duplicate callback.
+- Real React/Fiber avatar-component test mounts two shared avatars under Strict Mode, removes one, removes the last, and reuses the cached source. Clone texture and source-resource disposal follow ownership. Removing the clone cleanup reproduces RED (zero calls rather than one); restoring it passes. Loader/GPU are fixtures, not browser/hardware evidence.
+- Model-resource tests exercise real Three objects: two consumers, Strict Mode retain cancellation, final release, reusable source data and independent clone-owned bone textures.
+- Full Node24.18.0 `check:core` PASS: format, lint, types, architecture, **1,624 tests / 289 files**, normal build and disposable-port API/startup smoke. Initial broad renderer invocation lacked built workspace schema output; core built the prerequisites and covered all57renderer test files. Initial lint failure corrected to explicit globalThis browser globals.
+- Existing Three CommonJS deprecation and bundle-size warnings remain nonfatal. No product browser journey executed, and no physical VRAM reclamation claimed. TEST45493 remained on its prior bytes.
+
+## Controlled hands-on retest (pending)
+
+After authorized replacement of the retained lane with this build, record adapter baseline and keep graphics/browser/background applications fixed. Start the same agent/avatars and repository; repeat three reset/re-entry cycles, recording settled memory after each. Separately alternate two repositories without session reset; then swap avatars while keeping scene/agent count fixed. Revisit the original configuration in each sequence. Record both in-scene and post-reset/selection readings; allow delayed teardown/reclamation to settle. A stable repeatable plateau is distinct from growth each time the same configuration is revisited. Driver-wide readings alone do not allocate every byte to World.
+
+Aaron's functional reset acceptance on the earlier PR35 build remains valid evidence; new GPU-lifecycle behavior and retained visuals/animations still need human acceptance. PR35 remains draft/unmerged; do not reload, reset, shut down or patch the existing retained session automatically.
diff --git a/docs/internal/SESSION_RESET_FIX.md b/docs/internal/SESSION_RESET_FIX.md
new file mode 100644
index 0000000..cf02a49
--- /dev/null
+++ b/docs/internal/SESSION_RESET_FIX.md
@@ -0,0 +1,40 @@
+# Session reset agent release
+
+## Scope — October 6, 2026
+
+Aaron requested a separate PR after TEST45492 reproduced a four-agent reset lockout. Reset must release the old World-owned sessions and roster, retain discovery registrations/user identity/avatars/native history, and allow another single-agent or multi-agent setup, including the same agent choices. Do not stop underlying harness services or operator-persistent sessions. Keep the existing review lane unchanged; manual acceptance and merge remain pending. No performance work, provider changes, releases, or scripted product-navigation journeys.
+
+## Observed evidence
+
+Read-only TEST45492 health/owner/served-build verification passed. After Aaron used Escape → Reset Session and reached agent selection, GET /api/constellation/current still returned lifecycle active, revision 8, four connected agents, entryReady true, and no terminal outcomes. The UI leaveWorld handler only resets local presentation and leaves the constellation state intact; the selector's rosterFull guard therefore disables all harness choices. Discovery recheck cannot release roster seats.
+
+The existing end endpoint closes owned roster sessions but leaves a terminal constellation; no new-world rollover exists. The fix must perform both teardown and a fresh empty World generation, not only clear the local roster or call end.
+
+## Prior performance verdict
+
+Aaron reports four agents with Clone test loaded, all graphics settings enabled, sitting for at least an hour; GPU RAM did not exceed reported 5.9. Provisional sustained-memory stability PASS for that scenario, not a complete leak-elimination or FPS claim. Prior effects-on slowdown/city-view pause remain separate.
+
+## Acceptance
+
+- Reset a full roster, preserve operator-persistent identity, and start with zero occupied seats and a fresh World identity.
+- Reuse the same discovered agents in a new multi-agent session or select a single agent.
+- Repeated reset requests do not terminate a replacement session; failed teardown keeps the previous state retryable and does not pretend success.
+- Clear stale UI selection, avatars, targeting, and movement state only after successful reset.
+- Single World-owned attachments are released as well; discovery registrations and native history are not deleted.
+
+## Verification
+
+- Focused RED: reset endpoint returned 404 before implementation; the client had no reset method; the Escape-menu binding still selected presentation-only leave. An initial add-agent fixture expected 200 instead of the existing 201 contract and was corrected before counting the endpoint RED.
+- Focused GREEN: 60 tests across seven lifecycle, client, component-callback, entry-state and multi-agent UI files passed.
+- Full conventional `check:core` passed: formatting, lint, TypeScript, architecture, **1,620 tests / 286 files**, production build and disposable-port startup/API smoke. One initial formatting failure was corrected before the successful run. Existing Three CommonJS deprecation and bundle-size warnings remain non-fatal.
+- Callback tests execute the actual component callback with closure ports; they establish await-before-leave, double-click coalescing, failure/retry identity and local cleanup. They are not React scheduling, native-harness or hands-on product acceptance.
+- API tests use the real server/service and disposable durable storage with a lifecycle fixture. They prove fresh identity, full-roster reselection, idempotent replay, persistence and failed-end retry; they do not end Aaron's live agents.
+- Exact-head CI and Aaron's hands-on acceptance remain pending. No scripted product-navigation journeys were run. TEST45492 was only read, not changed.
+
+## Manual acceptance after authorized test-lane switch
+
+1. Start four agents, load Clone test, use Escape → Reset Session, and confirm selection is usable after reset completes.
+2. Choose the same four agent connections for a new multi-agent session and enter World.
+3. Reset again, choose Single Agent, connect any discovered agent, and enter World.
+4. Reset the single-agent session and choose a different single agent or another multi-agent group. Saved discovery registrations and user/avatar choices should remain available.
+5. If a native agent cannot end, the UI must remain on the current World with a retry message rather than claiming successful reset.
diff --git a/packages/renderer-r3f/src/imported-avatar-canvas.tsx b/packages/renderer-r3f/src/imported-avatar-canvas.tsx
index 2cee48f..b86323c 100644
--- a/packages/renderer-r3f/src/imported-avatar-canvas.tsx
+++ b/packages/renderer-r3f/src/imported-avatar-canvas.tsx
@@ -1,4 +1,8 @@
 import { createPreviewRenderer } from "./world-renderer.js";
+import {
+  disposeAvatarSkeletons,
+  retainModelResources,
+} from "./model-resource-lifecycle.js";
 import { prepareAvatarBounds } from "./world-preparation.js";
 import {
   Canvas,
@@ -479,6 +483,7 @@ function ImportedAvatarModel({
       activeAction.current = null;
       mixer.stopAllAction();
       mixer.uncacheRoot(scene);
+      disposeAvatarSkeletons(scene);
     },
     [mixer, scene],
   );
@@ -600,6 +605,7 @@ export function ImportedAvatarWorldModel({
   readonly representation?: ImportedAvatarWorldRepresentation | undefined;
 }) {
   const gltf = useLoader(ImportedAvatarGLTFLoader, selection.assetUrl);
+  useEffect(() => retainModelResources(gltf.scene), [gltf.scene]);
   const resolvedRotation: readonly [number, number, number] = [
     selection.rotation[0] + rotation[0],
     selection.rotation[1] + rotation[1],
@@ -659,6 +665,7 @@ export function ImportedAvatarCanvas({
   readonly scale: number;
 }) {
   const gltf = useLoader(ImportedAvatarGLTFLoader, selection.assetUrl);
+  useEffect(() => retainModelResources(gltf.scene), [gltf.scene]);
   const selectionKey = [
     selection.assetId,
     selection.clipIndex,
diff --git a/packages/renderer-r3f/src/imported-avatar-review-canvas.tsx b/packages/renderer-r3f/src/imported-avatar-review-canvas.tsx
index ebc7af6..bf425ab 100644
--- a/packages/renderer-r3f/src/imported-avatar-review-canvas.tsx
+++ b/packages/renderer-r3f/src/imported-avatar-review-canvas.tsx
@@ -1,4 +1,8 @@
 import { createPreviewRenderer } from "./world-renderer.js";
+import {
+  disposeAvatarSkeletons,
+  retainModelResources,
+} from "./model-resource-lifecycle.js";
 import { Canvas, useFrame, useLoader, useThree } from "@react-three/fiber";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { AnimationMixer, type AnimationAction, type Group } from "three";
@@ -175,6 +179,7 @@ function ReviewModel({
     () => () => {
       mixer.stopAllAction();
       mixer.uncacheRoot(scene);
+      disposeAvatarSkeletons(scene);
     },
     [mixer, scene],
   );
@@ -218,6 +223,7 @@ export function ImportedAvatarReviewCanvas({
   ) => void;
 }) {
   const gltf = useLoader(GLTFLoader, selection.assetUrl);
+  useEffect(() => retainModelResources(gltf.scene), [gltf.scene]);
   const [renderState, setRenderState] = useState<
     "loading" | "ready" | "refused"
   >("loading");
diff --git a/packages/renderer-r3f/src/model-resource-lifecycle.js b/packages/renderer-r3f/src/model-resource-lifecycle.js
new file mode 100644
index 0000000..ae4a09b
--- /dev/null
+++ b/packages/renderer-r3f/src/model-resource-lifecycle.js
@@ -0,0 +1,50 @@
+import { Mesh, Texture } from "three";
+
+// useLoader retains CPU model data across canvases. Keep that reusable data,
+// but release GPU-backed resources once no mounted model uses the source.
+const modelUsers = new WeakMap();
+
+export function retainModelResources(scene) {
+  let owner = modelUsers.get(scene);
+  if (!owner) {
+    owner = { users: 0, release: undefined };
+    modelUsers.set(scene, owner);
+  }
+  globalThis.clearTimeout(owner.release);
+  owner.users++;
+  return () => {
+    owner.users--;
+    if (owner.users !== 0) return;
+    // Let Strict Mode cleanup/setup and same-commit model replacements retain
+    // the asset before releasing it. No images are closed or cache entries lost.
+    owner.release = globalThis.setTimeout(() => {
+      const resources = new Set();
+      scene.traverse((object) => {
+        if (!(object instanceof Mesh)) return;
+        resources.add(object.geometry);
+        const materials = Array.isArray(object.material)
+          ? object.material
+          : [object.material];
+        for (const material of materials) {
+          resources.add(material);
+          for (const value of Object.values(material)) {
+            if (value instanceof Texture) resources.add(value);
+          }
+        }
+      });
+      disposeAvatarSkeletons(scene);
+      for (const resource of resources) resource.dispose();
+      modelUsers.delete(scene);
+    }, 0);
+  };
+}
+
+// SkeletonUtils clones skeletons, but shares source geometry/material/texture.
+// Only the clone's bone texture belongs to this avatar instance.
+export function disposeAvatarSkeletons(scene) {
+  const skeletons = new Set();
+  scene.traverse((object) => {
+    if (object.isSkinnedMesh) skeletons.add(object.skeleton);
+  });
+  for (const skeleton of skeletons) skeleton.dispose();
+}
diff --git a/packages/renderer-r3f/src/repository-city-canvas.tsx b/packages/renderer-r3f/src/repository-city-canvas.tsx
index d850bab..84cbe3e 100644
--- a/packages/renderer-r3f/src/repository-city-canvas.tsx
+++ b/packages/renderer-r3f/src/repository-city-canvas.tsx
@@ -1,3 +1,4 @@
+import { retainModelResources } from "./model-resource-lifecycle.js";
 import {
   useFrame,
   useLoader,
@@ -522,5 +523,6 @@ function LoadedRepositoryCityModel(
     RepositoryCityGLTFLoader,
     REPOSITORY_ASSET_BY_ID.get(props.instance.assetId)!.glbUrl,
   );
+  useEffect(() => retainModelResources(gltf.scene), [gltf.scene]);
   return <RepositoryCityModel {...props} gltf={gltf} />;
 }
diff --git a/packages/renderer-r3f/src/world-renderer.js b/packages/renderer-r3f/src/world-renderer.js
index b3df0a5..1cbc69d 100644
--- a/packages/renderer-r3f/src/world-renderer.js
+++ b/packages/renderer-r3f/src/world-renderer.js
@@ -31,7 +31,17 @@ export async function createWorldRenderer({ canvas }, antialias = false) {
     ? "webgpu"
     : "webgl2";
   canvas.dataset.rendererRevision = "186";
-  return renderer;
+  // Fiber 9 tears down canvases via forceContextLoss(), not dispose(). Its
+  // WebGL-shaped hook must also release our WebGPU renderer and owned device.
+  // Keep the hook synchronous for Fiber; the renderer's teardown is async.
+  let disposal;
+  return Object.assign(renderer, {
+    forceContextLoss() {
+      disposal ??= renderer.dispose().catch((error) => {
+        globalThis.console.error("World renderer disposal failed", error);
+      });
+    },
+  });
 }
 
 /** Keep light/fog shader bindings stable while only their values change. */
diff --git a/packages/renderer-r3f/test/avatar-component-lifecycle.test.ts b/packages/renderer-r3f/test/avatar-component-lifecycle.test.ts
new file mode 100644
index 0000000..92bac89
--- /dev/null
+++ b/packages/renderer-r3f/test/avatar-component-lifecycle.test.ts
@@ -0,0 +1,140 @@
+import { afterEach, expect, it, vi } from "vitest";
+import { createElement, StrictMode } from "react";
+import {
+  act,
+  createRoot,
+  extend,
+  _roots,
+  useLoader,
+  unmountComponentAtNode,
+} from "@react-three/fiber";
+import {
+  Bone,
+  BoxGeometry,
+  Group,
+  MeshStandardMaterial,
+  Skeleton,
+  SkinnedMesh,
+  Texture,
+} from "three";
+import {
+  ImportedAvatarGLTFLoader,
+  ImportedAvatarWorldModel,
+  type ImportedAvatarWorldSelection,
+} from "../src/imported-avatar-canvas.js";
+
+// Real React/Fiber component lifecycle, cached-loader and GPU fixtures only.
+// No browser navigation, physical GPU allocation, or native harness dispatch.
+afterEach(() => {
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
+  vi.useRealTimers();
+});
+it("releases replaced avatar instances and sources while preserving a shared active avatar", async () => {
+  vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+  vi.useFakeTimers();
+  extend({ Group });
+  const texture = new Texture();
+  const geometry = new BoxGeometry();
+  geometry.computeBoundingBox();
+  const material = new MeshStandardMaterial({ map: texture });
+  const source = new Group();
+  const mesh = new SkinnedMesh(geometry, material);
+  const bone = new Bone();
+  mesh.add(bone);
+  mesh.bind(new Skeleton([bone]));
+  mesh.boundingBox = geometry.boundingBox;
+  source.add(mesh);
+  const sourceTexture = vi.spyOn(texture, "dispose");
+  const url = "fixture-avatar-lifecycle.glb";
+  vi.spyOn(ImportedAvatarGLTFLoader.prototype, "load").mockImplementation(
+    (_url, loaded) => {
+      loaded({ scene: source, animations: [] } as never);
+    },
+  );
+  const selection: ImportedAvatarWorldSelection = {
+    assetId: "fixture",
+    assetUrl: url,
+    rotation: [0, 0, 0],
+    scale: 1,
+    groundOffset: 0,
+    resolvedClip: {
+      clipIndex: -1,
+      clipName: "",
+      locomotion: "Idle",
+      semantic: "Idle",
+      oneShot: false,
+      durationSeconds: 0,
+      verification: "evidence-refused",
+      error: "no fixture clip",
+    },
+  };
+  const avatar = (key: string) =>
+    createElement(ImportedAvatarWorldModel, {
+      key,
+      role: "agent",
+      selection,
+      action: "Idle",
+      animate: false,
+      position: [0, 0, 0],
+      rotation: [0, 0, 0],
+      scale: 1,
+      onReady: () => {},
+      animationGeneration: 0,
+    });
+  const canvas = { dataset: {} } as HTMLCanvasElement;
+  const renderer = {
+    render() {},
+    setSize() {},
+    setPixelRatio() {},
+    shadowMap: {},
+  };
+  const root = createRoot(canvas);
+  await root.configure({
+    gl: renderer as never,
+    frameloop: "never",
+    dpr: 1,
+    size: { width: 64, height: 64, top: 0, left: 0 },
+  });
+  try {
+    await act(async () => {
+      root.render(
+        createElement(StrictMode, null, avatar("one"), avatar("two")),
+      );
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    const scene = _roots.get(canvas)!.store.getState().scene;
+    const clones: SkinnedMesh[] = [];
+    scene.traverse((object) => {
+      if (object instanceof SkinnedMesh) clones.push(object);
+    });
+    expect(clones).toHaveLength(2);
+    clones.forEach((clone) => clone.skeleton.computeBoneTexture());
+    const first = vi.spyOn(clones[0]!.skeleton.boneTexture!, "dispose");
+    const second = vi.spyOn(clones[1]!.skeleton.boneTexture!, "dispose");
+    await act(async () => {
+      root.render(createElement(StrictMode, null, avatar("two")));
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    expect(first).toHaveBeenCalledOnce();
+    expect(second).not.toHaveBeenCalled();
+    expect(sourceTexture).not.toHaveBeenCalled();
+    await act(async () => {
+      root.render(null);
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    expect(second).toHaveBeenCalledOnce();
+    expect(sourceTexture).toHaveBeenCalledOnce();
+    // The cached source remains loadable after its GPU resources were released.
+    await act(async () => {
+      root.render(avatar("reused"));
+    });
+    expect(scene.children).toHaveLength(1);
+  } finally {
+    await act(async () => {
+      unmountComponentAtNode(canvas);
+    });
+    await vi.advanceTimersByTimeAsync(500);
+    useLoader.clear(ImportedAvatarGLTFLoader, url);
+  }
+});
diff --git a/packages/renderer-r3f/test/model-resource-lifecycle.test.ts b/packages/renderer-r3f/test/model-resource-lifecycle.test.ts
new file mode 100644
index 0000000..02d3c54
--- /dev/null
+++ b/packages/renderer-r3f/test/model-resource-lifecycle.test.ts
@@ -0,0 +1,85 @@
+import { afterEach, expect, it, vi } from "vitest";
+import {
+  Bone,
+  BoxGeometry,
+  Group,
+  MeshStandardMaterial,
+  Skeleton,
+  SkinnedMesh,
+  Texture,
+} from "three";
+import { configureImportedAvatarScene } from "../src/imported-avatar-canvas.js";
+import * as lifecycle from "../src/model-resource-lifecycle.js";
+
+// Tests exercise real Three disposal events, not physical GPU reclamation.
+const owners = lifecycle as unknown as {
+  retainModelResources: (scene: Group) => () => void;
+  disposeAvatarSkeletons: (scene: Group) => void;
+};
+afterEach(() => vi.useRealTimers());
+function model() {
+  const scene = new Group();
+  const texture = new Texture();
+  const geometry = new BoxGeometry();
+  const material = new MeshStandardMaterial({ map: texture });
+  const bone = new Bone();
+  const mesh = new SkinnedMesh(geometry, material);
+  mesh.add(bone);
+  mesh.bind(new Skeleton([bone]));
+  scene.add(mesh);
+  return { scene, texture, geometry, material, mesh };
+}
+
+it("releases a model only after its final user leaves, and can reuse cached source data", async () => {
+  expect(owners.retainModelResources).toBeTypeOf("function");
+  vi.useFakeTimers();
+  const asset = model();
+  const texture = vi.spyOn(asset.texture, "dispose");
+  const geometry = vi.spyOn(asset.geometry, "dispose");
+  const material = vi.spyOn(asset.material, "dispose");
+  const leaveFirst = owners.retainModelResources(asset.scene);
+  const leaveSecond = owners.retainModelResources(asset.scene);
+  leaveFirst();
+  await vi.runAllTimersAsync();
+  expect(texture).not.toHaveBeenCalled();
+  leaveSecond();
+  // Strict Mode cleanup/setup replay must cancel the pending release.
+  const leaveReplay = owners.retainModelResources(asset.scene);
+  await vi.runAllTimersAsync();
+  expect(texture).not.toHaveBeenCalled();
+  leaveReplay();
+  await vi.runAllTimersAsync();
+  expect(texture).toHaveBeenCalledOnce();
+  expect(geometry).toHaveBeenCalledOnce();
+  expect(material).toHaveBeenCalledOnce();
+  expect(asset.mesh.geometry).toBe(asset.geometry);
+  expect(asset.material.map).toBe(asset.texture);
+  const leaveReused = owners.retainModelResources(asset.scene);
+  leaveReused();
+  await vi.runAllTimersAsync();
+  expect(texture).toHaveBeenCalledTimes(2);
+});
+
+it("disposes clone-owned skeleton textures without touching another avatar or shared model resources", () => {
+  expect(owners.disposeAvatarSkeletons).toBeTypeOf("function");
+  const asset = model();
+  const first = configureImportedAvatarScene(asset.scene);
+  const second = configureImportedAvatarScene(asset.scene);
+  const a = first.children[0] as SkinnedMesh;
+  const b = second.children[0] as SkinnedMesh;
+  a.skeleton.computeBoneTexture();
+  b.skeleton.computeBoneTexture();
+  const aTexture = vi.spyOn(a.skeleton.boneTexture!, "dispose");
+  const bTexture = vi.spyOn(b.skeleton.boneTexture!, "dispose");
+  const geometry = vi.spyOn(asset.geometry, "dispose");
+  const material = vi.spyOn(asset.material, "dispose");
+  const sourceTexture = vi.spyOn(asset.texture, "dispose");
+  owners.disposeAvatarSkeletons(first);
+  expect(aTexture).toHaveBeenCalledOnce();
+  expect(a.skeleton.boneTexture).toBeNull();
+  expect(bTexture).not.toHaveBeenCalled();
+  expect(geometry).not.toHaveBeenCalled();
+  expect(material).not.toHaveBeenCalled();
+  expect(sourceTexture).not.toHaveBeenCalled();
+  owners.disposeAvatarSkeletons(second);
+});
diff --git a/packages/renderer-r3f/test/world-renderer-lifecycle.test.ts b/packages/renderer-r3f/test/world-renderer-lifecycle.test.ts
new file mode 100644
index 0000000..6ad7c9f
--- /dev/null
+++ b/packages/renderer-r3f/test/world-renderer-lifecycle.test.ts
@@ -0,0 +1,70 @@
+import { afterEach, expect, it, vi } from "vitest";
+import { act, createRoot, unmountComponentAtNode } from "@react-three/fiber";
+import { createWorldRenderer } from "../src/world-renderer.js";
+
+// Exercise the installed reconciler's real canvas-unmount path. The GPU is a
+// fixture: these counters prove ownership/disposal, not physical VRAM recovery.
+const gpu = vi.hoisted(() => ({
+  webgpu: true,
+  renderers: [] as {
+    dispose: ReturnType<typeof vi.fn>;
+    forceContextLoss?: () => void;
+  }[],
+}));
+vi.mock("three/webgpu", async () => {
+  const actual = await vi.importActual("three/webgpu");
+  return {
+    ...actual,
+    WebGPURenderer: class {
+      library = { addLight: vi.fn() };
+      shadowMap = { enabled: false, type: 0 };
+      backend = { isWebGPUBackend: gpu.webgpu };
+      domElement: HTMLCanvasElement;
+      onDeviceLost = vi.fn();
+      init = vi.fn(async () => {});
+      dispose = vi.fn(async () => {});
+      render = vi.fn();
+      setSize = vi.fn();
+      setPixelRatio = vi.fn();
+      constructor({ canvas }: { canvas: HTMLCanvasElement }) {
+        this.domElement = canvas;
+        gpu.renderers.push(this);
+      }
+    },
+  };
+});
+afterEach(() => {
+  gpu.renderers = [];
+  gpu.webgpu = true;
+  vi.useRealTimers();
+  vi.unstubAllGlobals();
+});
+
+it("releases each retired WebGPU renderer through real R3F canvas teardown", async () => {
+  vi.useFakeTimers();
+  vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+  for (let session = 0; session < 3; session++) {
+    gpu.webgpu = session !== 1;
+    const canvas = { dataset: {} } as HTMLCanvasElement;
+    const root = createRoot(canvas);
+    await root.configure({
+      gl: createWorldRenderer,
+      frameloop: "never",
+      dpr: 1,
+      size: { width: 64, height: 64, top: 0, left: 0 },
+    });
+    await act(async () => {
+      root.render(null);
+    });
+    const renderer = gpu.renderers.at(-1)!;
+    expect(renderer.dispose).not.toHaveBeenCalled();
+    await act(async () => {
+      unmountComponentAtNode(canvas);
+    });
+    await vi.advanceTimersByTimeAsync(500);
+    expect(renderer.dispose).toHaveBeenCalledOnce();
+    renderer.forceContextLoss?.();
+    expect(renderer.dispose).toHaveBeenCalledOnce();
+  }
+  expect(gpu.renderers).toHaveLength(3);
+});