Storage ports: ChatStore/GraphStore/JobStore + adapters + core inversion (stage 3)

Per-entity semantic ports (src/core/ports.ts), one adapter family
(src/store/*, fs JSON/JSONL), exactly one composition point
(src/server/stores.ts). Dependency direction is now machine-checked:
adapters implement core interfaces; core never imports an adapter.

The inversion:
- core/graph.ts (emitChat/getGraph/graphSnapshot/foldStaleChats) is now
  pure — it takes the storage ports as explicit parameters (GraphDeps).
  No store imports; newGraphNodeId is local; node id format unchanged.
- core/graph-context.ts buildGraphContext() no longer defaults to the
  live ledgers: the chat-handler hands in getGraph(graphStore) per turn.
- store adapters export exactly one object each implementing their port
  (chatStore/graphStore/jobStore); bodies otherwise verbatim.
  NodeMapping + SessionCheckpoint moved store/graph -> core/contracts
  (they ARE contract shapes); CreateJobInit/JobPatch live in ports.
- titleFromPrompt moved store/chats -> core/contracts (pure helper,
  planNodeStatus precedent). Store modules now contain persistence only.
- server/stores.ts is the composition root; server/{chats,graph,jobs}.ts
  and chat-handler wire from it; agent (plan tools, sub-agent runner)
  call the port objects. The shell surface (@/src/server exports) is
  unchanged.

Lint law extended: the whole of src/core is now a purity zone (was a
file glob with a graph/graph-context exemption). Verified it fires on
core->store imports; tsc clean, 190/190 tests, eslint clean, prod build
clean (prerender 6/6). Tests pass deps explicitly — graph.test uses the
same fs-adapter pair stores.ts wires in production; graph-context.test
keeps its in-memory ledgers as a GraphStore implementation.

src/core/ports.ts

@@ -0,0 +1,95 @@
+/**
+ * Storage ports (the hexagonal seams — vision §1 "storage stays swappable").
+ *
+ * One port per ENTITY, with domain operations — never one generic
+ * key/value interface. Core and the service layer that orbits it code
+ * against these types only; concrete adapters live in src/store/ (fs
+ * JSON/JSONL today, SQLite drop-in later) and are wired exactly once, in
+ * the composition root (src/server/stores.ts). Dependencies point one way:
+ * adapters may import core; core NEVER imports an adapter.
+ */
+
+import type { UIMessage } from "ai";
+import type {
+	ChatRecord,
+	ChatSummary,
+	GraphEdge,
+	GraphNode,
+	JobKind,
+	JobRecord,
+	LedgerEvent,
+	NodeMapping,
+	PlanTree,
+	SessionCheckpoint,
+} from "./contracts.ts";
+
+// ─── ChatStore — the session record's home (data/chats) ─────────────────────
+
+export interface ChatStore {
+	/** Create a session record (persisted immediately). */
+	createChat(title: string): ChatRecord;
+	/** The full record, or null if unknown id / corrupt file. */
+	getChat(id: string): ChatRecord | null;
+	/** All sessions, newest activity first (the sidebar's list view). */
+	listChats(): ChatSummary[];
+	/** Persist the full message list (client state + new response) after a turn. */
+	saveMessages(id: string, messages: UIMessage[]): void;
+	/** Persist the session plan tree (plan tools call this in execute). */
+	saveTree(id: string, tree: PlanTree): void;
+}
+
+// ─── GraphStore — the append-only evidence ledgers (data/graph) ──────────────
+// v1 surface = the five JSONL ledgers (nodes / edges / events / mappings /
+// sessions). Reads return the raw append-order lines; merging edge assertions
+// by (from, to, type) is DERIVED in core/graph.ts — the store never decides.
+// The extraction pipeline (next stage) becomes the sole writer; this read
+// surface stays.
+
+export interface GraphStore {
+	/** Append one GraphNode (ids are unique — no merging needed). */
+	appendNode(node: GraphNode): void;
+	/** Raw node lines in append order. */
+	readNodes(): GraphNode[];
+
+	/** Append one edge ASSERTION (a second session asserting the same
+	 *  (from, to, type) appends another line; readers merge). */
+	appendEdge(assertion: GraphEdge): void;
+	readEdges(): GraphEdge[];
+
+	/** Append one quiz outcome / taught event. */
+	appendEvent(event: LedgerEvent): void;
+	readEvents(): LedgerEvent[];
+
+	/** Append one identity-map line (chat's tree node → graph node). */
+	appendMapping(mapping: NodeMapping): void;
+	readMappings(): NodeMapping[];
+
+	/** Append one emission checkpoint. */
+	appendCheckpoint(checkpoint: SessionCheckpoint): void;
+	readCheckpoints(): SessionCheckpoint[];
+}
+
+// ─── JobStore — background sub-agent jobs (data/jobs) ─────────────────────────
+
+export interface CreateJobInit {
+	kind: JobKind;
+	chatId: string;
+	toolCallId: string;
+	/** First activity line (defaults to "starting"). */
+	activity?: string;
+}
+
+/** Mergeable fields — identity (id, kind, chatId, toolCallId, createdAt) is immutable. */
+export type JobPatch = Partial<Omit<JobRecord, "id" | "kind" | "chatId" | "toolCallId" | "createdAt">>;
+
+export interface JobStore {
+	/** Create a running job (keyed by toolCallId for spawn dedup). */
+	createJob(init: CreateJobInit): JobRecord;
+	getJob(id: string): JobRecord | null;
+	/** Merge a patch into the record; null if unknown id. */
+	updateJob(id: string, patch: JobPatch): JobRecord | null;
+	/** All jobs for a chat, newest activity first. */
+	listJobs(chatId: string): JobRecord[];
+	/** The job fulfilling a given tool part, if any (spawn-hook dedup). */
+	findJobByToolCallId(chatId: string, toolCallId: string): JobRecord | null;
+}