@namzu/sdk 43.0.0 → 44.0.0

package/src/store/memory/memory.ts

@@ -12,6 +12,12 @@ import type {
 import { assertMemoryStatus } from '../../types/memory/index.js'
 import { generateMemoryId } from '../../utils/id.js'
 import { InMemoryMemoryIndex, searchMemoryEntries } from './index.js'
+import {
+	MemoryNameConflictError,
+	assertOptionalMemoryFields,
+	nameHolder,
+	withOptionalFields,
+} from './naming.js'
 
 export class InMemoryMemoryStore implements MemoryStore {
 	private content = new Map<string, MemoryContent>()
@@ -20,18 +26,26 @@ export class InMemoryMemoryStore implements MemoryStore {
 	async create(
 		params: CreateMemoryParams,
 	): Promise<{ entry: MemoryIndexEntry; content: MemoryContent }> {
+		assertOptionalMemoryFields(params)
+		if (params.name !== undefined) {
+			const holder = nameHolder(this.index.allEntries(), params.name)
+			if (holder) throw new MemoryNameConflictError(params.name, holder.id)
+		}
 		const id = generateMemoryId()
 		const now = Date.now()
 
-		const entry: MemoryIndexEntry = {
-			id,
-			title: params.title,
-			summary: params.summary,
-			tags: params.tags ? [...params.tags] : [],
-			status: 'active',
-			createdAt: now,
-			updatedAt: now,
-		}
+		const entry: MemoryIndexEntry = withOptionalFields(
+			{
+				id,
+				title: params.title,
+				summary: params.summary,
+				tags: params.tags ? [...params.tags] : [],
+				status: 'active',
+				createdAt: now,
+				updatedAt: now,
+			},
+			params,
+		)
 
 		const memoryContent: MemoryContent = {
 			id,
@@ -58,19 +72,27 @@ export class InMemoryMemoryStore implements MemoryStore {
 
 	async update(id: MemoryId, updates: UpdateMemoryParams): Promise<MemoryIndexEntry | undefined> {
 		if (updates.status !== undefined) assertMemoryStatus(updates.status)
+		assertOptionalMemoryFields(updates)
 		const existing = this.index.getEntry(id)
 		if (!existing) return undefined
+		if (updates.name !== undefined) {
+			const holder = nameHolder(this.index.allEntries(), updates.name, id)
+			if (holder) throw new MemoryNameConflictError(updates.name, holder.id)
+		}
 
 		const now = Date.now()
 
-		const updated: MemoryIndexEntry = {
-			...existing,
-			title: updates.title ?? existing.title,
-			summary: updates.summary ?? existing.summary,
-			tags: updates.tags ? [...updates.tags] : existing.tags,
-			status: updates.status ?? existing.status,
-			updatedAt: now,
-		}
+		const updated: MemoryIndexEntry = withOptionalFields(
+			{
+				...existing,
+				title: updates.title ?? existing.title,
+				summary: updates.summary ?? existing.summary,
+				tags: updates.tags ? [...updates.tags] : existing.tags,
+				status: updates.status ?? existing.status,
+				updatedAt: now,
+			},
+			updates,
+		)
 
 		this.index.set(updated)
 

package/src/store/memory/naming.ts

@@ -0,0 +1,195 @@
+import { NamzuError } from '../../types/errors/index.js'
+import type { MemoryId } from '../../types/ids/index.js'
+import type {
+	CreateMemoryParams,
+	MemoryIndexEntry,
+	UpdateMemoryParams,
+} from '../../types/memory/index.js'
+import { isMemoryType } from '../../types/memory/index.js'
+
+/** A memory name is a file name and a link target, so it is kept to what is safe as both. */
+export const MEMORY_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/
+export const MEMORY_NAME_MAX_LENGTH = 64
+/**
+ * Longest name {@link slugifyMemoryName} derives from a title. Shorter than
+ * {@link MEMORY_NAME_MAX_LENGTH} because the name appears twice in an index
+ * line (`- [name](name.md) — description`) inside a 150-character budget; a
+ * derived name that spends it all leaves the description, the only text a
+ * reader judges relevance by, a few words long.
+ */
+export const DERIVED_MEMORY_NAME_MAX_LENGTH = 32
+/** The index file a one-file-per-memory store generates; never a memory's name. */
+export const MEMORY_INDEX_NAME = 'MEMORY'
+
+export function isMemoryName(value: unknown): value is string {
+	return (
+		typeof value === 'string' &&
+		value.length <= MEMORY_NAME_MAX_LENGTH &&
+		MEMORY_NAME_PATTERN.test(value) &&
+		value.toUpperCase() !== MEMORY_INDEX_NAME
+	)
+}
+
+function invalidField(field: string, reason: string): never {
+	throw new NamzuError({
+		code: 'invalid_config',
+		message: `Memory ${field} ${reason}.`,
+		details: { field },
+		retryable: false,
+	})
+}
+
+export function assertMemoryName(value: unknown): asserts value is string {
+	if (!isMemoryName(value)) {
+		invalidField(
+			'name',
+			`must be a kebab-case slug of lowercase letters and digits, at most ${MEMORY_NAME_MAX_LENGTH} characters, and not "memory"; got ${JSON.stringify(value)}`,
+		)
+	}
+}
+
+/** Latin letters NFKD leaves whole, because they are letters of their own rather than marked ones. */
+const FOLDS: Readonly<Record<string, string>> = {
+	ı: 'i',
+	ł: 'l',
+	đ: 'd',
+	ø: 'o',
+	ß: 'ss',
+	æ: 'ae',
+	œ: 'oe',
+}
+
+/**
+ * The slug a title becomes. Diacritics are folded, everything else outside
+ * `a-z0-9` is a separator, and the result is cut at a word boundary. A title
+ * with no Latin letters or digits at all becomes `memory-note`, which the
+ * caller then suffixes like any other taken name.
+ */
+export function slugifyMemoryName(text: string): string {
+	const slug = text
+		.normalize('NFKD')
+		.replace(/\p{M}/gu, '')
+		.replace(/[ıłđøßæœ]/giu, (letter) => FOLDS[letter.toLowerCase()] ?? letter)
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, '-')
+		.replace(/^-+|-+$/g, '')
+	let cut = slug
+	if (cut.length > DERIVED_MEMORY_NAME_MAX_LENGTH) {
+		// Cut at the last word boundary that fits, when the slug has one past
+		// its first few characters; a single long word is cut where it is.
+		cut = cut.slice(0, DERIVED_MEMORY_NAME_MAX_LENGTH + 1)
+		const boundary = cut.lastIndexOf('-')
+		cut = boundary > 8 ? cut.slice(0, boundary) : cut.slice(0, DERIVED_MEMORY_NAME_MAX_LENGTH)
+		cut = cut.replace(/-+$/, '')
+	}
+	return isMemoryName(cut) ? cut : 'memory-note'
+}
+
+/** `base`, or `base-2`, `base-3`… — the first one nobody holds. */
+export function uniqueMemoryName(base: string, taken: ReadonlySet<string>): string {
+	if (!taken.has(base)) return base
+	for (let n = 2; ; n++) {
+		const candidate = `${base}-${n}`
+		if (!taken.has(candidate)) return candidate
+	}
+}
+
+/**
+ * A save under a name another memory already holds.
+ *
+ * Refused rather than suffixed because an explicit name is a claim about
+ * WHICH memory this is: two records under one name are the duplicate a
+ * caller should have written as an update. The error names the holder so
+ * the caller can do exactly that.
+ */
+export class MemoryNameConflictError extends NamzuError {
+	readonly memoryName: string
+	readonly existingId: MemoryId
+
+	constructor(name: string, existingId: MemoryId) {
+		super({
+			code: 'storage_error',
+			message: `A memory named "${name}" already exists (${existingId}). Update that memory instead of saving a duplicate, or choose a different name.`,
+			details: { name, existingId, reason: 'name_conflict' },
+			retryable: false,
+		})
+		this.name = 'MemoryNameConflictError'
+		this.memoryName = name
+		this.existingId = existingId
+	}
+}
+
+/** Why a store refused to write a memory's content. */
+export type MemoryContentRejection = 'too_large' | 'nul_byte'
+
+/**
+ * A memory the store would write but could not read back.
+ *
+ * Refused before anything is written: a one-file-per-memory store refuses to
+ * load a directory holding a file it cannot read, so writing one would turn
+ * a single bad save into every later operation failing.
+ */
+export class MemoryContentRejectedError extends NamzuError {
+	readonly reason: MemoryContentRejection
+	/** Encoded size of the file that would have been written, when `too_large`. */
+	readonly bytes?: number
+	readonly limit?: number
+
+	constructor(
+		reason: MemoryContentRejection,
+		details: { readonly bytes?: number; readonly limit?: number } = {},
+	) {
+		super({
+			code: 'invalid_config',
+			message:
+				reason === 'too_large'
+					? `The memory would be ${details.bytes} bytes on disk, over the ${details.limit}-byte limit for one memory. Save the rule or fact and where to find the rest, not the rest itself.`
+					: 'The memory contains a NUL character, which a memory file cannot hold. Remove it and save again.',
+			details: { reason, ...details },
+			retryable: false,
+		})
+		this.name = 'MemoryContentRejectedError'
+		this.reason = reason
+		if (details.bytes !== undefined) this.bytes = details.bytes
+		if (details.limit !== undefined) this.limit = details.limit
+	}
+}
+
+/** Refuse malformed optional fields before a store writes anything. */
+export function assertOptionalMemoryFields(
+	params: Pick<CreateMemoryParams, 'name' | 'description' | 'type'>,
+): void {
+	if (params.name !== undefined) assertMemoryName(params.name)
+	if (params.type !== undefined && !isMemoryType(params.type)) {
+		invalidField('type', 'must be user, feedback, project or reference')
+	}
+	if (params.description !== undefined) {
+		if (typeof params.description !== 'string') invalidField('description', 'must be a string')
+		if (/[\r\n]/.test(params.description)) invalidField('description', 'must be a single line')
+	}
+}
+
+/** The holder of `name` other than `self`, if any. */
+export function nameHolder(
+	entries: readonly MemoryIndexEntry[],
+	name: string,
+	self?: MemoryId,
+): MemoryIndexEntry | undefined {
+	return entries.find((entry) => entry.name === name && entry.id !== self)
+}
+
+/** Copy the optional typed fields onto an entry, leaving absent ones absent. */
+export function withOptionalFields(
+	entry: MemoryIndexEntry,
+	fields: Pick<UpdateMemoryParams, 'name' | 'description' | 'type'>,
+): MemoryIndexEntry {
+	const name = fields.name ?? entry.name
+	const description = fields.description ?? entry.description
+	const type = fields.type ?? entry.type
+	return {
+		...entry,
+		...(name !== undefined ? { name } : {}),
+		...(description !== undefined ? { description } : {}),
+		...(type !== undefined ? { type } : {}),
+	}
+}

package/src/store/memory/origin.ts

@@ -0,0 +1,35 @@
+/**
+ * Who wrote a memory, read from the metadata its writer stamps.
+ *
+ * The generated index a host loads into every prompt lists what someone chose
+ * to remember. A record the runtime derived on its own — the session memory
+ * promoter's account of a turn, a consolidation of a turn's working state — is
+ * written after almost every turn; listing it would change the system prompt nearly
+ * every turn, invalidating the prompt cache from there on, and would push the
+ * operator's own memories out of a capped index. Such records stay in the
+ * store, reachable through recall and search, and never enter the index.
+ */
+
+/** `metadata.source` of a record the session memory promoter writes. */
+export const SESSION_MEMORY_SOURCE = 'session-memory'
+/** `metadata.kind` of a record consolidation writes. */
+export const CONSOLIDATION_KIND = 'consolidation'
+/** `metadata.source` of a record the model saved with `save_memory`. */
+export const AGENT_MEMORY_SOURCE = 'agent-memory'
+
+/**
+ * - `derived` — written by the runtime, not chosen by anyone: never indexed.
+ * - `model` — saved by the model with `save_memory`.
+ * - `operator` — everything else: a note, a hand-written file, an import.
+ */
+export type MemoryOrigin = 'derived' | 'model' | 'operator'
+
+export function memoryOrigin(
+	metadata: Readonly<Record<string, unknown>> | undefined,
+): MemoryOrigin {
+	if (metadata?.source === SESSION_MEMORY_SOURCE || metadata?.kind === CONSOLIDATION_KIND) {
+		return 'derived'
+	}
+	if (metadata?.source === AGENT_MEMORY_SOURCE) return 'model'
+	return 'operator'
+}

package/src/store/session/disk.ts

@@ -9,20 +9,33 @@
  *     project.json
  *     sessions/{sessionId}/
  *       session.json
- *       messages.jsonl
+ *       summary.json
  *       subsessions/{subSessionId}/
  *         subsession.json
  *
+ * It holds the session ENTITIES (status, actor, ownership version,
+ * sub-session edges, summaries) and nothing of the conversation. A session's
+ * messages are records in its session log (`SessionLog`,
+ * `~/.namzu/projects/<slug>/<session-id>.jsonl`), read through
+ * `foldSessionMessages` and written only by the turn recorder under the
+ * session lease; listing turns and children across sessions is the
+ * `SessionIndex`. This store no longer writes `messages.jsonl`, and one left
+ * behind by an older build is never read.
+ *
  * Tenant scoping is enforced through the JSON payload (`tenantId` field on
  * every record) rather than the path layout; cross-tenant reads reject with
  * {@link TenantIsolationError} (Convention #17, session-hierarchy.md §12.2).
  *
- * Constructor takes `rootDir`; migration to the canonical `.namzu/projects/`
- * path lives in Phase 7 of the overall roadmap.
+ * Constructor takes `rootDir`. This entity tree is NOT the session layout:
+ * it is keyed by project id, so a `rootDir` equal to `NAMZU_HOME` puts
+ * UUID-named directories under `projects/`, which `namzu state` reports as
+ * legacy. Give it a directory of its own. Moving the entities onto the
+ * session log and index needs record types for session status, ownership
+ * and sub-session edges that the log does not have yet.
  */
 
 import { createHash } from 'node:crypto'
-import { appendFile, mkdir, readFile, rm } from 'node:fs/promises'
+import { mkdir, rm } from 'node:fs/promises'
 import { join } from 'node:path'
 import {
 	ProjectRootPathTakenError,
@@ -31,12 +44,10 @@ import {
 	TenantIsolationError,
 } from '../../session/errors.js'
 import { SessionAlreadySummarizedError } from '../../session/summary/errors.js'
-import type { MessageId, SessionId, TenantId } from '../../types/ids/index.js'
-import type { Message } from '../../types/message/index.js'
+import type { SessionId, TenantId } from '../../types/ids/index.js'
 import type { Project, ProjectStatus } from '../../types/project/entity.js'
 import type { Session } from '../../types/session/entity.js'
 import type { ProjectId, SubSessionId, SummaryId, TopicId } from '../../types/session/ids.js'
-import type { SessionMessage } from '../../types/session/messages.js'
 import type {
 	CreateProjectParams,
 	CreateSessionParams,
@@ -57,7 +68,6 @@ import {
 	asSessionId,
 	asSubSessionId,
 	asTopicId,
-	generateMessageId,
 	generateProjectId,
 	generateSessionId,
 	generateSubSessionId,
@@ -68,12 +78,7 @@ import {
 	DiskRevisionRecordStore,
 	type RevisionedRecordLocation,
 } from '../kv/revision-record-store.js'
-// `migrate` and `stamp` are imported directly for the append-only
-// `messages.jsonl` path ALONE: each line there is a whole record carrying
-// its own stamp, because a log is written by many builds over its lifetime
-// and its lines can legitimately differ in version. Every RECORD read and
-// write goes through the `records` primitive below instead.
-import { defineSchema, migrate, stamp } from '../schema.js'
+import { defineSchema } from '../schema.js'
 import { canonicalizePath, rootPathIndexKey } from './canonical-path.js'
 import { getAncestry, getChildren, orderChildren } from './linkage.js'
 import type { LinkageView } from './linkage.js'
@@ -92,32 +97,12 @@ const SCHEMA = defineSchema({
 	migrations: {
 		1: migrateSessionStoreThreadIdToTopicId,
 		2: migrateSessionStoreTopicIdPrefix,
-		3: migrateSessionStoreMessageRecordKind,
+		// v3 → v4 tagged the lines of `messages.jsonl`, which this store no
+		// longer reads; for every record it still reads the step is identity.
+		3: (record) => record,
 	},
 })
 
-/**
- * v3 → v4: distinguish ordinary message appends from atomic replacements.
- *
- * The schema migrator runs over every record kind in this store, so the
- * predicate names the fields unique to a message-log line and leaves project,
- * session, sub-session and summary records byte-for-byte alone.
- */
-export function migrateSessionStoreMessageRecordKind(
-	record: Record<string, unknown>,
-): Record<string, unknown> {
-	if (
-		record.recordKind !== undefined ||
-		typeof record.id !== 'string' ||
-		typeof record.sessionId !== 'string' ||
-		!('message' in record) ||
-		typeof record.at !== 'string'
-	) {
-		return record
-	}
-	return { ...record, recordKind: 'message' }
-}
-
 /**
  * Read, write and list, through the one implementation.
  *
@@ -128,12 +113,7 @@ export function migrateSessionStoreMessageRecordKind(
  * partially and written back with the difference gone, a listing needs a
  * stable order), and every one fixed here had to be remembered into the
  * other three.
- *
- * Deliberately NOT converted: the append-only session event log and
- * `messages.jsonl`. Those are log-shaped, not record-shaped — each line is
- * a whole record and append IS the write-safety primitive — so forcing them
- * through a record store would be a worse fit than the duplication it
- * removes.
+
  */
 const records = new DiskRecordStore<unknown>(SCHEMA)
 
@@ -178,11 +158,10 @@ export function migrateSessionStoreTopicIdPrefix(
  * with this as its data migration.
  *
  * One migration function runs over every kind this schema stamps —
- * project.json, session.json, subsession.json, summary.json, and each
- * `messages.jsonl` line — via the single shared `readJson` / `migrate`
- * call. Only `PersistedSession` ever carried `threadId`; an unconditional
- * rewrite here would stamp `topicId: undefined` onto the other three kinds
- * and onto every message line ever written. Exported, not module-private,
+ * project.json, session.json, subsession.json and summary.json — via the
+ * single shared `readJson` / `migrate` call. Only `PersistedSession` ever
+ * carried `threadId`; an unconditional rewrite here would stamp
+ * `topicId: undefined` onto the other kinds. Exported, not module-private,
  * so that guarantee is unit-testable directly against the function rather
  * than only observable through whichever deserializer happens to forward
  * an extra field today (most of them don't — they map named fields, which
@@ -254,35 +233,6 @@ interface PersistedSubSession {
 	updatedAt: string
 }
 
-interface PersistedMessageLine {
-	recordKind: 'message'
-	id: MessageId
-	sessionId: SessionId
-	tenantId: TenantId
-	message: Message
-	at: string
-}
-
-/**
- * One atomic projection change inside the append-only message log.
- *
- * Writing the replacement as several ordinary lines would expose a prefix if
- * the process died between appends. One line is the transaction boundary: a
- * reader sees the old conversation or the complete compacted one.
- */
-interface PersistedMessageReplacementLine {
-	recordKind: 'replacement'
-	sessionId: SessionId
-	tenantId: TenantId
-	messages: readonly {
-		readonly id: MessageId
-		readonly message: Message
-		readonly at: string
-	}[]
-}
-
-type PersistedMessageRecord = PersistedMessageLine | PersistedMessageReplacementLine
-
 interface PersistedSummary {
 	id: SummaryId
 	sessionRef: SessionId
@@ -871,120 +821,6 @@ export class DiskSessionStore implements SessionStore {
 		this.subSessionIndex.delete(subSessionId)
 	}
 
-	// Messages ----------------------------------------------------------------
-
-	async appendMessage(
-		sessionId: SessionId,
-		message: Message,
-		tenantId: TenantId,
-	): Promise<MessageId> {
-		const located = await this.locateSession(sessionId)
-		if (!located) throw new Error(`Session ${sessionId} not found`)
-
-		const session = await records.read<PersistedSession>(join(located.path, 'session.json'))
-		if (!session) throw new Error(`Session ${sessionId} not found on disk`)
-		this.assertTenant(session.tenantId, tenantId, `session(${sessionId})`)
-
-		const id = generateMessageId()
-		const entry: PersistedMessageLine = {
-			recordKind: 'message',
-			id,
-			sessionId,
-			tenantId,
-			message,
-			at: new Date().toISOString(),
-		}
-		// Each line is a whole record, so each line carries its own stamp: an
-		// append-only log is written by many builds over its lifetime and its
-		// lines can legitimately differ in version.
-		await appendFile(
-			join(located.path, 'messages.jsonl'),
-			`${JSON.stringify(stamp(SCHEMA, entry))}\n`,
-			'utf-8',
-		)
-		return id
-	}
-
-	async replaceMessages(
-		sessionId: SessionId,
-		messages: readonly Message[],
-		tenantId: TenantId,
-	): Promise<void> {
-		const located = await this.locateSession(sessionId)
-		if (!located) throw new Error(`Session ${sessionId} not found`)
-
-		const session = await records.read<PersistedSession>(join(located.path, 'session.json'))
-		if (!session) throw new Error(`Session ${sessionId} not found on disk`)
-		this.assertTenant(session.tenantId, tenantId, `session(${sessionId})`)
-
-		const at = new Date().toISOString()
-		const entry: PersistedMessageReplacementLine = {
-			recordKind: 'replacement',
-			sessionId,
-			tenantId,
-			messages: messages.map((message) => ({ id: generateMessageId(), message, at })),
-		}
-		// One append, however many projected messages. If the process dies before
-		// this line lands, readers see the old projection; after it lands, they
-		// see the whole replacement. There is no prefix state to mistake for a
-		// successful compaction.
-		await appendFile(
-			join(located.path, 'messages.jsonl'),
-			`${JSON.stringify(stamp(SCHEMA, entry))}\n`,
-			'utf-8',
-		)
-	}
-
-	async loadMessages(sessionId: SessionId, tenantId: TenantId): Promise<readonly Message[]> {
-		const rows = await this.loadSessionMessages(sessionId, tenantId)
-		return rows.map((r) => r.message)
-	}
-
-	async loadSessionMessages(
-		sessionId: SessionId,
-		tenantId: TenantId,
-	): Promise<readonly SessionMessage[]> {
-		const located = await this.locateSession(sessionId)
-		if (!located) return []
-
-		const session = await records.read<PersistedSession>(join(located.path, 'session.json'))
-		if (!session) return []
-		this.assertTenant(session.tenantId, tenantId, `session(${sessionId})`)
-
-		const path = join(located.path, 'messages.jsonl')
-		let raw: string
-		try {
-			raw = await readFile(path, 'utf-8')
-		} catch (err) {
-			const code = (err as NodeJS.ErrnoException).code
-			if (code === 'ENOENT') return []
-			throw err
-		}
-		const lines = raw.split('\n').filter((l) => l.length > 0)
-		let projected: SessionMessage[] = []
-		for (const line of lines) {
-			const persisted = migrate<PersistedMessageRecord>(SCHEMA, JSON.parse(line))
-			if (persisted.recordKind === 'replacement') {
-				projected = persisted.messages.map((entry) => ({
-					id: entry.id,
-					sessionId: persisted.sessionId,
-					tenantId: persisted.tenantId,
-					message: entry.message,
-					at: new Date(entry.at),
-				}))
-				continue
-			}
-			projected.push({
-				id: persisted.id,
-				sessionId: persisted.sessionId,
-				tenantId: persisted.tenantId,
-				message: persisted.message,
-				at: new Date(persisted.at),
-			})
-		}
-		return projected
-	}
-
 	// Linkage -----------------------------------------------------------------
 
 	async getChildren(sessionId: SessionId, tenantId: TenantId): Promise<readonly SubSession[]> {
@@ -1352,12 +1188,3 @@ function deserializeSummary(s: PersistedSummary): SessionSummaryRef {
 		materializedBy: 'kernel',
 	}
 }
-
-// FS helpers -----------------------------------------------------------------
-
-// Note: messages are append-only `messages.jsonl` (not write-tmp-rename).
-// Append is the write-safety primitive for log-structured files; each
-// line is a whole record. This matches pattern doc §13.4 persistence
-// (`messages.json[l]` as append-only event log).
-
-export type { SessionMessage } from '../../types/session/messages.js'

package/src/store/session/index.ts

@@ -1,16 +1,12 @@
-// Sub-barrel for the session-scoped persistence module (Convention #4).
+// Sub-barrel for the session-entity persistence module (Convention #4).
 //
-// Messages are scoped to a `SessionId` and every accessor carries explicit
-// `TenantId` (Convention #17). Concrete implementations live in sibling
-// files; re-export them here so consumers import via
-// `../store/session/index.js`. The `SessionMessage` shape lives under
-// `types/session/messages.ts` — re-exported here for convenience.
+// Projects, sessions, sub-session edges and summaries, every accessor
+// carrying an explicit `TenantId` (Convention #17). A session's conversation
+// is not here: it is the session log (`store/session-log`), and listing
+// across sessions is the session index (`store/session-index`).
 
 export { InMemorySessionStore } from './memory.js'
 export { DiskSessionStore } from './disk.js'
-export { SqliteSessionStore } from './sqlite.js'
-export type { SqliteSessionStoreConfig } from './sqlite.js'
 export type { DiskSessionStoreConfig } from './disk.js'
-export type { SessionMessage } from '../../types/session/messages.js'
 export { getAncestry, getChildren, orderChildren } from './linkage.js'
 export type { LinkageView } from './linkage.js'