@namzu/cli 34.1.1 → 36.0.0

package/dist/integrations/sessions/store.js

@@ -1,780 +0,0 @@
-/**
- * Conversation persistence for the CLI, built on the SDK's session log.
- *
- * Every conversation is one session: an append-only, hash-chained JSONL file
- * at `$NAMZU_HOME/projects/<slug>/<session-id>.jsonl`. The log is the source
- * of truth. The rebuildable index at `$NAMZU_HOME/index.sqlite` answers the
- * questions a list needs (which sessions this project has, which one a
- * desktop key names) and is refreshed from the log after every write here.
- *
- * The CLI writes only the records that happen outside a turn: the
- * `session_started` that creates a conversation, `session_updated` for its
- * title, archive flag and caller-side names, and the `compaction` record that
- * seeds a fork with the history it copied. Messages and turns are appended by
- * the kernel's turn recorder while `query()` runs, under the session lease.
- *
- * This is what powers `/resume`: list recent sessions, fold a chosen
- * session's messages, and keep chatting in it. The project is the canonical
- * checkout root, so every directory of one checkout shares its history.
- */
-import { createHash, randomUUID } from 'node:crypto';
-import { mkdirSync } from 'node:fs';
-import { readdir, realpath } from 'node:fs/promises';
-import { basename, resolve } from 'node:path';
-import { join } from 'node:path';
-import { isDeepStrictEqual } from 'node:util';
-import { DiskSessionGoalStore, DiskSessionLog, SessionPaths, asSessionId, asTopicId, ensureProject, foldSessionMessages, generateSessionId, isEntityId, openSessionIndex, readSessionLog, } from '@namzu/sdk';
-import { resolveNamzuHome } from '../state/home.js';
-import { loadIdentity } from '../state/identity.js';
-import { ensurePrivateStateDirectory } from '../state/private-directory.js';
-import { cliProjectRoot } from '../state/project.js';
-/** Who created a conversation, as its `session_started.agent` records it. */
-const CLI_AGENT = { id: 'namzu-cli', name: 'Namzu' };
-/** How long a write outside a turn waits for a lease another writer holds. */
-const LEASE_WAIT_MS = 5_000;
-const LEASE_POLL_MS = 25;
-const LEASE_TTL_MS = 30_000;
-/**
- * Open (or initialize) the working directory's project: `projects/<slug>/`
- * with its `project.json`, the installation's tenant, and the index.
- *
- * The project is the nearest checkout root (a `.git` file or directory), so
- * worktrees and nested repositories keep distinct history while every
- * directory of one checkout shares it. Tool cwd is unchanged.
- */
-export async function openSessions(cwd, options = {}) {
-    const workingDirectory = await realpath(resolve(cwd));
-    const root = resolve(options.stateRoot ??
-        resolveNamzuHome({
-            ...(options.home !== undefined ? { home: options.home } : {}),
-            ...(options.env !== undefined ? { env: options.env } : {}),
-        }));
-    mkdirSync(root, { recursive: true });
-    // The installation owns the tenant; the canonical checkout owns the Project.
-    const tenantId = loadIdentity(root).tenantId;
-    const projectsDir = ensurePrivateStateDirectory(root, 'projects');
-    const project = await ensureProject({ home: root, cwd: cliProjectRoot(workingDirectory) });
-    ensurePrivateStateDirectory(projectsDir, project.slug);
-    const paths = new SessionPaths({ home: root, slug: project.slug });
-    const index = await openSessionIndex({
-        home: root,
-        ...(options.indexBackend ? { backend: options.indexBackend } : {}),
-    });
-    const partial = {
-        root,
-        paths,
-        slug: project.slug,
-        projectRoot: project.cwd,
-        projectId: project.projectId,
-        topicId: topicIdFor(project.projectId),
-        tenantId,
-        index,
-    };
-    const store = {
-        getSession: (sessionId, tenant) => readSessionEntity(partial, sessionId, tenant),
-    };
-    return {
-        ...partial,
-        store,
-        goals: new DiskSessionGoalStore({ rootDir: paths.projectDir(), sessions: store }),
-    };
-}
-/** Release the index's database handle. Idempotent. */
-export function closeSessions(s) {
-    try {
-        s.index.close();
-    }
-    catch {
-        // Already closed.
-    }
-}
-/** One stable CLI topic per logical workspace, without an extra binding file. */
-function topicIdFor(projectId) {
-    const digest = createHash('sha256').update(`namzu:cli-topic:${projectId}`).digest('hex');
-    return asTopicId(`${digest.slice(0, 8)}-${digest.slice(8, 12)}-8${digest.slice(13, 16)}-a${digest.slice(17, 20)}-${digest.slice(20, 32)}`);
-}
-// ─── the log ──────────────────────────────────────────────────────────────
-/** The file a root conversation's log lives in. */
-export function conversationLogPath(s, sessionId) {
-    return s.paths.sessionLog({ sessionId });
-}
-/** A writer handle on one conversation's log. */
-export function openConversationLog(s, sessionId) {
-    return DiskSessionLog.at(s.paths, { sessionId });
-}
-function holderName() {
-    return `namzu-cli:${process.pid}:${randomUUID()}`;
-}
-/**
- * Take a conversation's writer lease, waiting briefly for another writer.
- *
- * A turn holds the lease while it runs, so a write between turns only ever
- * waits for a turn that is settling. One that is still running when the wait
- * ends is refused by name rather than waited on indefinitely.
- */
-async function claimLease(log, op) {
-    const deadline = Date.now() + LEASE_WAIT_MS;
-    const holder = holderName();
-    for (;;) {
-        const lease = await log.claim({ holder, ttlMs: LEASE_TTL_MS });
-        if (lease)
-            return lease;
-        if (Date.now() >= deadline) {
-            throw new Error(`Conversation ${log.sessionId} is busy: another writer holds it — ${op} rejected. Wait for its turn to finish and try again.`);
-        }
-        await new Promise((resolveWait) => setTimeout(resolveWait, LEASE_POLL_MS));
-    }
-}
-/** Append records outside any turn, under a lease taken for just these records. */
-async function appendOutsideTurn(s, sessionId, drafts, op) {
-    const log = openConversationLog(s, sessionId);
-    const lease = await claimLease(log, op);
-    try {
-        for (const draft of drafts)
-            await log.append(lease, draft);
-    }
-    finally {
-        await log.release(lease);
-    }
-    await refreshIndex(s, sessionId);
-}
-/** Bring the index's row for one conversation up to date with its log. */
-export async function refreshIndex(s, sessionId) {
-    await s.index.refresh({ slug: s.slug, logPath: conversationLogPath(s, sessionId), sessionId });
-}
-/**
- * Read one conversation's log, or `null` when there is none.
- *
- * Strict by default: a log whose chain is broken is not something to resume
- * or fork. A list passes `tolerant` and reads what precedes the break.
- */
-export async function readConversationFacts(s, sessionId, mode = 'strict') {
-    const read = await readSessionLog(conversationLogPath(s, sessionId), { mode, sessionId });
-    const records = read.entries.map((entry) => entry.record);
-    const first = records[0];
-    if (first === undefined || first.type !== 'session_started')
-        return null;
-    let title;
-    let named = false;
-    let archived = false;
-    let active;
-    for (const record of records) {
-        switch (record.type) {
-            case 'session_updated':
-                if (record.title !== undefined) {
-                    title = record.title;
-                    named = record.titleSource === 'named' && record.title.length > 0;
-                }
-                if (record.archived !== undefined)
-                    archived = record.archived;
-                break;
-            case 'turn_started':
-                active = { turnId: record.turnId, paused: false };
-                break;
-            case 'turn_paused':
-                if (active?.turnId === record.turnId)
-                    active = { ...active, paused: true };
-                break;
-            case 'turn_resuming':
-                if (active?.turnId === record.turnId)
-                    active = { ...active, paused: false };
-                break;
-            case 'turn_completed':
-            case 'turn_failed':
-                if (active?.turnId === record.turnId)
-                    active = undefined;
-                break;
-        }
-    }
-    return {
-        sessionId,
-        started: first,
-        ...(title !== undefined ? { title } : {}),
-        named,
-        archived,
-        createdAt: first.ts,
-        updatedAt: records.at(-1)?.ts ?? first.ts,
-        ...(active ? { activeTurn: active } : {}),
-        records,
-    };
-}
-/** The folded conversation a log's records describe, spills read back. */
-async function foldConversation(s, sessionId, records) {
-    const log = openConversationLog(s, sessionId);
-    return await foldSessionMessages(records, { readSpill: (ref) => log.readSpill(ref) });
-}
-async function readSessionEntity(s, sessionId, tenantId) {
-    if (!isEntityId(sessionId, 'session'))
-        return null;
-    const facts = await readConversationFacts(s, sessionId, 'tolerant');
-    if (!facts)
-        return null;
-    const recordedTenant = facts.started.tenantId;
-    if (recordedTenant !== undefined && recordedTenant !== tenantId)
-        return null;
-    return {
-        id: sessionId,
-        topicId: facts.started.topicId ?? topicIdFor(facts.started.projectId),
-        projectId: facts.started.projectId,
-        tenantId,
-        status: facts.archived ? 'archived' : 'idle',
-        currentActor: null,
-        previousActors: [],
-        workspaceId: null,
-        ownerVersion: 0,
-        createdAt: new Date(facts.createdAt),
-        updatedAt: new Date(facts.updatedAt),
-    };
-}
-/**
- * Start a fresh conversation; returns its session id.
- *
- * Writes the log's first record, `session_started`, naming the project, the
- * tenant and the CLI topic. An id that already has a log is refused: two
- * conversations never share one.
- */
-export async function startConversation(s, idOrOptions) {
-    const options = typeof idOrOptions === 'string' ? { id: idOrOptions } : (idOrOptions ?? {});
-    const id = options.id ?? generateSessionId();
-    const log = openConversationLog(s, id);
-    const lease = await claimLease(log, 'start conversation');
-    try {
-        if ((await log.head()) !== null) {
-            throw new Error(`Conversation ${id} already exists — start conversation rejected.`);
-        }
-        await log.append(lease, {
-            type: 'session_started',
-            projectId: s.projectId,
-            tenantId: s.tenantId,
-            topicId: s.topicId,
-            cwd: s.projectRoot,
-            agent: { ...CLI_AGENT },
-            origin: options.origin ?? { protocol: 'cli' },
-        });
-    }
-    finally {
-        await log.release(lease);
-    }
-    await refreshIndex(s, id);
-    return id;
-}
-/**
- * Give a session log its `session_started` if it has none yet, so a turn can
- * begin in it. A log that already starts is left alone. Used where a session
- * is brought into existence by its first turn rather than by
- * {@link startConversation}: a headless scope, an in-memory log.
- */
-export async function ensureSessionStarted(log, session) {
-    if ((await log.head()) !== null)
-        return;
-    const lease = await claimLease(log, 'start session');
-    try {
-        if ((await log.head()) !== null)
-            return;
-        await log.append(lease, {
-            type: 'session_started',
-            projectId: session.projectId,
-            tenantId: session.tenantId,
-            topicId: session.topicId,
-            cwd: session.cwd,
-            agent: { ...session.agent },
-            origin: session.origin ?? { protocol: 'cli' },
-        });
-    }
-    finally {
-        await log.release(lease);
-    }
-}
-/** The external id a desktop key is filed under: scoped to the project, like the map it replaces. */
-function desktopExternalId(projectId, key) {
-    return JSON.stringify([projectId, key]);
-}
-/**
- * Resolve (creating if needed) the conversation bound to an embedder's
- * session key. The binding is the conversation's own `session_started.origin`,
- * so a later turn or history load with the same key reuses it, and an index
- * rebuild finds it again.
- */
-export async function resolveConversation(s, key) {
-    const existing = await findMappedConversation(s, key);
-    if (existing) {
-        await requireWritableConversation(s, existing, 'continue keyed conversation');
-        return existing;
-    }
-    const id = await startConversation(s, {
-        origin: { protocol: 'desktop', externalSessionId: desktopExternalId(s.projectId, key) },
-    });
-    // Another process may have claimed the key while this one was creating. The
-    // earliest claim wins the name; a loser archives its empty conversation so it
-    // never shows up in `/resume` as a second, indistinguishable row.
-    const winner = await findMappedConversation(s, key);
-    if (winner && winner !== id) {
-        await archiveConversation(s, id).catch(() => undefined);
-        await requireWritableConversation(s, winner, 'continue keyed conversation');
-        return winner;
-    }
-    return id;
-}
-/** Read an external-session binding without creating or widening its scope. */
-export async function findMappedConversation(s, key) {
-    const target = await s.index.resolveExternal('desktop', 'session', desktopExternalId(s.projectId, key));
-    if (!target)
-        return null;
-    const facts = await readConversationFacts(s, target.sessionId, 'tolerant');
-    return facts?.started.projectId === s.projectId ? target.sessionId : null;
-}
-/**
- * Resolve a conversation through this project.
- *
- * A session id names a file under this project's directory, so a log that
- * exists proves the conversation is this project's; the project id it
- * recorded must also agree, and so must the tenant.
- */
-async function requireConversationInScope(s, sessionId, op) {
-    const facts = await readConversationFacts(s, sessionId);
-    if (!facts) {
-        throw new Error(`Conversation ${sessionId} was not found — ${op} rejected`);
-    }
-    if (facts.started.projectId !== s.projectId ||
-        (facts.started.tenantId !== undefined && facts.started.tenantId !== s.tenantId)) {
-        throw new Error(`Conversation ${sessionId} does not belong to this workspace — ${op} rejected`);
-    }
-    return facts;
-}
-/**
- * Sequential admission gate for a turn or conversation mutation: the target
- * exists in this project and is not archived. It is not a cross-process
- * transaction; the session lease is what serialises writers.
- */
-export async function requireWritableConversation(s, sessionId, op = 'continue conversation') {
-    const facts = await requireConversationInScope(s, sessionId, op);
-    if (facts.archived) {
-        throw new Error(`Conversation ${sessionId} is archived and read-only — ${op} rejected. Its history remains available for inspection.`);
-    }
-}
-/**
- * Change the archive flag while holding the session's writer lease. The
- * earlier scope check prevents a missing log from being created by a lease
- * claim; the second check is the authoritative one after competing writers
- * have settled. An open turn, including one parked for a human, is not a
- * stable boundary to archive. Older versions could archive such a turn; a
- * restore must be allowed so the owner can resume or abandon it explicitly.
- */
-async function setConversationArchived(s, sessionId, archived) {
-    const op = archived ? 'archive conversation' : 'restore conversation';
-    await requireConversationInScope(s, sessionId, op);
-    const log = openConversationLog(s, sessionId);
-    const lease = await claimLease(log, op);
-    let changed = false;
-    try {
-        const facts = await requireConversationInScope(s, sessionId, op);
-        if (facts.archived === archived) {
-            throw new Error(`Conversation ${sessionId} is already ${archived ? 'archived' : 'active'}.`);
-        }
-        if (archived && facts.activeTurn) {
-            throw new Error(`Conversation ${sessionId} has an open turn — ${op} rejected. Resume or abandon that turn first.`);
-        }
-        await log.append(lease, { type: 'session_updated', archived });
-        changed = true;
-    }
-    finally {
-        await log.release(lease);
-    }
-    if (changed) {
-        try {
-            await refreshIndex(s, sessionId);
-        }
-        catch (refreshCause) {
-            // The append is already durable. A full sync can repair a failed
-            // incremental refresh without telling the operator the transition did
-            // not happen. If even that fails, name the actual durable state.
-            try {
-                await s.index.sync(s.root);
-            }
-            catch (syncCause) {
-                throw new ConversationIndexRefreshError(sessionId, archived, refreshCause, syncCause);
-            }
-        }
-    }
-}
-/** The log changed durably, but the rebuildable listing index could not catch up. */
-export class ConversationIndexRefreshError extends Error {
-    sessionId;
-    archived;
-    refreshCause;
-    syncCause;
-    constructor(sessionId, archived, refreshCause, syncCause) {
-        super(`Conversation ${sessionId} was ${archived ? 'archived' : 'restored'} in its durable log, but the list index could not refresh. Restart Namzu to rebuild the list, then inspect its state.`);
-        this.sessionId = sessionId;
-        this.archived = archived;
-        this.refreshCause = refreshCause;
-        this.syncCause = syncCause;
-        this.name = 'ConversationIndexRefreshError';
-    }
-}
-/** Make a settled conversation read-only while preserving its log. */
-export async function archiveConversation(s, sessionId) {
-    await setConversationArchived(s, sessionId, true);
-}
-/** Restore one archived conversation so the ordinary resume gate admits it. */
-export async function unarchiveConversation(s, sessionId) {
-    await setConversationArchived(s, sessionId, false);
-}
-/** Load a conversation's folded message history. */
-export async function loadConversation(s, sessionId) {
-    const facts = await requireConversationInScope(s, sessionId, 'load conversation history');
-    return await foldConversation(s, sessionId, facts.records);
-}
-/**
- * Load one conversation for a new model turn.
- *
- * Reading an archived conversation remains legitimate — `history` and export
- * are inspection surfaces — but resuming it would turn a tombstone back into a
- * live writer without a restore operation.
- */
-export async function loadResumableConversation(s, sessionId) {
-    const checked = asSessionId(sessionId);
-    await requireWritableConversation(s, checked, 'resume conversation');
-    return await loadConversation(s, checked);
-}
-/** The open turn of a conversation, if it has one: `paused` when it is parked. */
-export async function activeConversationTurn(s, sessionId) {
-    return (await requireConversationInScope(s, sessionId, 'inspect conversation')).activeTurn;
-}
-/** Recent non-empty conversations, newest first — for the `/resume` list. */
-export async function listRecent(s, limit = 20) {
-    return listConversations(s, false, limit);
-}
-/** Archived root conversations in this project, newest first. Empty ones remain discoverable. */
-export async function listArchived(s, limit = 100, offset = 0) {
-    await refreshProjectArchiveIndex(s);
-    return listConversations(s, true, limit, offset);
-}
-/**
- * The scan backend is a per-process snapshot. Another CLI process may have
- * archived a conversation after this handle opened; querying its old rows
- * alone would claim there are no archives. Refresh only root logs in the
- * selected project, and coalesce overlapping picker/list requests against
- * this index. Unchanged logs cost a head check, not another full fold.
- */
-const archiveListingRefreshes = new WeakMap();
-async function refreshProjectArchiveIndex(s) {
-    if (s.index.backend !== 'scan')
-        return;
-    let pending = archiveListingRefreshes.get(s.index);
-    if (!pending) {
-        pending = (async () => {
-            const entries = await readdir(s.paths.projectDir(), { withFileTypes: true });
-            for (const entry of entries) {
-                if (!entry.isFile() || !entry.name.endsWith('.jsonl'))
-                    continue;
-                const rawId = entry.name.slice(0, -'.jsonl'.length);
-                if (!isEntityId(rawId, 'session'))
-                    continue;
-                const sessionId = asSessionId(rawId);
-                await s.index.refresh({
-                    slug: s.slug,
-                    logPath: conversationLogPath(s, sessionId),
-                    sessionId,
-                });
-            }
-        })().finally(() => {
-            archiveListingRefreshes.delete(s.index);
-        });
-        archiveListingRefreshes.set(s.index, pending);
-    }
-    await pending;
-}
-async function listConversations(s, archived, limit, offset = 0) {
-    const boundedLimit = Number.isFinite(limit) ? Math.max(0, Math.min(Math.floor(limit), 100)) : 100;
-    const boundedOffset = Number.isSafeInteger(offset) && offset > 0 ? offset : 0;
-    if (boundedLimit === 0)
-        return [];
-    // The index is rebuilt from logs on open and refreshed on every transition.
-    // Filter there before reading a full log: an installation with thousands of
-    // archived conversations must not fold them all to draw /resume. Recheck
-    // each candidate's actual log and owner before exposing it.
-    const rows = (await s.index.listSessions({
-        slug: s.slug,
-        rootsOnly: true,
-        includeArchived: archived,
-    }))
-        .filter((row) => row.projectId === s.projectId && row.archived === archived)
-        .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
-        .slice(boundedOffset, boundedOffset + Math.max(100, boundedLimit * 5));
-    const out = [];
-    for (const row of rows) {
-        let facts;
-        let messages;
-        try {
-            facts = await readConversationFacts(s, row.id, 'tolerant');
-            if (!facts ||
-                facts.archived !== archived ||
-                facts.started.projectId !== s.projectId ||
-                (facts.started.tenantId !== undefined && facts.started.tenantId !== s.tenantId))
-                continue;
-            messages = await foldConversation(s, row.id, facts.records);
-        }
-        catch {
-            // A log this process cannot read is not a row a person can resume.
-            continue;
-        }
-        if (!archived && messages.length === 0)
-            continue;
-        const everything = recordedMessages(facts.records);
-        out.push({
-            id: row.id,
-            title: facts.title !== undefined &&
-                facts.title.length > 0 &&
-                (facts.named || facts.title !== 'Conversation')
-                ? facts.title
-                : conversationTitle(everything),
-            preview: [...everything]
-                .reverse()
-                .find((message) => message.role === 'user' && message.source === undefined)
-                ?.content.replace(/\s+/g, ' ')
-                .trim()
-                .slice(0, 240),
-            named: facts.named,
-            updatedAt: facts.updatedAt,
-            count: messages.length,
-        });
-        if (out.length >= boundedLimit)
-            break;
-    }
-    return out.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-}
-/** The name a person gave this conversation, or `undefined`. */
-export async function titleOf(s, sessionId) {
-    const facts = await readConversationFacts(s, sessionId, 'tolerant');
-    return facts?.named ? facts.title : undefined;
-}
-/**
- * Name a conversation, or with an empty name, take the name away.
- *
- * Recorded as `session_updated{title, titleSource: 'named'}`; clearing records
- * an empty derived title, so the list derives one from the first message
- * again rather than showing a blank row.
- */
-export async function setTitle(s, sessionId, title) {
-    await requireConversationInScope(s, sessionId, 'name conversation');
-    const trimmed = title.trim();
-    await appendOutsideTurn(s, sessionId, [
-        trimmed === ''
-            ? { type: 'session_updated', title: '', titleSource: 'derived' }
-            : { type: 'session_updated', title: trimmed, titleSource: 'named' },
-    ], 'name conversation');
-}
-/**
- * Seed a conversation that has no turns yet with a history, as one
- * `compaction` record outside any turn: the fold starts from its summary, so
- * the new conversation's context is exactly `messages`. Used by forks.
- */
-export async function seedConversationHistory(s, sessionId, messages, strategy = 'fork') {
-    if (messages.length === 0)
-        return;
-    await appendOutsideTurn(s, sessionId, [
-        {
-            type: 'compaction',
-            compactionId: randomUUID(),
-            strategy,
-            trigger: 'manual',
-            replacesSeqRange: [1, 1],
-            summary: [...messages],
-            keptMessageIds: [],
-            tokensBefore: 0,
-            tokensAfter: 0,
-        },
-    ], 'seed conversation history');
-}
-/**
- * Continue in a copy, leaving the original where it is.
- *
- * The copy is a real Session with the transcript written into it, not a
- * pointer: the two diverge from here, and a pointer would make the original's
- * later turns appear in the fork.
- *
- * **The fork is always named, and that is the load-bearing part.** Both
- * conversations start with the same first message, so both DERIVE the same
- * title — and `/resume` would show two rows a person cannot tell apart. The
- * name is taken from the source's own, so a fork of a fork stays readable, and
- * it is numbered against the names already in use.
- */
-export async function forkConversation(s, sourceId) {
-    await requireWritableConversation(s, sourceId, 'fork conversation');
-    const messages = await loadConversation(s, sourceId);
-    if (messages.length === 0) {
-        // Refused rather than served. A fork of nothing is an empty session
-        // that shows up in `/resume` forever and answers no question.
-        throw new Error('There is nothing to fork yet — this conversation has no messages.');
-    }
-    const { id, title } = await writeFork(s, s, sourceId, messages, messages);
-    return { id, title, copied: messages.length };
-}
-/**
- * Copy a settled conversation into another checkout's Project under the same
- * Namzu installation. A managed worktree is a distinct Project, so a normal
- * same-Project fork cannot be resumed there.
- */
-export async function forkConversationInto(source, target, sourceId) {
-    if (source.root !== target.root || source.tenantId !== target.tenantId) {
-        throw new Error('A conversation can only be forked within the same Namzu installation.');
-    }
-    const facts = await requireConversationInScope(source, sourceId, 'fork conversation to worktree');
-    if (facts.archived) {
-        throw new Error(`Conversation ${sourceId} is archived and cannot be forked.`);
-    }
-    if (facts.activeTurn) {
-        throw new Error('Wait for the current turn to finish before forking to a worktree.');
-    }
-    const messages = await loadConversation(source, sourceId);
-    if (messages.length === 0) {
-        throw new Error('There is nothing to fork yet — this conversation has no messages.');
-    }
-    const { id, title } = await writeFork(source, target, sourceId, messages, messages);
-    return { id, title, copied: messages.length };
-}
-/**
- * Content equality ignoring the durable id a message's own record carries.
- *
- * A message read twice from the SAME conversation names the same id both
- * times, so this only matters where it stops being the same conversation:
- * a fork's copy is a brand new record for the same content, under a new
- * id, in the new conversation's own log — the kernel names it, and that
- * name being new is the point, not a sign the content itself changed.
- */
-function sameMessageContent(a, b) {
-    const { id: _a, ...restA } = a;
-    const { id: _b, ...restB } = b;
-    return isDeepStrictEqual(JSON.parse(JSON.stringify(restA)), JSON.parse(JSON.stringify(restB)));
-}
-function sameMessageSequence(a, b) {
-    return (a.length === b.length &&
-        a.every((message, index) => sameMessageContent(message, b[index])));
-}
-/**
- * Fork immediately before one durable user message.
- *
- * `userOrdinal` is zero-based among user messages, not among every message.
- * The expected message is a compare-and-swap guard: a picker selects from an
- * in-memory history, then this helper reloads disk. If another write changed
- * that position, it refuses BEFORE creating a session instead of branching at
- * a boundary the operator did not select.
- *
- * An empty prefix is valid. Editing the first prompt creates an empty branch
- * and restores that prompt to the composer.
- */
-export async function forkConversationBeforeUser(s, sourceId, userOrdinal, expected) {
-    if (!Number.isInteger(userOrdinal) || userOrdinal < 0) {
-        throw new Error('The selected user-message position is invalid.');
-    }
-    await requireWritableConversation(s, sourceId, 'fork conversation before a prompt');
-    const messages = await loadConversation(s, sourceId);
-    let seen = -1;
-    const messageIndex = messages.findIndex((message) => {
-        if (message.role !== 'user')
-            return false;
-        seen += 1;
-        return seen === userOrdinal;
-    });
-    const selected = messages[messageIndex];
-    if (messageIndex < 0 || selected?.role !== 'user') {
-        throw new Error('The selected user message no longer exists in this conversation.');
-    }
-    if (!sameMessageContent(selected, expected)) {
-        throw new Error('The conversation changed after the prompt was selected. Nothing was forked; open the editor again from the current history.');
-    }
-    const prefix = messages.slice(0, messageIndex);
-    const { id, title } = await writeFork(s, s, sourceId, messages, prefix);
-    return { id, title, messages: prefix, selected };
-}
-/** Create, seed and name one fork after every boundary decision has been validated. */
-async function writeFork(sourceStore, targetStore, sourceId, sourceMessages, copiedMessages) {
-    const sourceFacts = await readConversationFacts(sourceStore, sourceId, 'tolerant');
-    const source = sourceFacts?.title !== undefined && sourceFacts.title.length > 0
-        ? sourceFacts.title
-        : conversationTitle(sourceFacts ? recordedMessages(sourceFacts.records) : sourceMessages);
-    const id = await startConversation(targetStore);
-    await seedConversationHistory(targetStore, id, copiedMessages);
-    const copiedBack = await loadConversation(targetStore, id);
-    if (!sameMessageSequence(copiedBack, copiedMessages)) {
-        throw new Error(`The forked conversation did not preserve its exact copied history (${id}).`);
-    }
-    const title = nextForkName(await takenTitles(targetStore), source);
-    await setTitle(targetStore, id, title);
-    return { id, title };
-}
-/** Every title in use among this project's conversations, keyed by session id. */
-async function takenTitles(s) {
-    const taken = {};
-    for (const row of await s.index.listSessions({ slug: s.slug, rootsOnly: true })) {
-        if (row.title !== undefined && row.title.length > 0)
-            taken[row.id] = row.title;
-    }
-    return taken;
-}
-/**
- * Every message the log ever recorded, in order: a fork's seeded history and
- * each `message` record, before any compaction or replacement folds them.
- *
- * A derived title and the list preview are read from this rather than from
- * the fold, so compacting a conversation away from its opening question does
- * not rename it: the opening message is still in the log.
- */
-function recordedMessages(records) {
-    const out = [];
-    for (const record of records) {
-        if (record.type === 'message')
-            out.push(record.content);
-        else if (record.type === 'compaction' && Array.isArray(record.summary)) {
-            if (record.strategy === 'fork')
-                out.push(...record.summary);
-        }
-    }
-    return out;
-}
-/**
- * `X (fork)`, then `X (fork 2)`, `X (fork 3)`.
- *
- * Numbered against the names in use rather than against a count of forks,
- * because a name that was removed frees its number and a fork that was renamed
- * never held one.
- */
-export function nextForkName(taken, source) {
-    const used = new Set(Object.values(taken));
-    const first = `${source} (fork)`;
-    if (!used.has(first))
-        return first;
-    for (let n = 2; n < 1000; n += 1) {
-        const candidate = `${source} (fork ${n})`;
-        if (!used.has(candidate))
-            return candidate;
-    }
-    // A thousand forks of one conversation is not a case worth a cleverer
-    // answer, and a name that repeats is better than a refusal here.
-    return `${source} (fork)`;
-}
-export function conversationTitle(messages) {
-    const firstHuman = messages.find((message) => message.role === 'user' && message.source === undefined);
-    const firstGoal = messages.find((message) => message.role === 'user' && message.source?.type === 'goal-round');
-    const raw = firstHuman?.role === 'user'
-        ? firstHuman.content
-        : firstGoal?.role === 'user' && firstGoal.source?.type === 'goal-round'
-            ? firstGoal.source.objective
-            : 'Conversation';
-    const text = raw.replace(/\s+/g, ' ').trim();
-    return text.length > 60 ? `${text.slice(0, 59)}…` : text || 'Conversation';
-}
-/** The project directory name, for messages that point a person at it. */
-export function projectLabel(s) {
-    return basename(s.projectRoot) || s.projectRoot;
-}
-/** Where a conversation's per-session files live (`<session-id>/`). */
-export function conversationDir(s, sessionId) {
-    return s.paths.sessionDir({ sessionId });
-}
-/** The project's directory under `NAMZU_HOME` (`projects/<slug>/`). */
-export function projectDir(s) {
-    return join(s.root, 'projects', s.slug);
-}
-//# sourceMappingURL=store.js.map