@namzu/sdk 27.0.0 → 28.0.0

package/dist/store/session/disk.js

@@ -20,13 +20,24 @@
  * Constructor takes `rootDir`; migration to the canonical `.namzu/projects/`
  * path lives in Phase 7 of the overall roadmap.
  */
-import { appendFile, mkdir, readFile, readdir, rm } from 'node:fs/promises';
+import { appendFile, mkdir, readFile, rm } from 'node:fs/promises';
 import { join } from 'node:path';
-import { StaleProjectError, StaleSessionError, TenantIsolationError } from '../../session/errors.js';
+import { ProjectRootPathTakenError, StaleProjectError, StaleSessionError, TenantIsolationError, } from '../../session/errors.js';
 import { SessionAlreadySummarizedError } from '../../session/summary/errors.js';
-import { atomicWriteFile } from '../../utils/atomic-write.js';
 import { generateMessageId, generateProjectId, generateSessionId, generateSubSessionId, } from '../../utils/id.js';
+import { DiskRecordStore } from '../kv/record-store.js';
+//  and  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
+// `records` above instead.
+// `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 { canonicalizePath, rootPathIndexKey } from './canonical-path.js';
 import { getAncestry, getChildren, orderChildren } from './linkage.js';
 /**
  * This store's on-disk format, versioned as a unit — which is how a
@@ -36,7 +47,78 @@ import { getAncestry, getChildren, orderChildren } from './linkage.js';
  * Bump `current` and add the migration for the step you are leaving when
  * the shape changes.
  */
