feat(graph): two-mode session deletion — the first destructive ledger operation

DELETE /api/chats/[id]?mode=preserve-graph|delete-nodes (mode required):
- preserve-graph: only extraction bookkeeping dies (coverage rows,
  legacy checkpoints) — graph ledgers byte-untouched
- delete-nodes: the chat's ledger traces die. Node survival = surviving
  provenance point / mapping line (notes imports carry empty
  provenance) / surviving event. The creator's aliases + provenance are
  stripped from a surviving node's create line (owner ruling
  2026-09-23: name/statement/createdAt are the shared identity);
  orphan nodes, their edges, events, mappings, positions, embedding
  vectors and cluster members die; cluster labels stay (immutable)

Gates: 404 unknown, 409 turn_in_flight / jobs_running (with jobIds),
503 extraction_winding_down after a 10s abort-and-poll; the purge is
one sync block (ledgers → jobs → chat record last). rewriteLedgers is
atomic (tmp + rename). graphRevision (max mtime over graph data files)
rides the activity feed + the response as the change stamp.

Anti-resurrection: the chat pipeline re-checks chat liveness at each
merge — a run that slips past the wind-down aborts with nothing merged
or checkpointed; its partial spend dies with the chat.

app/api/chats/[id]/route.ts

@@ -1,4 +1,4 @@
-import { getChat, isTurnRunning, stores } from "@/src/server";
+import { deleteChatSession, getChat, isTurnRunning, stores, type ChatDeleteMode } from "@/src/server";
 
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
 	const { id } = await params;
@@ -28,3 +28,55 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
 	return Response.json({ title: record.title });
 }
 
+/**
+ * DELETE /api/chats/[id]?mode=preserve-graph|delete-nodes — session deletion
+ * (wave 6, owner rulings 2026-09-22/23). The mode is REQUIRED and explicit:
+ * no default, because the two differ in destructiveness —
+ *
+ *   preserve-graph  the session record, its jobs, and its extraction
+ *                   bookkeeping (coverage/checkpoint rows) die; the graph
+ *                   keeps every contribution the session merged.
+ *   delete-nodes    "this session never happened": every ledger trace of
+ *                   the session goes too — provenance, link lines,
+ *                   events, mappings — and orphaned nodes die entirely
+ *                   (shared nodes survive automatically, their other
+ *                   sessions' content intact).
+ *
+ * Gates are the server orchestration's (server/chats.ts deleteChatSession):
+ * 409 while a turn or background job is running, 503 while the session's
+ * extraction is winding down after its abort — both retryable. The
+ * response carries what was removed plus the new graphRevision (the
+ * version stamp the UI polls to refetch clusters/layout).
+ */
+export async function DELETE(req: Request, { params }: { params: Promise<{ id: string }> }) {
+	const { id } = await params;
+	const mode = new URL(req.url).searchParams.get("mode");
+	if (mode !== "preserve-graph" && mode !== "delete-nodes") {
+		return Response.json(
+			{
+				error: 'mode is required and must be "preserve-graph" or "delete-nodes"',
+				code: "bad_mode",
+			},
+			{ status: 400 },
+		);
+	}
+	const outcome = await deleteChatSession(id, mode as ChatDeleteMode);
+	if (!outcome.ok) {
+		return Response.json(
+			{
+				error: outcome.error,
+				code: outcome.code,
+				...("jobIds" in outcome ? { jobIds: outcome.jobIds } : {}),
+		},
+			{ status: outcome.status },
+		);
+	}
+	return Response.json({
+		ok: true,
+		mode: outcome.mode,
+		stats: outcome.stats,
+		jobsRemoved: outcome.jobsRemoved,
+		graphRevision: outcome.graphRevision,
+	});
+}
+