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.
This commit is contained in:
amosblomqvist
@@ -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,
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
@@ -725,7 +725,12 @@ export function createExtractionPipeline(deps: ExtractionPipelineDeps): Extracti
|
||||
* Idempotent per startedAt (the store dedupes). */
|
||||
function persistRunUsage(chatId: string, durationMs: number, stats: EmissionStats | undefined): void {
|
||||
const run = runningExtractions.get(chatId);
|
||||
if (!run) return;
|
||||
if (!run) return; // not running (tests driving stages directly)
|
||||
// SESSION-DELETION GUARD (wave 6): a chat deleted mid-run has no
|
||||
// usage log to append to — the record's death is the user's choice
|
||||
// and its partial spend logs with it (appendSourceUsage below
|
||||
// already no-ops for a vanished source; the chat path guards here).
|
||||
if (run.kind === "chat" && !chatStore.getChat(chatId)) return;
|
||||
const entry: ExtractionRunUsage = {
|
||||
startedAt: run.startedAt,
|
||||
at: new Date().toISOString(),
|
||||
@@ -787,6 +792,16 @@ export function createExtractionPipeline(deps: ExtractionPipelineDeps): Extracti
|
||||
setPhase(chatId, "auditing", "chat");
|
||||
const auditResult = await audit(chatId, findings, view);
|
||||
setPhase(chatId, "merging", "chat");
|
||||
// SESSION-DELETION GUARD (wave 6): a chat deleted mid-run must never
|
||||
// merge. The deletion route aborts this run first and runs its purge
|
||||
// as one sync block; this closes the last window — a run that slipped
|
||||
// past the wind-down finds the chat gone HERE and rides the existing
|
||||
// abort path (info, not error): nothing merged, nothing checkpointed.
|
||||
if (!chatStore.getChat(chatId)) {
|
||||
const gone = new Error(`chat deleted mid-run: ${chatId}`);
|
||||
gone.name = "AbortError";
|
||||
throw gone;
|
||||
}
|
||||
// The batch's messages, snapshotted when the run computed
|
||||
// coverage — if a message mutates mid-run (a quiz answer
|
||||
// merges in), the stored fingerprint won't match its new
|
||||
|
||||
@@ -0,0 +1,277 @@
|
||||
/**
|
||||
* Session deletion — the FIRST destructive operation on the append-only
|
||||
* graph ledgers (owner ruling 2026-09-22, wave 6 chunk A).
|
||||
*
|
||||
* Until now mergeFindings has been the sole writer; deletion is the second,
|
||||
* and it is held to the same discipline: PURE code over the storage ports
|
||||
* (core/ports.ts), no LLM judgment anywhere, deterministic and idempotent.
|
||||
* The caller (the DELETE /api/chats/[id] route through the server
|
||||
* orchestration) owns the cross-store choreography (chat record, jobs,
|
||||
* extraction wind-down); this module owns the LEDGERS.
|
||||
*
|
||||
* Two modes (owner-locked semantics):
|
||||
*
|
||||
* preserve-graph the chat's extraction bookkeeping dies — its coverage
|
||||
* rows and its legacy checkpoint lines — and NOTHING else:
|
||||
* nodes, edges, events, mappings stay byte-identical.
|
||||
* The graph keeps the session's contributions; the
|
||||
* snapshot simply no longer resolves the dead chatId to
|
||||
* a title (nodeSessions/nodeObservations filter unknown
|
||||
* ids at read time — no UI ghosting).
|
||||
*
|
||||
* delete-nodes "this session never happened": every trace of the
|
||||
* chat leaves the ledgers — its provenance points on
|
||||
* every node and edge line, its link lines (their
|
||||
* phrasings die with them), its quiz events and
|
||||
* observations, its mapping lines (the audit trail), its
|
||||
* coverage/checkpoint rows — and orphans die: a node
|
||||
* whose references all came from this chat disappears
|
||||
* entirely, pruned from the positions and embedding
|
||||
* ledgers too (dead members would break cluster hulls).
|
||||
*
|
||||
* Shared nodes survive automatically (the ruling): a node lives iff ANY
|
||||
* surviving reference remains — a provenance point from another chat or
|
||||
* notes source, or a surviving event (another session's quiz outcome /
|
||||
* observation) naming it. The create line of a surviving node is special:
|
||||
* name/statement/createdAt are the node's IDENTITY — the shared anchor
|
||||
* other sessions' link verdicts recognized — so they stay even when the
|
||||
* deleted chat created the node; but that session's phrasings (the line's
|
||||
* aliases) are stripped and its provenance points removed (owner ruling
|
||||
* 2026-09-23: all traces, identity survives).
|
||||
*
|
||||
* Not touched, by design:
|
||||
* - cluster-labels.jsonl — immutable history by contract, and the
|
||||
* namer is graph-global (tied to no session); core-survival renames
|
||||
* communities whose core shrank below half.
|
||||
* - imported-notes sources (src_…) — a different front door with its
|
||||
* own lifecycle (re-import dedupes by path hash); this wave deletes
|
||||
* CHATS.
|
||||
*
|
||||
* Resurrection safety: the deletion runs as ONE synchronous block (no
|
||||
* awaits — atomic vs the event loop, so no extraction append can
|
||||
* interleave), and the extraction pipeline re-checks the chat record
|
||||
* before each batch's merge (a deleted chat never merges). Both seams
|
||||
* together close every corrupt/resurrect path.
|
||||
*/
|
||||
|
||||
import type {
|
||||
CoverageEntry,
|
||||
GraphEdge,
|
||||
GraphNode,
|
||||
LedgerEvent,
|
||||
NodeMapping,
|
||||
SessionCheckpoint,
|
||||
} from "./contracts.ts";
|
||||
import type { GraphStore } from "./ports.ts";
|
||||
|
||||
/** The two deletion modes (owner-locked 2026-09-22). Machine-checkable on
|
||||
* the API as the required `mode` query param — no default, so no
|
||||
* accidental destructive choice. */
|
||||
export type ChatDeleteMode = "preserve-graph" | "delete-nodes";
|
||||
|
||||
/** What one deletion removed from the ledgers (the DELETE response's
|
||||
* stats; the UI can show "3 topics, 2 links removed" from this). */
|
||||
export interface ChatDeletionStats {
|
||||
/** Distinct nodes that died entirely (all their lines). */
|
||||
nodesRemoved: number;
|
||||
/** Edge assertion LINES removed (empty-provenance or dead endpoint). */
|
||||
edgesRemoved: number;
|
||||
/** Events removed (quiz outcomes + observations). */
|
||||
eventsRemoved: number;
|
||||
/** Mapping lines removed (the chat's audit trail). */
|
||||
mappingsRemoved: number;
|
||||
/** Coverage rows removed. */
|
||||
coverageRemoved: number;
|
||||
/** Checkpoint lines removed. */
|
||||
checkpointsRemoved: number;
|
||||
}
|
||||
|
||||
const EMPTY_STATS: ChatDeletionStats = {
|
||||
nodesRemoved: 0,
|
||||
edgesRemoved: 0,
|
||||
eventsRemoved: 0,
|
||||
mappingsRemoved: 0,
|
||||
coverageRemoved: 0,
|
||||
checkpointsRemoved: 0,
|
||||
};
|
||||
|
||||
/**
|
||||
* Remove one chat's traces from the graph ledgers. Synchronous by design
|
||||
* (the atomicity argument above); idempotent (a second run finds nothing
|
||||
* and returns zero stats).
|
||||
*/
|
||||
export function deleteChatTraces(graphStore: GraphStore, chatId: string, mode: ChatDeleteMode): ChatDeletionStats {
|
||||
if (mode !== "preserve-graph" && mode !== "delete-nodes") {
|
||||
throw new Error(`Unknown deletion mode: ${mode as string}`);
|
||||
}
|
||||
|
||||
// The bookkeeping rows die in BOTH modes — coverage and checkpoints
|
||||
// are extraction state, not graph content (owner semantics: even
|
||||
// preserve-graph deletes "the chat's coverage rows").
|
||||
const coverage = graphStore.readCoverage().filter((row) => row.chatId !== chatId);
|
||||
const checkpoints = graphStore.readCheckpoints().filter((row) => row.chatId !== chatId);
|
||||
const stats: ChatDeletionStats = {
|
||||
...EMPTY_STATS,
|
||||
coverageRemoved: graphStore.readCoverage().length - coverage.length,
|
||||
checkpointsRemoved: graphStore.readCheckpoints().length - checkpoints.length,
|
||||
};
|
||||
|
||||
if (mode === "preserve-graph") {
|
||||
if (stats.coverageRemoved > 0 || stats.checkpointsRemoved > 0) {
|
||||
graphStore.rewriteLedgers({ coverage, checkpoints });
|
||||
}
|
||||
return stats;
|
||||
}
|
||||
|
||||
// ── delete-nodes: the full purge ──────────────────────────────────────
|
||||
const nodeLines = graphStore.readNodes();
|
||||
const edgeLines = graphStore.readEdges();
|
||||
const events = graphStore.readEvents();
|
||||
const mappings = graphStore.readMappings();
|
||||
|
||||
// Does the chat touch the graph at all? (A never-extracted chat still
|
||||
// needs its coverage rows dropped above, but no ledger rewrite — keeps
|
||||
// mtimes stable so the graph revision only moves when something really
|
||||
// changed.)
|
||||
const touched =
|
||||
nodeLines.some((line) => line.provenance.some((pt) => pt.chatId === chatId)) ||
|
||||
edgeLines.some((line) => line.provenance.some((pt) => pt.chatId === chatId)) ||
|
||||
events.some((event) => event.chatId === chatId) ||
|
||||
mappings.some((m) => m.chatId === chatId);
|
||||
if (!touched) {
|
||||
if (stats.coverageRemoved > 0 || stats.checkpointsRemoved > 0) {
|
||||
graphStore.rewriteLedgers({ coverage, checkpoints });
|
||||
}
|
||||
return stats;
|
||||
}
|
||||
|
||||
// 1. Survival: a node lives iff a reference from ANY surviving source
|
||||
// remains — another chat/src's provenance point on any of its lines,
|
||||
// a surviving mapping line (notes-front-door nodes carry EMPTY
|
||||
// provenance: the file IS the anchor, recorded through the mapping
|
||||
// line), or a surviving event naming it. (Edge endpoints are deliberately
|
||||
// NOT survival references: an edge's asserting session always left
|
||||
// provenance on its endpoints, so endpoint-only liveness cannot
|
||||
// occur in a consistent ledger — and counting it would keep nodes
|
||||
// alive whose lines we would then drop, dangling the edge.)
|
||||
const survives = (points: ReadonlyArray<{ chatId: string }>): boolean =>
|
||||
points.some((pt) => pt.chatId !== chatId);
|
||||
const live = new Set<string>();
|
||||
for (const line of nodeLines) {
|
||||
if (survives(line.provenance)) live.add(line.id);
|
||||
}
|
||||
for (const mapping of mappings) {
|
||||
if (mapping.chatId !== chatId) live.add(mapping.graphNodeId);
|
||||
}
|
||||
for (const event of events) {
|
||||
if (event.chatId !== chatId && event.nodeId !== null) live.add(event.nodeId);
|
||||
}
|
||||
|
||||
// 2. Node lines. Per-line (each line is ONE extraction run's append, so
|
||||
// per-session alias provenance exists at line granularity):
|
||||
// dead node every line dies
|
||||
// untouched line kept verbatim
|
||||
// partially-deleted kept with the chat's points stripped
|
||||
// (defensive — single-run lines never mix chats)
|
||||
// all points deleted CREATE line: identity survives, aliases
|
||||
// stripped (owner ruling 2026-09-23), points
|
||||
// empty / LINK line: dies with its phrasings
|
||||
const outNodes: GraphNode[] = [];
|
||||
const seenIds = new Set<string>();
|
||||
for (const line of nodeLines) {
|
||||
if (!live.has(line.id)) continue; // the whole node dies
|
||||
const first = !seenIds.has(line.id);
|
||||
seenIds.add(line.id);
|
||||
const points = line.provenance.filter((pt) => pt.chatId !== chatId);
|
||||
if (points.length === line.provenance.length) {
|
||||
outNodes.push(line); // untouched by this chat
|
||||
continue;
|
||||
}
|
||||
if (points.length > 0) {
|
||||
outNodes.push({ ...line, provenance: points });
|
||||
continue;
|
||||
}
|
||||
if (first) {
|
||||
// The create line of a surviving node the deleted chat minted:
|
||||
// name/statement/createdAt are the shared identity other
|
||||
// sessions recognized — they stay; the session's phrasings and
|
||||
// provenance die (all traces, owner 2026-09-23).
|
||||
outNodes.push({ ...line, provenance: [], aliases: [] });
|
||||
}
|
||||
// else: the deleted chat's link line — dies with its phrasings.
|
||||
}
|
||||
|
||||
// 3. Edges: strip the chat's points; an assertion dies when its
|
||||
// provenance empties or either endpoint died IN THIS DELETION.
|
||||
// (Only nodes that existed and died count — an edge whose endpoints
|
||||
// never resolved as nodes is foreign data the deletion leaves alone:
|
||||
// destructive rewriting may not exceed the deleted chat's blast
|
||||
// radius.)
|
||||
const deadNodes = new Set([...new Set(nodeLines.map((line) => line.id))].filter((id) => !live.has(id)));
|
||||
const outEdges: GraphEdge[] = [];
|
||||
for (const line of edgeLines) {
|
||||
if (deadNodes.has(line.from) || deadNodes.has(line.to)) continue;
|
||||
const points = line.provenance.filter((pt) => pt.chatId !== chatId);
|
||||
// An assertion dies when THIS deletion empties its provenance — a
|
||||
// line that already had no points is foreign/legacy data, not this
|
||||
// chat's trace; it rides untouched.
|
||||
if (line.provenance.length > 0 && points.length === 0) continue;
|
||||
outEdges.push(points.length === line.provenance.length ? line : { ...line, provenance: points });
|
||||
}
|
||||
|
||||
// 4. Events, mappings: the chat's rows die outright.
|
||||
const outEvents = events.filter((event) => event.chatId !== chatId);
|
||||
const outMappings = mappings.filter((m) => m.chatId !== chatId);
|
||||
|
||||
stats.nodesRemoved = [...new Set(nodeLines.map((line) => line.id))].filter((id) => !live.has(id)).length;
|
||||
stats.edgesRemoved = edgeLines.length - outEdges.length;
|
||||
stats.eventsRemoved = events.length - outEvents.length;
|
||||
stats.mappingsRemoved = mappings.length - outMappings.length;
|
||||
|
||||
graphStore.rewriteLedgers({
|
||||
nodes: outNodes,
|
||||
edges: outEdges,
|
||||
events: outEvents,
|
||||
mappings: outMappings,
|
||||
coverage,
|
||||
checkpoints,
|
||||
});
|
||||
|
||||
// 5. Positions: prune dead nodes (stale resting spots would pin
|
||||
// nothing — but pruning keeps the ledger honest and the revision
|
||||
// moving for exactly the right reason).
|
||||
const positions = graphStore.readPositions();
|
||||
const knownNodeIds = new Set(nodeLines.map((line) => line.id));
|
||||
const prunedPositions = Object.fromEntries(
|
||||
Object.entries(positions).filter(([id]) => live.has(id) || !knownNodeIds.has(id)),
|
||||
);
|
||||
if (Object.keys(prunedPositions).length !== Object.keys(positions).length) {
|
||||
graphStore.writePositions(prunedPositions);
|
||||
}
|
||||
|
||||
// 6. Embeddings: prune dead vectors and dead cluster members — a dead
|
||||
// member in a hull list would break rendering (its position is
|
||||
// gone). Clusters emptied by pruning drop out; sub-minimum ones
|
||||
// vanish at the read-side filter. The model/dim headers stay.
|
||||
const embeddings = graphStore.readEmbeddings();
|
||||
const prunedVectors = Object.fromEntries(
|
||||
Object.entries(embeddings.vectors).filter(([id]) => live.has(id) || !knownNodeIds.has(id)),
|
||||
);
|
||||
const prunedClusters = embeddings.clusters
|
||||
.map((cluster) => ({ members: cluster.members.filter((id) => live.has(id) || !knownNodeIds.has(id)) }))
|
||||
.filter((cluster) => cluster.members.length > 0);
|
||||
if (
|
||||
Object.keys(prunedVectors).length !== Object.keys(embeddings.vectors).length ||
|
||||
prunedClusters.length !== embeddings.clusters.length ||
|
||||
prunedClusters.some((c, i) => c.members.length !== embeddings.clusters[i]!.members.length)
|
||||
) {
|
||||
graphStore.writeEmbeddings({
|
||||
...embeddings,
|
||||
vectors: prunedVectors,
|
||||
clusters: prunedClusters,
|
||||
updatedAt: new Date().toISOString(),
|
||||
});
|
||||
}
|
||||
|
||||
return stats;
|
||||
}
|
||||
@@ -60,6 +60,11 @@ export interface ChatStore {
|
||||
* Like saveSettings: a rename is NOT conversation activity — updatedAt
|
||||
* stays put, so sidebar order never churns on a rename. */
|
||||
renameChat(id: string, title: string): ChatRecord;
|
||||
/** Delete the session record entirely (session-deletion wave 6, owner
|
||||
* 2026-09-22). False when the id is unknown. The graph-ledger purge and
|
||||
* job cleanup are the caller's choreography (core/graph-deletion.ts +
|
||||
* the DELETE route), not the store's. */
|
||||
deleteChat(id: string): boolean;
|
||||
}
|
||||
|
||||
// ─── GraphStore — the append-only evidence ledgers (data/graph) ──────────────
|
||||
@@ -129,6 +134,23 @@ export interface GraphStore {
|
||||
readEmbeddings(): EmbeddingsLedger;
|
||||
/** Replace the whole ledger (embedding is a full-batch computation). */
|
||||
writeEmbeddings(ledger: EmbeddingsLedger): void;
|
||||
|
||||
/** THE DESTRUCTIVE SEAM (session-deletion wave 6, owner 2026-09-22 —
|
||||
* the first non-append operation on these ledgers): atomically
|
||||
* replace the full contents of any subset of the six rewritable
|
||||
* ledgers. Each provided array is written to a temp file and renamed
|
||||
* over the ledger (crash-safe: a torn write never replaces the
|
||||
* original); absent keys leave their ledger untouched. The pure
|
||||
* computation is core/graph-deletion.ts — the store only makes the
|
||||
* replacement atomic. */
|
||||
rewriteLedgers(next: {
|
||||
nodes?: GraphNode[];
|
||||
edges?: GraphEdge[];
|
||||
events?: LedgerEvent[];
|
||||
mappings?: NodeMapping[];
|
||||
coverage?: CoverageEntry[];
|
||||
checkpoints?: SessionCheckpoint[];
|
||||
}): void;
|
||||
}
|
||||
|
||||
// ─── JobStore — background sub-agent jobs (data/jobs) ─────────────────────────
|
||||
@@ -154,6 +176,11 @@ export interface JobStore {
|
||||
listJobs(chatId: string): JobRecord[];
|
||||
/** The job fulfilling a given tool part, if any (spawn-hook dedup). */
|
||||
findJobByToolCallId(chatId: string, toolCallId: string): JobRecord | null;
|
||||
/** Delete every job record for a chat — running or finished (session-
|
||||
* deletion wave 6). Returns how many files were removed. The deletion
|
||||
* route refuses while jobs are still running, so by the time this
|
||||
* fires every record is terminal. */
|
||||
deleteJobsForChat(chatId: string): number;
|
||||
}
|
||||
|
||||
// ─── SettingsStore — THE user settings record (settings-storage wave, 2026-09-19) ──
|
||||
|
||||
+102
-1
@@ -1,11 +1,112 @@
|
||||
import { stores } from "./stores.ts";
|
||||
import { abortExtraction, extractionStatuses } from "../agent/subagents/extraction.ts";
|
||||
import { deleteChatTraces, type ChatDeleteMode, type ChatDeletionStats } from "../core/graph-deletion.ts";
|
||||
import { titleFromPrompt } from "../core/contracts.ts";
|
||||
import { graphRevision } from "./graph.ts";
|
||||
import { stores } from "./stores.ts";
|
||||
import { isTurnRunning } from "./turn-liveness.ts";
|
||||
|
||||
/**
|
||||
* Server-side chat entries for the transport layer (app/api/chats*,
|
||||
* app/chat/[id]). Today these delegate straight to the ChatStore port; the
|
||||
* services stage carves the real orchestration behind this same surface.
|
||||
*
|
||||
* deleteChatSession (wave 6, session deletion — the FIRST destructive
|
||||
* operation on the graph ledgers) is the one real orchestration here:
|
||||
* gates → extraction wind-down → one synchronous deletion block. See
|
||||
* core/graph-deletion.ts for the ledger semantics and the atomicity
|
||||
* argument.
|
||||
*/
|
||||
|
||||
export const { createChat, getChat, listChats } = stores.chatStore;
|
||||
export { titleFromPrompt };
|
||||
export type { ChatDeleteMode, ChatDeletionStats } from "../core/graph-deletion.ts";
|
||||
|
||||
/** How long the wind-down wait may take before the caller gets a retryable
|
||||
* 503 (an aborted extraction ends at its next model-call boundary —
|
||||
* provider cancellation is normally sub-second, but a wedged provider
|
||||
* must never wedge deletion). */
|
||||
const WIND_DOWN_TIMEOUT_MS = 10_000;
|
||||
const WIND_DOWN_POLL_MS = 50;
|
||||
|
||||
/** What deleteChatSession did — the route maps it straight to HTTP. */
|
||||
export type ChatDeleteOutcome =
|
||||
| { ok: false; status: 404; code: "not_found"; error: string }
|
||||
| { ok: false; status: 409; code: "turn_in_flight" | "jobs_running"; error: string; jobIds: string[] }
|
||||
| { ok: false; status: 503; code: "extraction_winding_down"; error: string }
|
||||
| {
|
||||
ok: true;
|
||||
mode: ChatDeleteMode;
|
||||
stats: ChatDeletionStats;
|
||||
jobsRemoved: number;
|
||||
graphRevision: number;
|
||||
};
|
||||
|
||||
/**
|
||||
* Delete a session (owner rulings 2026-09-22/23): gates first, then the
|
||||
* purge. The owner-locked choreography:
|
||||
*
|
||||
* 1. GATES — a turn in flight or a running background job refuses with
|
||||
* 409 (they write the chat record and steer into it; deleting
|
||||
* mid-flight would corrupt the write-ahead flow). The UI retries once
|
||||
* work drains.
|
||||
* 2. EXTRACTION WIND-DOWN — the chat's own pipeline run is TRUE-
|
||||
* CANCELLED (abortExtraction: spend stops, nothing merges), then
|
||||
* awaited off the registry. A timeout is a retryable 503, never a
|
||||
* forced race.
|
||||
* 3. THE SYNC BLOCK — everything below runs without a single await:
|
||||
* no extraction append can interleave (the event loop never yields
|
||||
* mid-block), so the read-filter-write of the ledger rewrites is
|
||||
* atomic against the pipeline. Ledgers first, jobs next, the chat
|
||||
* record LAST (a crash mid-block leaves a deletable chat with a
|
||||
* purged graph — re-running DELETE fixes it — never a deleted chat
|
||||
* with live traces). The pipeline's per-batch liveness guard
|
||||
* (extraction.ts) closes the last window: a run that slipped past
|
||||
* the wind-down finds the chat gone at its merge and aborts with
|
||||
* nothing merged.
|
||||
*/
|
||||
export async function deleteChatSession(chatId: string, mode: ChatDeleteMode): Promise<ChatDeleteOutcome> {
|
||||
if (!stores.chatStore.getChat(chatId)) {
|
||||
return { ok: false, status: 404, code: "not_found", error: "No such session" };
|
||||
}
|
||||
if (isTurnRunning(chatId)) {
|
||||
return {
|
||||
ok: false,
|
||||
status: 409,
|
||||
code: "turn_in_flight",
|
||||
error: "A turn is running in this session — try again when it finishes",
|
||||
jobIds: [],
|
||||
};
|
||||
}
|
||||
const runningJobs = stores.jobStore.listJobs(chatId).filter((job) => job.status === "running");
|
||||
if (runningJobs.length > 0) {
|
||||
return {
|
||||
ok: false,
|
||||
status: 409,
|
||||
code: "jobs_running",
|
||||
error: "Background jobs are still running in this session — try again when they finish",
|
||||
jobIds: runningJobs.map((job) => job.id),
|
||||
};
|
||||
}
|
||||
if (extractionStatuses().some((run) => run.chatId === chatId)) {
|
||||
abortExtraction(chatId); // true cancellation — spend stops, nothing merges
|
||||
const deadline = Date.now() + WIND_DOWN_TIMEOUT_MS;
|
||||
while (extractionStatuses().some((run) => run.chatId === chatId)) {
|
||||
if (Date.now() > deadline) {
|
||||
return {
|
||||
ok: false,
|
||||
status: 503,
|
||||
code: "extraction_winding_down",
|
||||
error: "The session's extraction is still winding down — try again in a moment",
|
||||
};
|
||||
}
|
||||
await new Promise((resolve) => setTimeout(resolve, WIND_DOWN_POLL_MS));
|
||||
}
|
||||
}
|
||||
|
||||
// THE SYNC BLOCK — no awaits below (see the doc comment). Order:
|
||||
// ledgers → jobs → the chat record.
|
||||
const stats = deleteChatTraces(stores.graphStore, chatId, mode);
|
||||
const jobsRemoved = stores.jobStore.deleteJobsForChat(chatId);
|
||||
stores.chatStore.deleteChat(chatId);
|
||||
return { ok: true, mode, stats, jobsRemoved, graphRevision: graphRevision() };
|
||||
}
|
||||
|
||||
@@ -1,3 +1,5 @@
|
||||
import * as fs from "node:fs";
|
||||
import { EMBEDDINGS_FILE, LEDGER_FILES, POSITIONS_FILE } from "../../config.ts";
|
||||
import type { GraphSnapshot } from "../core/contracts.ts";
|
||||
import type { GraphCostSummary } from "../core/cost-summary.ts";
|
||||
import { graphCostSummary } from "../core/cost-summary.ts";
|
||||
@@ -35,3 +37,33 @@ export function graphCosts(): GraphCostSummary {
|
||||
.map((s) => ({ filePath: s.filePath, extractions: s.extractions! }));
|
||||
return graphCostSummary({ chats, sources, naming: stores.graphStore.readNamingRuns() });
|
||||
}
|
||||
|
||||
/** The graph's version stamp (session-deletion wave 6): the max mtime
|
||||
* across every graph data file — ledgers, positions, embeddings. Moves
|
||||
* on ANY graph write (merge append, settle, embed, or a deletion's
|
||||
* atomic rewrite), never moves on reads, and needs no bookkeeping of
|
||||
* its own: the fs IS the counter. Consumers poll it (the activity feed
|
||||
* carries it; the DELETE response returns it) to know clusters/layout
|
||||
* must refetch — the "graph changed underneath me" signal. */
|
||||
export function graphRevision(): number {
|
||||
let revision = 0;
|
||||
for (const file of [
|
||||
LEDGER_FILES.nodes,
|
||||
LEDGER_FILES.edges,
|
||||
LEDGER_FILES.events,
|
||||
LEDGER_FILES.mappings,
|
||||
LEDGER_FILES.sessions,
|
||||
LEDGER_FILES.coverage,
|
||||
LEDGER_FILES.clusterLabels,
|
||||
LEDGER_FILES.namingRuns,
|
||||
POSITIONS_FILE,
|
||||
EMBEDDINGS_FILE,
|
||||
]) {
|
||||
try {
|
||||
revision = Math.max(revision, fs.statSync(file).mtimeMs);
|
||||
} catch {
|
||||
/* absent — nothing has ever written it */
|
||||
}
|
||||
}
|
||||
return revision;
|
||||
}
|
||||
|
||||
@@ -21,6 +21,7 @@
|
||||
|
||||
import { extractionStatuses, type ExtractionPhase } from "../agent/subagents/extraction.ts";
|
||||
import { chatStore } from "../store/chats.ts";
|
||||
import { graphRevision } from "./graph.ts";
|
||||
import { listJobs } from "./jobs.ts";
|
||||
import type { JobRecord } from "../core/contracts.ts";
|
||||
|
||||
@@ -45,7 +46,13 @@ export interface ActivityExtraction {
|
||||
* the blob disappears when the process ends. Cost math is NOT done here:
|
||||
* raw usage rides on the records and the client folds it with the pure
|
||||
* helpers in core/prices.ts (transport stays thin). */
|
||||
export function activityFeed(): { jobs: ActivityJob[]; extractions: ActivityExtraction[] } {
|
||||
/** The dock's whole world + the graph's version stamp (wave 6 session
|
||||
* deletion): the payload carries graphRevision (max mtime across the
|
||||
* graph data files — see server/graph.ts) so any view can detect "the
|
||||
* graph changed underneath me" (a merge landed, a deletion purged) and
|
||||
* refetch clusters/layout. Reads never move it; the DELETE response
|
||||
* returns the same stamp. */
|
||||
export function activityFeed(): { jobs: ActivityJob[]; extractions: ActivityExtraction[]; graphRevision: number } {
|
||||
const chats = chatStore.listChats();
|
||||
const jobs: ActivityJob[] = [];
|
||||
for (const chat of chats) {
|
||||
@@ -63,5 +70,9 @@ export function activityFeed(): { jobs: ActivityJob[]; extractions: ActivityExtr
|
||||
}));
|
||||
// oldest-first on last activity: the stable blob order (ISO strings sort chronologically)
|
||||
jobs.sort((a, b) => a.updatedAt.localeCompare(b.updatedAt));
|
||||
return { jobs, extractions: extractions.sort((a, b) => a.startedAt - b.startedAt) };
|
||||
return {
|
||||
jobs,
|
||||
extractions: extractions.sort((a, b) => a.startedAt - b.startedAt),
|
||||
graphRevision: graphRevision(),
|
||||
};
|
||||
}
|
||||
|
||||
@@ -129,6 +129,19 @@ function renameChat(id: string, title: string): ChatRecord {
|
||||
return record;
|
||||
}
|
||||
|
||||
/** Delete the session record file entirely (session-deletion wave 6,
|
||||
* owner 2026-09-22). False when the id is unknown — the route turns that
|
||||
* into a 404. The record's graph traces and jobs are the route's
|
||||
* choreography (core/graph-deletion.ts), not the store's. */
|
||||
function deleteChat(id: string): boolean {
|
||||
try {
|
||||
fs.unlinkSync(chatFile(id));
|
||||
return true;
|
||||
} catch {
|
||||
return false; // never existed, already deleted, or unreadable — same answer
|
||||
}
|
||||
}
|
||||
|
||||
/** Persist the session plan tree (plan tools call this in execute). */
|
||||
function saveTree(id: string, tree: PlanTree): void {
|
||||
const record = getChat(id);
|
||||
@@ -147,6 +160,7 @@ export const chatStore: ChatStore = {
|
||||
saveTree,
|
||||
saveSettings,
|
||||
renameChat,
|
||||
deleteChat,
|
||||
appendTurnUsage,
|
||||
appendExtractionUsage,
|
||||
};
|
||||
|
||||
@@ -260,6 +260,49 @@ export const graphStore: GraphStore = {
|
||||
writeEmbeddings(ledger: EmbeddingsLedger): void {
|
||||
writeEmbeddingsLedger(ledger);
|
||||
},
|
||||
|
||||
/** THE DESTRUCTIVE SEAM (wave 6 session deletion): atomic full-content
|
||||
* replacement per provided ledger — write a uniquely-named temp file
|
||||
* beside the ledger, then rename over it (POSIX-atomic: a crash mid-
|
||||
* write leaves the original ledger and an orphan .tmp-*, never a torn
|
||||
* ledger). Empty arrays write an empty file — a purged ledger reads
|
||||
* as "nothing yet", same as never-emitted. */
|
||||
rewriteLedgers(next: {
|
||||
nodes?: GraphNode[];
|
||||
edges?: GraphEdge[];
|
||||
events?: LedgerEvent[];
|
||||
mappings?: NodeMapping[];
|
||||
coverage?: CoverageEntry[];
|
||||
checkpoints?: SessionCheckpoint[];
|
||||
}): void {
|
||||
const files = {
|
||||
nodes: LEDGER_FILES.nodes,
|
||||
edges: LEDGER_FILES.edges,
|
||||
events: LEDGER_FILES.events,
|
||||
mappings: LEDGER_FILES.mappings,
|
||||
coverage: LEDGER_FILES.coverage,
|
||||
checkpoints: LEDGER_FILES.sessions,
|
||||
} as const;
|
||||
for (const [key, records] of Object.entries(next) as [keyof typeof files, unknown[]][]) {
|
||||
const file = files[key];
|
||||
fs.mkdirSync(path.dirname(file), { recursive: true });
|
||||
const tmp = `${file}.tmp-${crypto.randomUUID().slice(0, 8)}`;
|
||||
try {
|
||||
// JSONL: one record per line, trailing newline — a reader
|
||||
// must see exactly what appendLine would have written.
|
||||
const body = records.map((record) => JSON.stringify(record)).join("\n") + (records.length > 0 ? "\n" : "");
|
||||
fs.writeFileSync(tmp, body, "utf-8");
|
||||
fs.renameSync(tmp, file);
|
||||
} catch (err) {
|
||||
try {
|
||||
fs.unlinkSync(tmp);
|
||||
} catch {
|
||||
/* the rename either already happened or the tmp never existed */
|
||||
}
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
/** positions.json — { positions, updatedAt }. Read-modify-write, NOT
|
||||
|
||||
@@ -79,10 +79,28 @@ function findJobByToolCallId(chatId: string, toolCallId: string): JobRecord | nu
|
||||
return listJobs(chatId).find((j) => j.toolCallId === toolCallId) ?? null;
|
||||
}
|
||||
|
||||
/** Delete every job record file for a chat (session-deletion wave 6) —
|
||||
* running or finished, they are the chat's records and die with it.
|
||||
* Returns how many files were removed. The deletion route refuses while
|
||||
* jobs are still running, so every record here is terminal. */
|
||||
function deleteJobsForChat(chatId: string): number {
|
||||
let removed = 0;
|
||||
for (const job of listJobs(chatId)) {
|
||||
try {
|
||||
fs.unlinkSync(jobFile(job.id));
|
||||
removed++;
|
||||
} catch {
|
||||
/* already gone — the count is best-effort truth */
|
||||
}
|
||||
}
|
||||
return removed;
|
||||
}
|
||||
|
||||
export const jobStore: JobStore = {
|
||||
createJob,
|
||||
getJob,
|
||||
updateJob,
|
||||
listJobs,
|
||||
findJobByToolCallId,
|
||||
deleteJobsForChat,
|
||||
};
|
||||
|
||||
@@ -135,6 +135,16 @@ function memoryLedgers() {
|
||||
for (const [id, v] of Object.entries(next.vectors)) embeddings.vectors.set(id, [...v]);
|
||||
embeddings.clusters = next.clusters.map((c) => [...c.members]);
|
||||
},
|
||||
// The destructive seam (wave 6 session deletion) — mirrors the real
|
||||
// store: replace the provided ledgers' full contents.
|
||||
rewriteLedgers: (next) => {
|
||||
if (next.nodes) nodes.splice(0, nodes.length, ...next.nodes.map((n) => ({ ...n, provenance: [...n.provenance], aliases: [...n.aliases] })));
|
||||
if (next.edges) edges.splice(0, edges.length, ...next.edges.map((e) => ({ ...e, provenance: [...e.provenance] })));
|
||||
if (next.events) events.splice(0, events.length, ...next.events.map((e) => ({ ...e })));
|
||||
if (next.mappings) mappings.splice(0, mappings.length, ...next.mappings.map((m) => ({ ...m })));
|
||||
if (next.coverage) coverage.splice(0, coverage.length, ...next.coverage.map((c) => ({ ...c })));
|
||||
if (next.checkpoints) checkpoints.splice(0, checkpoints.length, ...next.checkpoints.map((c) => ({ ...c })));
|
||||
},
|
||||
} satisfies GraphStore;
|
||||
}
|
||||
|
||||
@@ -1253,3 +1263,45 @@ describe("the chunked pipeline (extraction coverage)", () => {
|
||||
assert.equal(coverageOf(messages(), ledgers.readCoverage(), chatId).uncoveredCount, 0, "re-covered");
|
||||
});
|
||||
});
|
||||
|
||||
// ─── session deletion mid-run (wave 6) ─────────────────────────────────────
|
||||
|
||||
describe("the session-deletion guard (chat deleted mid-run)", () => {
|
||||
it("a run whose chat dies mid-extraction aborts at the merge with nothing merged, checkpointed, or billed", async () => {
|
||||
const { chatId } = fixtureChat();
|
||||
const ledgers = memoryLedgers();
|
||||
|
||||
// The chat record is deleted DURING the audit model call — the worst
|
||||
// window: findings already spent, the merge next.
|
||||
const pipeline = createExtractionPipeline({
|
||||
chatStore,
|
||||
graphStore: ledgers,
|
||||
embedder: fakeEmbedder,
|
||||
extractor: submitModel("submit_findings", FINDINGS),
|
||||
auditor: submitModel("submit_review", { propositions: FINDINGS.propositions, edges: [], attribution: { quiz: {} }, dropped: [] }, () => chatStore.deleteChat(chatId)),
|
||||
labeler: submitModel("submit_labels", { labels: [] }),
|
||||
});
|
||||
const stats = await pipeline.runExtraction(chatId);
|
||||
|
||||
// The abort rides the existing abort path: info, not error; zero
|
||||
// emissions (stats present but empty — nothing merged).
|
||||
assert.ok(stats);
|
||||
assert.equal(stats.nodes, 0);
|
||||
assert.equal(stats.edges, 0);
|
||||
assert.equal(stats.events, 0);
|
||||
|
||||
// Nothing merged, nothing checkpointed — the deleted chat leaves no
|
||||
// trace for a later snapshot to resurrect.
|
||||
assert.equal(ledgers.readNodes().length, 0);
|
||||
assert.equal(ledgers.readEdges().length, 0);
|
||||
assert.equal(ledgers.readEvents().length, 0);
|
||||
assert.equal(ledgers.readMappings().length, 0);
|
||||
assert.equal(ledgers.readCoverage().length, 0);
|
||||
assert.equal(ledgers.readCheckpoints().length, 0);
|
||||
|
||||
// The run is off the registry (the finally always cleans up).
|
||||
assert.equal(extractionStatuses().some((run) => run.chatId === chatId), false);
|
||||
// And its partial spend died with the chat — no usage row on a ghost.
|
||||
assert.equal(chatStore.getChat(chatId), null);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -634,3 +634,211 @@ describe("graph ledger store", () => {
|
||||
assert.deepEqual(merged.provenance.map((p) => p.messageId), ["m1", "m2"]);
|
||||
});
|
||||
});
|
||||
|
||||
// ─── session deletion (wave 6 — the first destructive ledger operation) ─────
|
||||
|
||||
import { deleteChatTraces, type ChatDeletionStats } from "../src/core/graph-deletion.ts";
|
||||
import { deleteChatSession } from "../src/server/chats.ts";
|
||||
import { beginTurn, endTurn } from "../src/server/turn-liveness.ts";
|
||||
import { jobStore } from "../src/store/jobs.ts";
|
||||
|
||||
describe("session deletion (deleteChatTraces + deleteChatSession, wave 6)", () => {
|
||||
/** Two-session scenario: dA creates the shared node X + the orphan Y and
|
||||
* asserts X→Y; dB links X (its own phrasings), creates Z, asserts X→Z.
|
||||
* Deleting dA must: keep X (dB's link line survives, dA's create-line
|
||||
* aliases stripped — the identity stays), kill Y (orphan), keep Z and
|
||||
* dB's edge, kill dA's events/mappings/coverage/checkpoints. */
|
||||
function buildTwoSessionScenario() {
|
||||
const dA = fixtureChat("Deletion session A", [
|
||||
user("du1", "teach me the deletion topic"),
|
||||
assistant("da1", [
|
||||
quizPart(
|
||||
"d-call-1",
|
||||
{ question: "DQ1", options: [{ label: "a" }, { label: "b" }], correctAnswer: "a", explanation: "e" },
|
||||
answer({ questionId: "d-call-1", questionText: "DQ1 text", correct: true, answeredAt: "2026-09-23T00:00:00.000Z" }),
|
||||
),
|
||||
]),
|
||||
]);
|
||||
const auditA: AuditResult = {
|
||||
propositions: [
|
||||
{ id: "p1", name: "Shared core", statement: "Shared core statement", aliases: ["shared feel"], messages: ["du1"], evidence: ["e"], understanding: "solid" },
|
||||
{ id: "p2", name: "Solo fact", statement: "Solo fact statement", aliases: ["solo feel"], messages: ["du1"], evidence: ["e"] },
|
||||
],
|
||||
edges: [{ from: "p1", to: "p2", type: "follows", messages: ["du1"], evidence: ["e"] }],
|
||||
attribution: { quiz: { "d-call-1": "p1" } },
|
||||
dropped: [],
|
||||
};
|
||||
mergeFindings(dA.id, auditA, graphDeps, sessionSource(dA.id));
|
||||
// Resolve through THIS session's mappings — the shared ledger holds
|
||||
// lookalike statements from earlier tests, so statement-lookup would
|
||||
// link dB to the wrong node.
|
||||
const mappedId = (sourceId: string): string =>
|
||||
graphStore.readMappings().find((m) => m.chatId === dA.id && m.sourceId === sourceId)!.graphNodeId;
|
||||
const xId = mappedId("p1");
|
||||
const yId = mappedId("p2");
|
||||
|
||||
const dB = fixtureChat("Deletion session B", [
|
||||
user("eu1", "more on the shared core"),
|
||||
assistant("eb1", [
|
||||
quizPart(
|
||||
"e-call-1",
|
||||
{ question: "EQ1", options: [{ label: "a" }, { label: "b" }], correctAnswer: "a", explanation: "e" },
|
||||
answer({ questionId: "e-call-1", questionText: "EQ1 text", correct: false, answeredAt: "2026-09-23T00:01:00.000Z" }),
|
||||
),
|
||||
]),
|
||||
]);
|
||||
const auditB: AuditResult = {
|
||||
propositions: [
|
||||
{ id: "q1", name: "Shared again", statement: "Shared core, rephrased", aliases: ["B phrasing"], messages: ["eu1"], evidence: ["e"], linkTo: xId, understanding: "shaky" },
|
||||
{ id: "q2", name: "B extra", statement: "B extra statement", aliases: ["b extra feel"], messages: ["eu1"], evidence: ["e"] },
|
||||
],
|
||||
edges: [{ from: "q1", to: "q2", type: "follows", messages: ["eu1"], evidence: ["e"] }],
|
||||
attribution: { quiz: { "e-call-1": "q1" } },
|
||||
dropped: [],
|
||||
};
|
||||
mergeFindings(dB.id, auditB, graphDeps, sessionSource(dB.id));
|
||||
const zId = graphStore.readMappings().find((m) => m.chatId === dB.id && m.sourceId === "q2")!.graphNodeId;
|
||||
|
||||
// Coverage rows (both chats) + positions + embeddings garnish — the
|
||||
// deletion prunes all three ledgers.
|
||||
for (const chat of [dA, dB]) {
|
||||
for (let i = 0; i < 2; i++) {
|
||||
graphStore.appendCoverage({ chatId: chat.id, fp: `${chat.id}-${i}`, tokens: 10, foldedAt: "2026-09-23T00:02:00.000Z" });
|
||||
}
|
||||
}
|
||||
graphStore.writePositions({ ...graphStore.readPositions(), [xId]: { x: 1, y: 1 }, [yId]: { x: 2, y: 2 }, [zId]: { x: 3, y: 3 } });
|
||||
const emb = graphStore.readEmbeddings();
|
||||
graphStore.writeEmbeddings({
|
||||
...emb,
|
||||
vectors: { ...emb.vectors, [xId]: [1, 0], [yId]: [0, 1], [zId]: [1, 1] },
|
||||
clusters: [...emb.clusters, { members: [xId, yId, zId] }],
|
||||
updatedAt: "2026-09-23T00:03:00.000Z",
|
||||
});
|
||||
return { dA, dB, xId, yId, zId };
|
||||
}
|
||||
|
||||
it("delete-nodes: the shared node survives with the other session's content; the orphan dies; the creator's aliases are stripped (owner ruling 2026-09-23)", () => {
|
||||
const { dA, dB, xId, yId, zId } = buildTwoSessionScenario();
|
||||
const zLineBefore = JSON.stringify(graphStore.readNodes().find((n) => n.id === zId));
|
||||
|
||||
const stats = deleteChatTraces(graphStore, dA.id, "delete-nodes");
|
||||
assert.deepEqual(stats, {
|
||||
nodesRemoved: 1,
|
||||
edgesRemoved: 1,
|
||||
eventsRemoved: 2,
|
||||
mappingsRemoved: 2,
|
||||
coverageRemoved: 2,
|
||||
checkpointsRemoved: 1,
|
||||
} satisfies ChatDeletionStats);
|
||||
|
||||
const graph = getGraph(graphStore);
|
||||
// X survives: identity (name/statement/createdAt from the create
|
||||
// line) intact, dA's aliases + provenance gone, dB's phrasings in.
|
||||
const x = graph.nodes.find((n) => n.id === xId)!;
|
||||
assert.equal(x.statement, "Shared core statement", "the shared identity survives");
|
||||
assert.equal(x.name, "Shared core");
|
||||
assert.ok(!x.aliases.includes("shared feel"), "the deleted creator's phrasings are stripped (owner ruling)");
|
||||
assert.ok(x.aliases.includes("B phrasing") && x.aliases.includes("Shared core, rephrased"));
|
||||
assert.deepEqual(x.provenance, [{ chatId: dB.id, messageId: "eu1" }], "only dB's provenance remains");
|
||||
// Y (the orphan) is gone entirely.
|
||||
assert.equal(graph.nodes.some((n) => n.id === yId), false);
|
||||
assert.equal(graphStore.readNodes().some((n) => n.id === yId), false);
|
||||
// Z (dB-only) is untouched, byte-identical.
|
||||
assert.equal(JSON.stringify(graphStore.readNodes().find((n) => n.id === zId)), zLineBefore);
|
||||
// Edges: dA's assertion X→Y died; dB's X→Z survived.
|
||||
const scoped = scopedGraph([dA.id, dB.id]);
|
||||
assert.deepEqual(scoped.edges, [{ from: xId, to: zId, type: "follows", provenance: [{ chatId: dB.id, messageId: "eu1" }] }]);
|
||||
// Events: only dB's quiz + observation remain.
|
||||
assert.deepEqual(scoped.events.map((e) => [e.kind, e.chatId === dB.id]), [
|
||||
["miss", true],
|
||||
["observation", true],
|
||||
]);
|
||||
// Mappings: dA's audit trail died; dB's stays.
|
||||
const mappings = graphStore.readMappings().filter((m) => [dA.id, dB.id].includes(m.chatId));
|
||||
assert.deepEqual(mappings, [{ chatId: dB.id, sourceId: "q1", graphNodeId: xId }, { chatId: dB.id, sourceId: "q2", graphNodeId: zId }]);
|
||||
// Positions/embeddings: the orphan pruned everywhere.
|
||||
const positions = graphStore.readPositions();
|
||||
assert.equal(positions[yId], undefined);
|
||||
assert.deepEqual(positions[xId], { x: 1, y: 1 });
|
||||
const emb = graphStore.readEmbeddings();
|
||||
assert.equal(emb.vectors[yId], undefined);
|
||||
assert.ok(emb.vectors[xId] && emb.vectors[zId]);
|
||||
assert.deepEqual(emb.clusters.at(-1), { members: [xId, zId] }, "dead members pruned from the hull");
|
||||
// The snapshot resolves X to dB only — the deleted chat left no ghost.
|
||||
const snapshot = graphSnapshot(graphDeps);
|
||||
assert.deepEqual(snapshot.nodeSessions[xId], [dB.id]);
|
||||
assert.deepEqual(snapshot.nodeObservations[xId], { [dB.id]: "shaky" });
|
||||
assert.ok(snapshot.sessions[dB.id] && !snapshot.sessions[dA.id]);
|
||||
// Atomic rewrites left no temp files, and appends still work.
|
||||
assert.equal(fs.readdirSync(PATHS.graph).filter((f) => f.includes(".tmp-")).length, 0);
|
||||
const eventsBefore = graphStore.readEvents().length;
|
||||
graphStore.appendEvent({ nodeId: null, kind: "correct", chatId: "chat_del_append_probe", at: "2026-09-23T00:04:00.000Z" });
|
||||
assert.equal(graphStore.readEvents().length, eventsBefore + 1);
|
||||
// Idempotent: a second run finds nothing.
|
||||
assert.deepEqual(deleteChatTraces(graphStore, dA.id, "delete-nodes"), { ...stats, nodesRemoved: 0, edgesRemoved: 0, eventsRemoved: 0, mappingsRemoved: 0, coverageRemoved: 0, checkpointsRemoved: 0 } satisfies ChatDeletionStats);
|
||||
});
|
||||
|
||||
it("preserve-graph: only the extraction bookkeeping dies — the graph ledgers are byte-identical", () => {
|
||||
const { dA, dB, xId, yId, zId } = buildTwoSessionScenario();
|
||||
const before = {
|
||||
nodes: graphStore.readNodes(),
|
||||
edges: graphStore.readEdges(),
|
||||
events: graphStore.readEvents(),
|
||||
mappings: graphStore.readMappings(),
|
||||
positions: graphStore.readPositions(),
|
||||
embeddings: graphStore.readEmbeddings(),
|
||||
};
|
||||
const stats = deleteChatTraces(graphStore, dA.id, "preserve-graph");
|
||||
assert.deepEqual(stats, {
|
||||
nodesRemoved: 0,
|
||||
edgesRemoved: 0,
|
||||
eventsRemoved: 0,
|
||||
mappingsRemoved: 0,
|
||||
coverageRemoved: 2,
|
||||
checkpointsRemoved: 1,
|
||||
} satisfies ChatDeletionStats);
|
||||
assert.deepEqual(graphStore.readNodes(), before.nodes);
|
||||
assert.deepEqual(graphStore.readEdges(), before.edges);
|
||||
assert.deepEqual(graphStore.readEvents(), before.events);
|
||||
assert.deepEqual(graphStore.readMappings(), before.mappings);
|
||||
assert.deepEqual(graphStore.readPositions(), before.positions);
|
||||
assert.deepEqual(graphStore.readEmbeddings(), before.embeddings);
|
||||
assert.equal(graphStore.readCoverage().some((row) => row.chatId === dA.id), false);
|
||||
assert.equal(graphStore.readCoverage().some((row) => row.chatId === dB.id), true);
|
||||
void xId; void yId; void zId;
|
||||
});
|
||||
|
||||
it("deleteChatSession: the orchestration's gates and the sync block", async () => {
|
||||
// 404 — unknown chat.
|
||||
assert.deepEqual(await deleteChatSession("chat_missing_delete", "delete-nodes"), { ok: false, status: 404, code: "not_found", error: "No such session" });
|
||||
|
||||
const { dA } = buildTwoSessionScenario();
|
||||
// 409 — a turn in flight.
|
||||
beginTurn(dA.id);
|
||||
const turnedAway = await deleteChatSession(dA.id, "delete-nodes");
|
||||
assert.deepEqual(turnedAway, { ok: false, status: 409, code: "turn_in_flight", error: "A turn is running in this session — try again when it finishes", jobIds: [] });
|
||||
endTurn(dA.id);
|
||||
// 409 — running background jobs.
|
||||
const job = jobStore.createJob({ kind: "research", chatId: dA.id, toolCallId: "del-call-1" });
|
||||
const jobsBlocked = await deleteChatSession(dA.id, "delete-nodes");
|
||||
assert.ok(!jobsBlocked.ok && jobsBlocked.status === 409, "refused with 409");
|
||||
if (jobsBlocked.code === "jobs_running") assert.deepEqual(jobsBlocked.jobIds, [job.id]);
|
||||
assert.equal(jobStore.deleteJobsForChat(dA.id), 1, "test cleanup — the job file is gone");
|
||||
|
||||
// Success — a terminal job rides along; the chat record dies last.
|
||||
const doneJob = jobStore.createJob({ kind: "research", chatId: dA.id, toolCallId: "del-call-2" });
|
||||
jobStore.updateJob(doneJob.id, { status: "done", activity: "delivered" });
|
||||
const outcome = await deleteChatSession(dA.id, "delete-nodes");
|
||||
assert.equal(outcome.ok, true);
|
||||
if (outcome.ok) {
|
||||
assert.equal(outcome.mode, "delete-nodes");
|
||||
assert.equal(outcome.stats.nodesRemoved, 1);
|
||||
assert.equal(outcome.jobsRemoved, 1);
|
||||
assert.ok(outcome.graphRevision > 0, "the version stamp moved");
|
||||
}
|
||||
assert.equal(chatStore.getChat(dA.id), null, "the chat record is gone");
|
||||
assert.equal(jobStore.getJob(doneJob.id), null, "the chat's job records are gone");
|
||||
// And a second call is an honest 404.
|
||||
assert.deepEqual(await deleteChatSession(dA.id, "delete-nodes"), { ok: false, status: 404, code: "not_found", error: "No such session" });
|
||||
});
|
||||
});
|
||||
|
||||
@@ -108,6 +108,7 @@ function fakeJobStore(): JobStore {
|
||||
},
|
||||
listJobs: () => [...jobs.values()],
|
||||
findJobByToolCallId: () => null,
|
||||
deleteJobsForChat: () => 0, // the drop tests never delete
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user