-const SCHEMA = defineSchema({ kind: 'session-store', current: 1, migrations: {} });
+const SCHEMA = defineSchema({
+    kind: 'session-store',
+    current: 3,
+    migrations: {
+        1: migrateSessionStoreThreadIdToTopicId,
+        2: migrateSessionStoreTopicIdPrefix,
+    },
+});
+/**
+ * Read, write and list, through the one implementation.
+ *
+ * This file carried its own `readJson`, its own `atomicWriteJson` and
+ * thirteen `readdir` scans — the same twenty lines four stores each kept a
+ * private copy of. The properties are not obvious ones (a missing file is
+ * an empty read, a record from a NEWER build is refused rather than read
+ * 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(SCHEMA);
+/**
+ * v2 → v3: NZ-TOPIC-04 narrows the Topic id prefix from `thd_` to `top_`.
+ * The FIELD is already `topicId` (the v1→v2 step above handled that); this
+ * step rewrites only the VALUE, and only when it still carries the old
+ * prefix — a record already at v3, or one that just arrived here via the
+ * v1→v2 step in the same `migrate()` call, has `topicId` starting `top_`
+ * (or `thd_`, freshly renamed from `threadId` — this step runs on it next
+ * in the same pass) either way, and the check below is what makes running
+ * it on an already-correct value a same-object no-op rather than a
+ * needless copy. Same one-function-runs-over-every-kind shape as its
+ * v1→v2 sibling: only `PersistedSession.topicId` is ever `thd_`-prefixed,
+ * so every other kind this schema stamps (project.json, subsession.json,
+ * summary.json, each messages.jsonl line) has no `topicId` key and comes
+ * back untouched.
+ */
+export function migrateSessionStoreTopicIdPrefix(record) {
+    const topicId = record.topicId;
+    if (typeof topicId !== 'string' || !topicId.startsWith('thd_'))
+        return record;
+    return { ...record, topicId: `top_${topicId.slice('thd_'.length)}` };
+}
+/**
+ * v1 → v2: the FK field `session.json` carries to its owning Topic was
+ * spelled `threadId`. NZ-TOPIC-01 renamed the layer, not the field
+ * (comment on `types/topic/store.ts`); NZ-TOPIC-03 is that rename landing,
+ * 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,
+ * 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
+ * is exactly why a stray key here would otherwise go unnoticed). NOT part
+ * of the package's public surface: `store/session/index.ts` re-exports
+ * `DiskSessionStore` by explicit name only, no wildcard.
+ */
+export function migrateSessionStoreThreadIdToTopicId(record) {
+    if (!('threadId' in record))
+        return record;
+    const { threadId, ...rest } = record;
+    return { ...rest, topicId: threadId };
+}
 /**
  * Non-terminal statuses from which {@link DiskSessionStore.recordSummary}
  * flips the owning session to `'idle'` as part of the atomic materialize +
@@ -63,6 +145,13 @@ export class DiskSessionStore {
                 resource: `project(name=${params.name})`,
             });
         }
+        const rootPath = params.rootPath === undefined ? undefined : await canonicalizePath(params.rootPath);
+        if (rootPath !== undefined) {
+            const existing = await this.findProjectByRootPath(rootPath, tenantId);
+            if (existing) {
+                throw new ProjectRootPathTakenError({ rootPath, existingProjectId: existing.id });
+            }
+        }
         const now = new Date();
         const project = {
             id: generateProjectId(),
@@ -75,18 +164,46 @@ export class DiskSessionStore {
             },
             status: 'open',
             ownerVersion: 0,
+            ...(rootPath !== undefined ? { rootPath } : {}),
             createdAt: now,
             updatedAt: now,
         };
         const dir = join(this.rootDir, 'projects', project.id);
         await mkdir(dir, { recursive: true });
-        await atomicWriteJson(join(dir, 'project.json'), serializeProject(project));
+        await records.write(join(dir, 'project.json'), serializeProject(project));
         this.projectIndex.set(project.id, { projectId: project.id, path: dir });
+        if (rootPath !== undefined)
+            await this.writeRootPathIndex(rootPath, tenantId, project.id);
         return project;
     }
+    /**
+     * Reads ONE index file. Not a scan of `projects/*` — that opens every
+     * `project.json` on the machine to answer a question about one
+     * directory, and gets slower with every project a host has ever made.
+     */
+    async findProjectByRootPath(rootPath, tenantId) {
+        const canonical = await canonicalizePath(rootPath);
+        const index = await records.read(this.rootPathIndexPath());
+        // Tenant is part of the KEY, not a filter applied after the lookup.
+        // Two tenants may bind projects to the same path on a shared machine,
+        // and a path-only key would hand one of them the other's project.
+        const projectId = index?.[rootPathIndexKey(canonical, tenantId)];
+        if (!projectId)
+            return null;
+        return await this.getProject(projectId, tenantId);
+    }
+    rootPathIndexPath() {
+        return join(this.rootDir, 'projects', 'root-path-index.json');
+    }
+    async writeRootPathIndex(rootPath, tenantId, projectId) {
+        const path = this.rootPathIndexPath();
+        const index = (await records.read(path)) ?? {};
+        index[rootPathIndexKey(rootPath, tenantId)] = projectId;
+        await records.write(path, index);
+    }
     async getProject(projectId, tenantId) {
         const dir = this.projectDir(projectId);
-        const raw = await readJson(join(dir, 'project.json'));
+        const raw = await records.read(join(dir, 'project.json'));
         if (!raw)
             return null;
         this.assertTenant(raw.tenantId, tenantId, `project(${projectId})`);
@@ -111,7 +228,7 @@ export class DiskSessionStore {
             },
             updatedAt: new Date(),
         };
