@namzu/cli 35.0.0 → 36.1.0

package/dist/chunks/chunk-TIGWWAJI.js

@@ -0,0 +1,765 @@
+import { createRequire as __namzuCreateRequire } from 'node:module';
+const require = __namzuCreateRequire(import.meta.url);
+import {
+  cliProjectRoot
+} from "./chunk-H6B6AROX.js";
+import {
+  ensurePrivateStateDirectory,
+  publishPrivateJsonIfAbsent
+} from "./chunk-A5UXODFL.js";
+import {
+  palAtWorkspace
+} from "./chunk-OLPOM3DR.js";
+import {
+  DiskSessionGoalStore,
+  DiskSessionLog,
+  SessionPaths,
+  asSessionId,
+  asTenantId,
+  asTopicId,
+  ensureProject,
+  foldSessionMessages,
+  generateSessionId,
+  generateTenantId,
+  isEntityId,
+  openSessionIndex,
+  readSessionLog,
+  resolveNamzuHome
+} from "./chunk-EWKJGHRO.js";
+import {
+  __name
+} from "./chunk-76FLAFCG.js";
+
+// src/integrations/sessions/store.ts
+import { createHash, randomUUID } from "node:crypto";
+import { lstatSync, mkdirSync } from "node:fs";
+import { lstat, readdir, realpath } from "node:fs/promises";
+import { basename, resolve } from "node:path";
+import { join as join2 } from "node:path";
+import { isDeepStrictEqual } from "node:util";
+
+// src/integrations/state/identity.ts
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+var FILE = "identity.json";
+function readIdentity(home) {
+  const path = join(home, FILE);
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf8"));
+    if (raw && !Array.isArray(raw) && typeof raw.tenantId === "string") {
+      return {
+        tenantId: asTenantId(raw.tenantId),
+        createdAt: typeof raw.createdAt === "string" ? raw.createdAt : ""
+      };
+    }
+    throw new Error("expected an object containing a tenantId string");
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw new Error(
+        `${path} is not a readable identity file: ${error instanceof Error ? error.message : String(error)}. Fix or remove it; a new one is minted when it is absent.`
+      );
+    }
+  }
+  return null;
+}
+__name(readIdentity, "readIdentity");
+function loadIdentity(home) {
+  const existing = readIdentity(home);
+  if (existing) return existing;
+  const path = join(home, FILE);
+  const identity = { tenantId: generateTenantId(), createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+  publishPrivateJsonIfAbsent(path, identity);
+  const published = readIdentity(home);
+  if (!published)
+    throw new Error(`${path} disappeared while initializing the installation identity`);
+  return published;
+}
+__name(loadIdentity, "loadIdentity");
+
+// src/integrations/sessions/display-title.ts
+function displayConversationTitle(title) {
+  return /^⏲ .+ · .+$/u.test(title) ? `Scheduled: ${title.slice(2)}` : title;
+}
+__name(displayConversationTitle, "displayConversationTitle");
+var ATTACHMENT_BLOCK = /(?:^|\n\n)Attached (?:text file|image): ("(?:[^"\\\n]|\\.)*")/u;
+function typedTextOf(content) {
+  const match = ATTACHMENT_BLOCK.exec(content);
+  if (!match) return { text: content };
+  let firstFile;
+  try {
+    const parsed = JSON.parse(match[1] ?? "");
+    if (typeof parsed === "string" && parsed) firstFile = parsed;
+  } catch {
+  }
+  return { text: content.slice(0, match.index), ...firstFile ? { firstFile } : {} };
+}
+__name(typedTextOf, "typedTextOf");
+
+// src/integrations/sessions/store.ts
+var CLI_AGENT = { id: "namzu-cli", name: "Namzu" };
+var LEASE_WAIT_MS = 5e3;
+var LEASE_POLL_MS = 25;
+var LEASE_TTL_MS = 3e4;
+async function openSessionScope(cwd, options = {}) {
+  const workingDirectory = await realpath(resolve(cwd));
+  const root = resolve(
+    options.stateRoot ?? resolveNamzuHome({
+      ...options.home !== void 0 ? { home: options.home } : {},
+      ...options.env !== void 0 ? { env: options.env } : {}
+    })
+  );
+  mkdirSync(root, { recursive: true });
+  const tenantId = loadIdentity(root).tenantId;
+  const projectsDir = ensurePrivateStateDirectory(root, "projects");
+  const pal = palAtWorkspace(cwd, root);
+  const palDirectory = pal ? lstatSync(pal.workspace, { bigint: true }) : void 0;
+  const project = await ensureProject({
+    home: root,
+    cwd: pal ? workingDirectory : cliProjectRoot(workingDirectory)
+  });
+  if (pal && palDirectory) {
+    if (project.cwd !== pal.workspace && (process.platform !== "win32" || project.cwd.toLowerCase() !== pal.workspace.toLowerCase()))
+      throw new Error("Pal workspace identity changed while opening its conversations.");
+    const preparedDirectory = await lstat(project.cwd, { bigint: true });
+    const current = palAtWorkspace(cwd, root);
+    const liveDirectory = current ? lstatSync(current.workspace, { bigint: true }) : void 0;
+    const sameDirectory = /* @__PURE__ */ __name((entry) => entry?.isDirectory() && !entry.isSymbolicLink() && palDirectory.ino > 0n && entry.dev === palDirectory.dev && entry.ino === palDirectory.ino && entry.birthtimeNs === palDirectory.birthtimeNs, "sameDirectory");
+    if (!current || current.id !== pal.id || current.workspace !== pal.workspace || !sameDirectory(preparedDirectory) || !sameDirectory(liveDirectory))
+      throw new Error("Pal workspace identity changed while opening its conversations.");
+  }
+  ensurePrivateStateDirectory(projectsDir, project.slug);
+  const paths = new SessionPaths({ home: root, slug: project.slug });
+  const partial = {
+    root,
+    paths,
+    slug: project.slug,
+    projectRoot: pal?.workspace ?? project.cwd,
+    projectId: project.projectId,
+    topicId: topicIdFor(project.projectId),
+    tenantId
+  };
+  const store = {
+    getSession: /* @__PURE__ */ __name((sessionId, tenant) => readSessionEntity(partial, sessionId, tenant), "getSession")
+  };
+  return { ...partial, store };
+}
+__name(openSessionScope, "openSessionScope");
+async function openSessions(cwd, options = {}) {
+  const scope = await openSessionScope(cwd, options);
+  const index = await openSessionIndex({
+    home: scope.root,
+    ...options.indexBackend ? { backend: options.indexBackend } : {}
+  });
+  return {
+    ...scope,
+    index,
+    goals: new DiskSessionGoalStore({ rootDir: scope.paths.projectDir(), sessions: scope.store })
+  };
+}
+__name(openSessions, "openSessions");
+function closeSessions(s) {
+  try {
+    s.index.close();
+  } catch {
+  }
+}
+__name(closeSessions, "closeSessions");
+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)}`
+  );
+}
+__name(topicIdFor, "topicIdFor");
+function conversationLogPath(s, sessionId) {
+  return s.paths.sessionLog({ sessionId });
+}
+__name(conversationLogPath, "conversationLogPath");
+function openConversationLog(s, sessionId) {
+  return DiskSessionLog.at(s.paths, { sessionId });
+}
+__name(openConversationLog, "openConversationLog");
+function holderName() {
+  return `namzu-cli:${process.pid}:${randomUUID()}`;
+}
+__name(holderName, "holderName");
+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 \u2014 ${op} rejected. Wait for its turn to finish and try again.`
+      );
+    }
+    await new Promise((resolveWait) => setTimeout(resolveWait, LEASE_POLL_MS));
+  }
+}
+__name(claimLease, "claimLease");
+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);
+}
+__name(appendOutsideTurn, "appendOutsideTurn");
+async function refreshIndex(s, sessionId) {
+  await s.index.refresh({ slug: s.slug, logPath: conversationLogPath(s, sessionId), sessionId });
+}
+__name(refreshIndex, "refreshIndex");
+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 === void 0 || 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 !== void 0) {
+          title = record.title;
+          named = record.titleSource === "named" && record.title.length > 0;
+        }
+        if (record.archived !== void 0) 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 = void 0;
+        break;
+    }
+  }
+  return {
+    sessionId,
+    started: first,
+    ...title !== void 0 ? { title } : {},
+    named,
+    archived,
+    createdAt: first.ts,
+    updatedAt: records.at(-1)?.ts ?? first.ts,
+    ...active ? { activeTurn: active } : {},
+    records
+  };
+}
+__name(readConversationFacts, "readConversationFacts");
+async function foldConversation(s, sessionId, records) {
+  const log = openConversationLog(s, sessionId);
+  return await foldSessionMessages(records, { readSpill: /* @__PURE__ */ __name((ref) => log.readSpill(ref), "readSpill") });
+}
+__name(foldConversation, "foldConversation");
+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 !== void 0 && 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)
+  };
+}
+__name(readSessionEntity, "readSessionEntity");
+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 \u2014 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;
+}
+__name(startConversation, "startConversation");
+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);
+  }
+}
+__name(ensureSessionStarted, "ensureSessionStarted");
+function desktopExternalId(projectId, key) {
+  return JSON.stringify([projectId, key]);
+}
+__name(desktopExternalId, "desktopExternalId");
+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) }
+  });
+  const winner = await findMappedConversation(s, key);
+  if (winner && winner !== id) {
+    await archiveConversation(s, id).catch(() => void 0);
+    await requireWritableConversation(s, winner, "continue keyed conversation");
+    return winner;
+  }
+  return id;
+}
+__name(resolveConversation, "resolveConversation");
+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;
+}
+__name(findMappedConversation, "findMappedConversation");
+async function requireConversationInScope(s, sessionId, op) {
+  const facts = await readConversationFacts(s, sessionId);
+  if (!facts) {
+    throw new Error(`Conversation ${sessionId} was not found \u2014 ${op} rejected`);
+  }
+  if (facts.started.projectId !== s.projectId || facts.started.tenantId !== void 0 && facts.started.tenantId !== s.tenantId) {
+    throw new Error(`Conversation ${sessionId} does not belong to this workspace \u2014 ${op} rejected`);
+  }
+  return facts;
+}
+__name(requireConversationInScope, "requireConversationInScope");
+async function requireWritableConversation(s, sessionId, op = "continue conversation") {
+  const facts = await requireConversationInScope(s, sessionId, op);
+  assertWritableConversation(facts, sessionId, op);
+}
+__name(requireWritableConversation, "requireWritableConversation");
+function assertWritableConversation(facts, sessionId, op) {
+  if (facts.archived) {
+    throw new Error(
+      `Conversation ${sessionId} is archived and read-only \u2014 ${op} rejected. Its history remains available for inspection.`
+    );
+  }
+}
+__name(assertWritableConversation, "assertWritableConversation");
+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 \u2014 ${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) {
+      try {
+        await s.index.sync(s.root);
+      } catch (syncCause) {
+        throw new ConversationIndexRefreshError(sessionId, archived, refreshCause, syncCause);
+      }
+    }
+  }
+}
+__name(setConversationArchived, "setConversationArchived");
+var ConversationIndexRefreshError = class extends Error {
+  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";
+  }
+  sessionId;
+  archived;
+  refreshCause;
+  syncCause;
+  static {
+    __name(this, "ConversationIndexRefreshError");
+  }
+};
+async function archiveConversation(s, sessionId) {
+  await setConversationArchived(s, sessionId, true);
+}
+__name(archiveConversation, "archiveConversation");
+async function unarchiveConversation(s, sessionId) {
+  await setConversationArchived(s, sessionId, false);
+}
+__name(unarchiveConversation, "unarchiveConversation");
+async function loadConversation(s, sessionId) {
+  return (await loadConversationSnapshot(s, sessionId)).messages;
+}
+__name(loadConversation, "loadConversation");
+async function loadConversationSnapshot(s, sessionId) {
+  const facts = await requireConversationInScope(s, sessionId, "load conversation history");
+  return {
+    messages: await foldConversation(s, sessionId, facts.records),
+    records: facts.records
+  };
+}
+__name(loadConversationSnapshot, "loadConversationSnapshot");
+async function loadResumableConversation(s, sessionId) {
+  const checked = asSessionId(sessionId);
+  const facts = await requireConversationInScope(s, checked, "resume conversation");
+  assertWritableConversation(facts, checked, "resume conversation");
+  return await foldConversation(s, checked, facts.records);
+}
+__name(loadResumableConversation, "loadResumableConversation");
+async function activeConversationTurn(s, sessionId) {
+  return (await requireConversationInScope(s, sessionId, "inspect conversation")).activeTurn;
+}
+__name(activeConversationTurn, "activeConversationTurn");
+async function listRecent(s, limit = 20) {
+  return listConversations(s, false, limit);
+}
+__name(listRecent, "listRecent");
+async function listArchived(s, limit = 100, offset = 0) {
+  await refreshProjectArchiveIndex(s);
+  return listConversations(s, true, limit, offset);
+}
+__name(listArchived, "listArchived");
+var archiveListingRefreshes = /* @__PURE__ */ 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;
+}
+__name(refreshProjectArchiveIndex, "refreshProjectArchiveIndex");
+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 [];
+  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 !== void 0 && facts.started.tenantId !== s.tenantId)
+        continue;
+      messages = await foldConversation(s, row.id, facts.records);
+    } catch {
+      continue;
+    }
+    if (!archived && messages.length === 0) continue;
+    const everything = recordedMessages(facts.records);
+    out.push({
+      id: row.id,
+      title: displayTitleOf(facts),
+      preview: [...everything].reverse().find(
+        (message) => message.role === "user" && message.source === void 0
+      )?.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));
+}
+__name(listConversations, "listConversations");
+async function titleOf(s, sessionId) {
+  const facts = await readConversationFacts(s, sessionId, "tolerant");
+  return facts?.named ? facts.title : void 0;
+}
+__name(titleOf, "titleOf");
+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"
+  );
+}
+__name(setTitle, "setTitle");
+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"
+  );
+}
+__name(seedConversationHistory, "seedConversationHistory");
+async function forkConversation(s, sourceId) {
+  await requireWritableConversation(s, sourceId, "fork conversation");
+  const messages = await loadConversation(s, sourceId);
+  if (messages.length === 0) {
+    throw new Error("There is nothing to fork yet \u2014 this conversation has no messages.");
+  }
+  const { id, title } = await writeFork(s, s, sourceId, messages, messages);
+  return { id, title, copied: messages.length };
+}
+__name(forkConversation, "forkConversation");
+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 \u2014 this conversation has no messages.");
+  }
+  const { id, title } = await writeFork(source, target, sourceId, messages, messages);
+  return { id, title, copied: messages.length };
+}
+__name(forkConversationInto, "forkConversationInto");
+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))
+  );
+}
+__name(sameMessageContent, "sameMessageContent");
+function sameMessageSequence(a, b) {
+  return a.length === b.length && a.every((message, index) => sameMessageContent(message, b[index]));
+}
+__name(sameMessageSequence, "sameMessageSequence");
+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 };
+}
+__name(forkConversationBeforeUser, "forkConversationBeforeUser");
+async function writeFork(sourceStore, targetStore, sourceId, sourceMessages, copiedMessages) {
+  const sourceFacts = await readConversationFacts(sourceStore, sourceId, "tolerant");
+  const source = sourceFacts?.title !== void 0 && 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 };
+}
+__name(writeFork, "writeFork");
+async function takenTitles(s) {
+  const taken = {};
+  for (const row of await s.index.listSessions({ slug: s.slug, rootsOnly: true })) {
+    if (row.title !== void 0 && row.title.length > 0) taken[row.id] = row.title;
+  }
+  return taken;
+}
+__name(takenTitles, "takenTitles");
+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;
+}
+__name(recordedMessages, "recordedMessages");
+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 < 1e3; n += 1) {
+    const candidate = `${source} (fork ${n})`;
+    if (!used.has(candidate)) return candidate;
+  }
+  return `${source} (fork)`;
+}
+__name(nextForkName, "nextForkName");
+function displayTitleOf(facts) {
+  return facts.title !== void 0 && facts.title.length > 0 && (facts.named || facts.title !== "Conversation") ? facts.title : conversationTitle(recordedMessages(facts.records));
+}
+__name(displayTitleOf, "displayTitleOf");
+function conversationTitle(messages) {
+  const firstHuman = messages.find(
+    (message) => message.role === "user" && message.source === void 0
+  );
+  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 typed = typedTextOf(raw);
+  const text = (typed.text.trim() ? typed.text : typed.firstFile ?? "").replace(/\s+/g, " ").trim();
+  return text.length > 60 ? `${text.slice(0, 59)}\u2026` : text || "Conversation";
+}
+__name(conversationTitle, "conversationTitle");
+function projectLabel(s) {
+  return basename(s.projectRoot) || s.projectRoot;
+}
+__name(projectLabel, "projectLabel");
+function conversationDir(s, sessionId) {
+  return s.paths.sessionDir({ sessionId });
+}
+__name(conversationDir, "conversationDir");
+function projectDir(s) {
+  return join2(s.root, "projects", s.slug);
+}
+__name(projectDir, "projectDir");
+
+export {
+  readIdentity,
+  displayConversationTitle,
+  openSessionScope,
+  openSessions,
+  closeSessions,
+  conversationLogPath,
+  openConversationLog,
+  refreshIndex,
+  readConversationFacts,
+  startConversation,
+  ensureSessionStarted,
+  resolveConversation,
+  findMappedConversation,
+  requireWritableConversation,
+  ConversationIndexRefreshError,
+  archiveConversation,
+  unarchiveConversation,
+  loadConversation,
+  loadConversationSnapshot,
+  loadResumableConversation,
+  activeConversationTurn,
+  listRecent,
+  listArchived,
+  titleOf,
+  setTitle,
+  seedConversationHistory,
+  forkConversation,
+  forkConversationInto,
+  forkConversationBeforeUser,
+  nextForkName,
+  displayTitleOf,
+  conversationTitle,
+  projectLabel,
+  conversationDir,
+  projectDir
+};
+//# sourceMappingURL=chunk-TIGWWAJI.js.map