-        await atomicWriteJson(join(this.projectDir(projectId), 'project.json'), serializeProject(project));
+        await records.write(join(this.projectDir(projectId), 'project.json'), serializeProject(project));
         return project;
     }
     async setProjectStatus(projectId, status, tenantId, expectedOwnerVersion) {
@@ -132,7 +249,7 @@ export class DiskSessionStore {
             ownerVersion: existing.ownerVersion + 1,
             updatedAt: new Date(),
         };
-        await atomicWriteJson(join(this.projectDir(projectId), 'project.json'), serializeProject(project));
+        await records.write(join(this.projectDir(projectId), 'project.json'), serializeProject(project));
         return project;
     }
     async listProjects(tenantId) {
@@ -142,16 +259,10 @@ export class DiskSessionStore {
         // process — which for a store whose whole point is durability is the
         // wrong answer.
         const projectsRoot = join(this.rootDir, 'projects');
-        let entries;
-        try {
-            entries = await readdir(projectsRoot);
-        }
-        catch {
-            return [];
-        }
+        const entries = await records.scanNames(projectsRoot, '');
         const found = [];
         for (const entry of entries) {
-            const raw = await readJson(join(projectsRoot, entry, 'project.json'));
+            const raw = await records.read(join(projectsRoot, entry, 'project.json'));
             if (!raw)
                 continue;
             // Another tenant's project is absent, not an error — a listing is a
@@ -176,7 +287,7 @@ export class DiskSessionStore {
         const now = new Date();
         const session = {
             id: generateSessionId(),
-            threadId: params.threadId,
+            topicId: params.topicId,
             projectId: params.projectId,
             tenantId,
             status: 'idle',
@@ -189,7 +300,7 @@ export class DiskSessionStore {
         };
         const dir = join(this.projectDir(params.projectId), 'sessions', session.id);
         await mkdir(dir, { recursive: true });
-        await atomicWriteJson(join(dir, 'session.json'), serializeSession(session));
+        await records.write(join(dir, 'session.json'), serializeSession(session));
         this.sessionIndex.set(session.id, {
             sessionId: session.id,
             projectId: params.projectId,
@@ -201,58 +312,49 @@ export class DiskSessionStore {
         const located = await this.locateSession(sessionId);
         if (!located)
             return null;
-        const raw = await readJson(join(located.path, 'session.json'));
+        const raw = await records.read(join(located.path, 'session.json'));
         if (!raw)
             return null;
         this.assertTenant(raw.tenantId, tenantId, `session(${sessionId})`);
         return deserializeSession(raw);
     }
-    async listSessions(threadId, tenantId) {
+    async listSessionsByTopic(topicId, tenantId) {
         // Walk projects/*/sessions/* and filter on the persisted record. Sessions
-        // don't live under a thread-scoped path in the current layout — the
-        // denormalized `threadId` on every session.json is the authority. Matches
-        // DiskThreadStore.listThreads in scan semantics.
+        // don't live under a topic-scoped path in the current layout — the
+        // denormalized `topicId` on every session.json is the authority.
+        //
+        // This used to say "matches DiskThreadStore.listThreads in scan
+        // semantics" — that class is gone (NZ-TOPIC-02, ses_020: zero production
+        // callers, never public, no tests). This function's own scan doesn't
+        // change; the comparison just isn't holding anything up anymore, so it's
+        // removed rather than left pointing at a deleted file. Renamed from
+        // `listSessions` alongside the field it reads (NZ-TOPIC-03).
         //
         // Cost: O(all sessions across all projects in the root) per call. The
         // MVP disk store prioritizes simplicity over index freshness, matching
         // `buildLinkageView` / `locateSession` which use the same pattern. A
-        // production driver would maintain a threadId → sessionIds secondary
+        // production driver would maintain a topicId → sessionIds secondary
         // index populated on createSession / deleteSession. Acceptable for
-        // ThreadManager archive/delete today because those operations are
+        // TopicManager archive/delete today because those operations are
         // admin-initiated and infrequent.
         const projectsDir = join(this.rootDir, 'projects');
-        let projectDirs;
-        try {
-            projectDirs = await readdir(projectsDir);
-        }
-        catch (err) {
-            const code = err.code;
-            if (code === 'ENOENT')
-                return [];
-            throw err;
-        }
+        const projectDirs = await records.scanNames(projectsDir, '');
         const results = [];
         for (const rawProject of projectDirs) {
             if (!rawProject.startsWith('prj_'))
                 continue;
             const sessionsRoot = join(projectsDir, rawProject, 'sessions');
-            let sessionDirs;
-            try {
-                sessionDirs = await readdir(sessionsRoot);
-            }
-            catch {
-                continue;
-            }
+            const sessionDirs = await records.scanNames(sessionsRoot, '');
             for (const rawSessionId of sessionDirs) {
                 if (!rawSessionId.startsWith('ses_'))
                     continue;
                 const path = join(sessionsRoot, rawSessionId);
-                const raw = await readJson(join(path, 'session.json'));
+                const raw = await records.read(join(path, 'session.json'));
                 if (!raw)
                     continue;
                 if (raw.tenantId !== tenantId)
                     continue;
-                if (raw.threadId !== threadId)
+                if (raw.topicId !== topicId)
                     continue;
                 results.push(deserializeSession(raw));
                 this.sessionIndex.set(raw.id, {
@@ -267,26 +369,17 @@ export class DiskSessionStore {
     }
     async listSessionsByProject(projectId, tenantId) {
         // One directory, not the whole root: sessions live under their project,
-        // so this is the cheap direction. `listSessions` has to scan every
-        // project precisely because `threadId` is denormalised onto the record
-        // rather than expressed in the layout.
+        // so this is the cheap direction. `listSessionsByTopic` has to scan
+        // every project precisely because `topicId` is denormalised onto the
+        // record rather than expressed in the layout.
         const sessionsRoot = join(this.projectDir(projectId), 'sessions');
-        let sessionDirs;
-        try {
-            sessionDirs = await readdir(sessionsRoot);
-        }
-        catch (err) {
-            const code = err.code;
-            if (code === 'ENOENT')
-                return [];
-            throw err;
-        }
+        const sessionDirs = await records.scanNames(sessionsRoot, '');
         const results = [];
         for (const rawSessionId of sessionDirs) {
             if (!rawSessionId.startsWith('ses_'))
                 continue;
             const path = join(sessionsRoot, rawSessionId);
-            const raw = await readJson(join(path, 'session.json'));
+            const raw = await records.read(join(path, 'session.json'));
             if (!raw)
                 continue;
             if (raw.tenantId !== tenantId)
@@ -308,7 +401,7 @@ export class DiskSessionStore {
                 resource: `session(${session.id}) payload`,
             });
         }
-        const existing = await readJson(join(located.path, 'session.json'));
+        const existing = await records.read(join(located.path, 'session.json'));
         if (existing) {
             this.assertTenant(existing.tenantId, tenantId, `session(${session.id})`);
         }
@@ -326,13 +419,13 @@ export class DiskSessionStore {
             });
         }
         const updated = { ...session, updatedAt: new Date() };
-        await atomicWriteJson(join(located.path, 'session.json'), serializeSession(updated));
+        await records.write(join(located.path, 'session.json'), serializeSession(updated));
     }
     async deleteSession(sessionId, tenantId) {
         const located = await this.locateSession(sessionId);
         if (!located)
             return; // Idempotent: missing = no-op.
-        const existing = await readJson(join(located.path, 'session.json'));
+        const existing = await records.read(join(located.path, 'session.json'));
         if (!existing)
             return;
         this.assertTenant(existing.tenantId, tenantId, `session(${sessionId})`);
@@ -341,15 +434,7 @@ export class DiskSessionStore {
         // We check BOTH directions (this session as parent, or as child) to
         // match the in-memory semantics.
         const subsDir = join(located.path, 'subsessions');
-        let subEntries = [];
-        try {
-            subEntries = await readdir(subsDir);
-        }
-        catch (err) {
-            const code = err.code;
-            if (code !== 'ENOENT')
-                throw err;
-        }
+        const subEntries = await records.scanNames(subsDir, '');
         if (subEntries.some((e) => e.startsWith('sub_'))) {
             throw new Error(`Session ${sessionId} has attached sub-sessions; delete them before deleting the session`);
         }
@@ -359,43 +444,21 @@ export class DiskSessionStore {
         // deleteSubSession + deleteSession call on the child (no orphans at
         // steady state).
         const projectsDir = join(this.rootDir, 'projects');
-        let projectDirs;
-        try {
-            projectDirs = await readdir(projectsDir);
-        }
-        catch (err) {
-            const code = err.code;
-            if (code === 'ENOENT')
-                projectDirs = [];
-            else
-                throw err;
-        }
+        const projectDirs = await records.scanNames(projectsDir, '');
         for (const rawProject of projectDirs) {
             if (!rawProject.startsWith('prj_'))
                 continue;
             const sessionsRoot = join(projectsDir, rawProject, 'sessions');
-            let siblingSessions = [];
-            try {
-                siblingSessions = await readdir(sessionsRoot);
-            }
-            catch {
-                continue;
-            }
+            const siblingSessions = await records.scanNames(sessionsRoot, '');
             for (const rawSib of siblingSessions) {
                 if (!rawSib.startsWith('ses_'))
                     continue;
                 const sibSubsDir = join(sessionsRoot, rawSib, 'subsessions');
-                let sibSubs = [];
-                try {
-                    sibSubs = await readdir(sibSubsDir);
-                }
-                catch {
-                    continue;
-                }
+                const sibSubs = await records.scanNames(sibSubsDir, '');
                 for (const rawSub of sibSubs) {
                     if (!rawSub.startsWith('sub_'))
                         continue;
-                    const subRaw = await readJson(join(sibSubsDir, rawSub, 'subsession.json'));
+                    const subRaw = await records.read(join(sibSubsDir, rawSub, 'subsession.json'));
                     if (!subRaw)
                         continue;
                     if (subRaw.childSessionId === sessionId || subRaw.parentSessionId === sessionId) {
@@ -437,7 +500,7 @@ export class DiskSessionStore {
         };
         const dir = join(parentLoc.path, 'subsessions', subSession.id);
         await mkdir(dir, { recursive: true });
-        await atomicWriteJson(join(dir, 'subsession.json'), serializeSubSession(subSession, tenantId));
+        await records.write(join(dir, 'subsession.json'), serializeSubSession(subSession, tenantId));
         this.subSessionIndex.set(subSession.id, {
             subSessionId: subSession.id,
             sessionId: params.parentSessionId,
@@ -450,7 +513,7 @@ export class DiskSessionStore {
         const located = await this.locateSubSession(subSessionId);
         if (!located)
             return null;
-        const raw = await readJson(join(located.path, 'subsession.json'));
+        const raw = await records.read(join(located.path, 'subsession.json'));
         if (!raw)
             return null;
         this.assertTenant(raw.tenantId, tenantId, `sub-session(${subSessionId})`);
@@ -461,18 +524,18 @@ export class DiskSessionStore {
         if (!located) {
             throw new Error(`SubSession ${subSession.id} not found`);
         }
-        const existing = await readJson(join(located.path, 'subsession.json'));
+        const existing = await records.read(join(located.path, 'subsession.json'));
         if (existing) {
             this.assertTenant(existing.tenantId, tenantId, `sub-session(${subSession.id})`);
         }
         const updated = { ...subSession, updatedAt: new Date() };
-        await atomicWriteJson(join(located.path, 'subsession.json'), serializeSubSession(updated, tenantId));
+        await records.write(join(located.path, 'subsession.json'), serializeSubSession(updated, tenantId));
     }
     async deleteSubSession(subSessionId, tenantId) {
         const located = await this.locateSubSession(subSessionId);
         if (!located)
             return; // Idempotent: missing = no-op.
-        const existing = await readJson(join(located.path, 'subsession.json'));
+        const existing = await records.read(join(located.path, 'subsession.json'));
         if (!existing) {
             // Record vanished between locate + read — treat as already deleted.
             this.subSessionIndex.delete(subSessionId);
@@ -487,7 +550,7 @@ export class DiskSessionStore {
         const located = await this.locateSession(sessionId);
         if (!located)
             throw new Error(`Session ${sessionId} not found`);
-        const session = await readJson(join(located.path, 'session.json'));
+        const session = await records.read(join(located.path, 'session.json'));
         if (!session)
             throw new Error(`Session ${sessionId} not found on disk`);
         this.assertTenant(session.tenantId, tenantId, `session(${sessionId})`);
@@ -513,7 +576,7 @@ export class DiskSessionStore {
         const located = await this.locateSession(sessionId);
         if (!located)
             return [];
-        const session = await readJson(join(located.path, 'session.json'));
+        const session = await records.read(join(located.path, 'session.json'));
         if (!session)
             return [];
         this.assertTenant(session.tenantId, tenantId, `session(${sessionId})`);
@@ -591,13 +654,13 @@ export class DiskSessionStore {
         if (!located) {
             throw new Error(`Session ${summary.sessionRef} not found`);
         }
-        const sessionRaw = await readJson(join(located.path, 'session.json'));
+        const sessionRaw = await records.read(join(located.path, 'session.json'));
         if (!sessionRaw) {
             throw new Error(`Session ${summary.sessionRef} not found on disk`);
         }
         this.assertTenant(sessionRaw.tenantId, tenantId, `session(${summary.sessionRef})`);
         const summaryPath = join(located.path, 'summary.json');
-        const existingRaw = await readJson(summaryPath);
+        const existingRaw = await records.read(summaryPath);
         if (existingRaw) {
             this.assertTenant(existingRaw.tenantId, tenantId, `summary(${existingRaw.id})`);
             if (existingRaw.id !== summary.id) {
@@ -611,7 +674,7 @@ export class DiskSessionStore {
         }
         else {
             // Step 1: persist summary.
-            await atomicWriteJson(summaryPath, serializeSummary(summary));
+            await records.write(summaryPath, serializeSummary(summary));
         }
         // Step 2: flip session status atomically if still non-terminal.
         if (SUMMARY_TERMINAL_FLIP_STATUSES.has(sessionRaw.status)) {
@@ -620,14 +683,14 @@ export class DiskSessionStore {
                 status: 'idle',
                 updatedAt: new Date().toISOString(),
             };
-            await atomicWriteJson(join(located.path, 'session.json'), flipped);
+            await records.write(join(located.path, 'session.json'), flipped);
         }
     }
     async getSummary(sessionId, tenantId) {
         const located = await this.locateSession(sessionId);
         if (!located)
             return null;
-        const raw = await readJson(join(located.path, 'summary.json'));
+        const raw = await records.read(join(located.path, 'summary.json'));
         if (!raw)
             return null;
         this.assertTenant(raw.tenantId, tenantId, `summary(${raw.id})`);
@@ -652,28 +715,15 @@ export class DiskSessionStore {
         if (cached)
             return cached;
         const projectsDir = join(this.rootDir, 'projects');
-        let projectDirs;
-        try {
-            projectDirs = await readdir(projectsDir);
-        }
-        catch (err) {
-            const code = err.code;
-            if (code === 'ENOENT')
-                return null;
-            throw err;
-        }
+        // ENOENT lists as empty; the loop below then falls through to the
+        // same `return null` the old catch took directly.
+        const projectDirs = await records.scanNames(projectsDir, '');
         for (const rawId of projectDirs) {
             if (!rawId.startsWith('prj_'))
                 continue;
             const projectId = rawId;
             const sessionsRoot = join(projectsDir, projectId, 'sessions');
-            let sessionDirs;
-            try {
-                sessionDirs = await readdir(sessionsRoot);
-            }
-            catch {
-                continue;
-            }
+            const sessionDirs = await records.scanNames(sessionsRoot, '');
             for (const rawSessionId of sessionDirs) {
                 if (!rawSessionId.startsWith('ses_'))
                     continue;
@@ -695,40 +745,21 @@ export class DiskSessionStore {
         if (cached)
             return cached;
         const projectsDir = join(this.rootDir, 'projects');
-        let projectDirs;
-        try {
-            projectDirs = await readdir(projectsDir);
-        }
-        catch (err) {
-            const code = err.code;
-            if (code === 'ENOENT')
-                return null;
-            throw err;
-        }
+        // ENOENT lists as empty; the loop below then falls through to the
+        // same `return null` the old catch took directly.
+        const projectDirs = await records.scanNames(projectsDir, '');
         for (const rawProject of projectDirs) {
             if (!rawProject.startsWith('prj_'))
                 continue;
             const projectId = rawProject;
             const sessionsRoot = join(projectsDir, projectId, 'sessions');
-            let sessionDirs;
-            try {
-                sessionDirs = await readdir(sessionsRoot);
-            }
-            catch {
-                continue;
-            }
+            const sessionDirs = await records.scanNames(sessionsRoot, '');
             for (const rawSession of sessionDirs) {
                 if (!rawSession.startsWith('ses_'))
                     continue;
                 const sessionId = rawSession;
                 const subsDir = join(sessionsRoot, sessionId, 'subsessions');
-                let subDirs;
-                try {
-                    subDirs = await readdir(subsDir);
-                }
-                catch {
-                    continue;
-                }
+                const subDirs = await records.scanNames(subsDir, '');
                 for (const rawSub of subDirs) {
                     if (rawSub === subSessionId) {
                         const entry = {
@@ -750,40 +781,21 @@ export class DiskSessionStore {
         // Acceptable for an MVP disk store; a production impl would cache.
         const allSubs = [];
         const projectsDir = join(this.rootDir, 'projects');
-        let projectDirs;
-        try {
-            projectDirs = await readdir(projectsDir);
-        }
-        catch (err) {
-            const code = err.code;
-            if (code === 'ENOENT')
-                return emptyLinkageView();
-            throw err;
-        }
+        // ENOENT lists as empty, and a view over no sub-sessions IS the empty
+        // view the old catch returned directly.
+        const projectDirs = await records.scanNames(projectsDir, '');
         for (const rawProject of projectDirs) {
             if (!rawProject.startsWith('prj_'))
                 continue;
             const sessionsRoot = join(projectsDir, rawProject, 'sessions');
-            let sessionDirs;
-            try {
-                sessionDirs = await readdir(sessionsRoot);
-            }
-            catch {
-                continue;
-            }
+            const sessionDirs = await records.scanNames(sessionsRoot, '');
             for (const rawSession of sessionDirs) {
                 if (!rawSession.startsWith('ses_'))
                     continue;
                 const subsRoot = join(sessionsRoot, rawSession, 'subsessions');
-                let subDirs;
-                try {
-                    subDirs = await readdir(subsRoot);
-                }
-                catch {
-                    continue;
-                }
+                const subDirs = await records.scanNames(subsRoot, '');
                 for (const rawSub of subDirs) {
-                    const raw = await readJson(join(subsRoot, rawSub, 'subsession.json'));
+                    const raw = await records.read(join(subsRoot, rawSub, 'subsession.json'));
                     if (!raw)
                         continue;
                     if (raw.tenantId !== tenantId)
@@ -798,12 +810,6 @@ export class DiskSessionStore {
         };
     }
 }
-function emptyLinkageView() {
-    return {
-        findChildSubSessions: () => [],
-        findParentSubSession: () => null,
-    };
-}
 // Serialization helpers -----------------------------------------------------
 function serializeProject(p) {
     return {
@@ -813,6 +819,7 @@ function serializeProject(p) {
         config: p.config,
         status: p.status,
         ownerVersion: p.ownerVersion,
+        ...(p.rootPath !== undefined ? { rootPath: p.rootPath } : {}),
         createdAt: p.createdAt.toISOString(),
         updatedAt: p.updatedAt.toISOString(),
     };
@@ -824,11 +831,12 @@ function deserializeProject(p) {
         name: p.name,
         config: p.config,
         // A project.json written before these fields existed reads as an open
-        // workspace at version 0, which is what it was. Leaving `ownerVersion`
+        // project at version 0, which is what it was. Leaving `ownerVersion`
         // undefined would be worse than a wrong default: every compare-and-set
         // against it would fail, so an existing store could never be closed.
         status: p.status ?? 'open',
         ownerVersion: p.ownerVersion ?? 0,
+        ...(p.rootPath !== undefined ? { rootPath: p.rootPath } : {}),
         createdAt: new Date(p.createdAt),
         updatedAt: new Date(p.updatedAt),
     };
@@ -836,7 +844,7 @@ function deserializeProject(p) {
 function serializeSession(s) {
     return {
         id: s.id,
-        threadId: s.threadId,
+        topicId: s.topicId,
         projectId: s.projectId,
         tenantId: s.tenantId,
         status: s.status,
@@ -851,7 +859,7 @@ function serializeSession(s) {
 function deserializeSession(s) {
     return {
         id: s.id,
-        threadId: s.threadId,
+        topicId: s.topicId,
         projectId: s.projectId,
         tenantId: s.tenantId,
         status: s.status,
@@ -935,26 +943,4 @@ function deserializeSummary(s) {
         materializedBy: 'kernel',
     };
 }
-// FS helpers -----------------------------------------------------------------
-async function readJson(path) {
-    try {
-        const raw = await readFile(path, 'utf-8');
-        // Through the schema rather than a bare cast: a record from an older
-        // build is brought forward, and one from a NEWER build is refused
-        // instead of read partially and written back with the difference
-        // gone.
-        return migrate(SCHEMA, JSON.parse(raw));
-    }
-    catch (err) {
-        const code = err.code;
-        if (code === 'ENOENT')
-            return null;
-        throw err;
-    }
-}
-async function atomicWriteJson(filePath, value) {
-    // Through the shared writer: the sidecar name has to be private to this
-    // write, and a fixed `.tmp` is shared by every writer of the record.
-    await atomicWriteFile(filePath, JSON.stringify(stamp(SCHEMA, value), null, 2));
-}
 //# sourceMappingURL=disk.js.map