@runeya/runeya 2.0.93 → 2.0.95

package/chunk-WAC56HS4.js

@@ -0,0 +1,1842 @@
+import {
+  findThreadDb,
+  lastTurn,
+  threadMessages,
+  threadsStartedAfter
+} from "./chunk-MD3VW4HQ.js";
+import {
+  AmbiguousProjectError,
+  agentManager,
+  decryptValue,
+  encryptValue,
+  ensureProjectsLoaded,
+  environmentStore,
+  forgetProject,
+  getEncryptionKey,
+  hasChangedSinceRead,
+  projectKey,
+  refOfProjectAmong,
+  registerProjectLoader,
+  rememberFile,
+  rootOfProjectAmong,
+  rootOfProjectRef,
+  serviceStore,
+  setProjectServices,
+  setProjectVault,
+  wasRead
+} from "./chunk-HX3ZIWHM.js";
+import {
+  COMPANION_RELAY_CLOSE,
+  COMPANION_RELAY_OPEN,
+  ProjectSchema,
+  allVaultRoots,
+  ensureLocalVault,
+  extractCompanionRelay,
+  keyedFilePath,
+  legacyMachineFilePath,
+  listCloudVaults,
+  localVaultRoot,
+  machineFilePath,
+  machineRoot,
+  orgIdOfRoot,
+  vaultFor,
+  vaultIdOfRoot
+} from "./chunk-3MJLS5UY.js";
+
+// ../server/src/services/conversation-store.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { readFile as readFile3, writeFile as writeFile4, rename as rename3, mkdir as mkdir3, chmod as chmod3 } from "fs/promises";
+import { dirname, join as join4 } from "path";
+import { EventEmitter as EventEmitter2 } from "events";
+
+// ../server/src/services/project-store.ts
+import { randomUUID } from "crypto";
+import { EventEmitter } from "events";
+import { readFile as readFile2, writeFile as writeFile3, rename as rename2, mkdir as mkdir2, chmod as chmod2, rm } from "fs/promises";
+import { join as join3 } from "path";
+
+// ../server/src/utils/ensure-data-gitignore.ts
+import { writeFile } from "fs/promises";
+import { join } from "path";
+var GITIGNORE_CONTENT = `
+#################
+# Do not edit this file #
+#################
+
+
+# Encryption key (contains secrets \u2014 never commit)
+.encryption.key
+.encryption.key.enc
+
+
+# Key verification canary \u2014 MUST be committed so new team members can validate their encryption key
+!.runeya-verify
+
+# This machine's cloud session token (encrypted, and specific to this install)
+cloud-session.json
+
+# Backup in local only
+backup-*
+
+# Per-user environment overrides (never commit \u2014 each dev has their own)
+environment-overrides.json
+
+# Private user data (conversations, personal state \u2014 never commit)
+*.private
+*.private.json*
+conversations/
+conversations.private.json
+
+
+
+# Runtime logs
+*.log
+*.log.*
+`;
+async function ensureDataGitignore(dataDir) {
+  const gitignorePath = join(dataDir, ".gitignore");
+  await writeFile(gitignorePath, GITIGNORE_CONTENT, "utf-8");
+}
+
+// ../server/src/services/project-path-store.ts
+import { readFile, writeFile as writeFile2, rename, mkdir, chmod, stat } from "fs/promises";
+import { isAbsolute, join as join2, resolve } from "path";
+var FILENAME = "project-paths.json";
+var ProjectPathStore = class {
+  paths = null;
+  async load() {
+    if (this.paths) return this.paths;
+    try {
+      const raw = await readFile(machineFilePath(FILENAME), "utf-8");
+      const parsed = JSON.parse(raw);
+      this.paths = isPathMap(parsed) ? parsed : {};
+    } catch {
+      this.paths = {};
+    }
+    return this.paths;
+  }
+  async persist() {
+    await mkdir(machineRoot(), { recursive: true });
+    const filePath = machineFilePath(FILENAME);
+    const tmpPath = `${filePath}.tmp`;
+    await writeFile2(tmpPath, JSON.stringify(this.paths ?? {}, null, 2), "utf-8");
+    await rename(tmpPath, filePath);
+    await chmod(filePath, 384);
+  }
+  /** The directory chosen for this project, or null while it has none. */
+  async get(ref) {
+    const paths = await this.load();
+    return paths[projectKey(ref)] ?? paths[ref.id] ?? null;
+  }
+  async all() {
+    return { ...await this.load() };
+  }
+  /**
+   * The project already placed in this directory, if any other one is.
+   *
+   * Answers with the key as stored — the couple, or the bare id for an entry an
+   * older version wrote — which is enough to say "taken" and to name it.
+   */
+  async projectAt(path, exclude) {
+    const target = resolve(path);
+    const excluded = exclude ? [projectKey(exclude), exclude.id] : [];
+    for (const [key, dir] of Object.entries(await this.load())) {
+      if (!excluded.includes(key) && resolve(dir) === target) return key;
+    }
+    return null;
+  }
+  async set(ref, path) {
+    if (!isAbsolute(path)) throw new Error("Le chemin du projet doit \xEAtre absolu");
+    const paths = await this.load();
+    delete paths[ref.id];
+    paths[projectKey(ref)] = resolve(path);
+    await this.persist();
+  }
+  /**
+   * Faire suivre le répertoire quand un projet change d'organisation.
+   *
+   * La clé est le couple `(organisation, projet)` : publier un projet local le
+   * fait passer de `local:<id>` à `<org>:<id>`, et l'entrée d'avant cesse alors
+   * de répondre — `get` ne retombe que sur l'identifiant nu, forme héritée, pas
+   * sur `local:<id>`. Le projet se retrouvait donc sans emplacement connu juste
+   * après avoir été publié, alors que ses sources n'avaient pas bougé d'un
+   * octet.
+   */
+  async relocate(from, to) {
+    const paths = await this.load();
+    const previous = paths[projectKey(from)] ?? paths[from.id];
+    if (!previous) return;
+    delete paths[projectKey(from)];
+    delete paths[from.id];
+    paths[projectKey(to)] = previous;
+    await this.persist();
+  }
+  async clear(ref) {
+    const paths = await this.load();
+    const keys = [projectKey(ref), ref.id].filter((k) => k in paths);
+    if (keys.length === 0) return;
+    for (const key of keys) delete paths[key];
+    await this.persist();
+  }
+  /** Test seam: forget what was read from disk. */
+  reset() {
+    this.paths = null;
+  }
+};
+function isPathMap(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && Object.values(value).every((v) => typeof v === "string");
+}
+async function holdsRuneyaProject(path) {
+  for (const candidate of ["project.json", "projects.json"]) {
+    try {
+      await stat(join2(path, ".runeya", candidate));
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+var projectPathStore = new ProjectPathStore();
+
+// ../server/src/services/project-store.ts
+var FILENAME2 = "project.json";
+var LEGACY_FILENAME = "projects.json";
+function toDiskForm(project) {
+  const { activeEnvironmentId: _runtimeOnly, ...rest } = project;
+  return rest;
+}
+async function readLocalProject() {
+  const root = localVaultRoot();
+  let current = null;
+  try {
+    const raw = await readFile2(join3(root, FILENAME2), "utf-8");
+    const parsed = ProjectSchema.safeParse(JSON.parse(raw));
+    if (parsed.success) current = parsed.data;
+  } catch {
+  }
+  let legacy;
+  try {
+    legacy = JSON.parse(await readFile2(join3(root, LEGACY_FILENAME), "utf-8"));
+  } catch {
+    return { local: current, strayCloud: [] };
+  }
+  const strayCloud = legacy.filter((p) => p.orgId);
+  if (current) return { local: current, strayCloud };
+  const locals = legacy.filter((p) => !p.orgId);
+  if (locals.length > 1) {
+    const names = locals.map((p) => `"${p.name}" (${p.id})`).join(", ");
+    throw new Error(
+      `${join3(root, LEGACY_FILENAME)} holds ${locals.length} local projects: ${names}. A directory now holds a single local project \u2014 move the others to their own directory, or into an organization, then start again.`
+    );
+  }
+  return { local: locals[0] ?? null, strayCloud };
+}
+async function readCloudProjects() {
+  const found = [];
+  for (const { orgId, projectId, root } of await listCloudVaults()) {
+    try {
+      const raw = await readFile2(join3(root, FILENAME2), "utf-8");
+      const parsed = ProjectSchema.safeParse({ ...JSON.parse(raw), id: projectId, orgId });
+      if (parsed.success) found.push({ project: parsed.data, root });
+    } catch {
+    }
+  }
+  return found;
+}
+var LocalProjectExistsError = class extends Error {
+  constructor(projectName) {
+    super(
+      `This directory already holds the local project "${projectName}". A directory holds one local project: use another directory, or create the project in an organization.`
+    );
+    this.projectName = projectName;
+    this.name = "LocalProjectExistsError";
+  }
+  code = "LOCAL_PROJECT_EXISTS";
+};
+var ProjectStore = class {
+  /**
+   * Keyed by the (organization, project) couple, never by the project id alone:
+   * the same id can name a different project in each organization, and keying
+   * by id let the second one read from disk overwrite the first — then `save()`
+   * wrote that survivor back into both vaults.
+   */
+  projects = /* @__PURE__ */ new Map();
+  loaded = false;
+  /** Emits `'saved'` after every persisted mutation, for the cloud sync bridge. */
+  events = new EventEmitter();
+  getFilePath(root = localVaultRoot()) {
+    return join3(root, FILENAME2);
+  }
+  async writeAtomic(filePath, data) {
+    const tmpPath = filePath + ".tmp";
+    await writeFile3(tmpPath, data, "utf-8");
+    await rename2(tmpPath, filePath);
+    await chmod2(filePath, 384);
+  }
+  /** Adopt a project read from disk, remembering which vault it came from. */
+  async absorb(p, root) {
+    const projectEnvs = await environmentStore.getByProjectId(p.id).catch(() => []);
+    const defaultEnv = projectEnvs.find((e) => e.default);
+    this.projects.set(projectKey(p), {
+      ...p,
+      environmentIds: p.environmentIds ?? [],
+      groupOrder: p.groupOrder ?? [],
+      // Prefer the env marked default, fall back to first env
+      activeEnvironmentId: defaultEnv?.id ?? p.environmentIds?.[0]
+    });
+    setProjectVault(p, root);
+    setProjectServices(p, p.serviceIds ?? []);
+  }
+  /**
+   * Read every vault: the launch directory, then each organization's projects.
+   *
+   * Cloud vaults are discovered by walking `~/.runeya/orgs/*&#47;projects/*` rather
+   * than from an index. An index is one more thing that can disagree with the
+   * disk — and a project present on disk but missing from it is exactly the
+   * "already here, still shown as downloadable" bug.
+   */
+  async load() {
+    if (this.loaded) return;
+    this.loaded = true;
+    const { local, strayCloud } = await readLocalProject();
+    if (local) await this.absorb(local, localVaultRoot());
+    let migrated = false;
+    for (const project of strayCloud) {
+      try {
+        await this.absorb(project, vaultFor(project).root);
+        migrated = true;
+      } catch {
+      }
+    }
+    for (const { project, root } of await readCloudProjects()) {
+      await this.absorb(project, root);
+    }
+    if (migrated) {
+      await this.save();
+      await serviceStore.relocateAll();
+      await environmentStore.relocateAll();
+    }
+  }
+  /**
+   * Persist every vault this store knows about.
+   *
+   * Writing all of them rather than only the one that changed keeps a project
+   * that moved between vaults — a local project adopted by an org, a cloud
+   * project pulled for the first time — from lingering in the vault it left.
+   */
+  async save() {
+    const locals = [];
+    const cloud = [];
+    for (const project of this.projects.values()) {
+      if (!project.orgId) locals.push(project);
+      else cloud.push({ project, root: vaultFor(project).root });
+    }
+    if (locals.length > 1) {
+      const names = locals.map((p) => `"${p.name}" (${p.id})`).join(", ");
+      throw new Error(
+        `Refusing to save ${locals.length} local projects in one directory: ${names}. A directory holds a single local project.`
+      );
+    }
+    const [local] = locals;
+    if (local) {
+      await ensureLocalVault();
+      await ensureDataGitignore(localVaultRoot());
+      await this.writeAtomic(this.getFilePath(), JSON.stringify(toDiskForm(local), null, 2));
+    } else {
+      await rm(this.getFilePath(), { force: true }).catch(() => {
+      });
+    }
+    await rename2(join3(localVaultRoot(), LEGACY_FILENAME), join3(localVaultRoot(), LEGACY_FILENAME + ".bak")).catch(() => {
+    });
+    for (const { project, root } of cloud) {
+      await mkdir2(root, { recursive: true });
+      await this.writeAtomic(this.getFilePath(root), JSON.stringify(toDiskForm(project), null, 2));
+      setProjectVault(project, root);
+    }
+    this.events.emit("saved");
+  }
+  /**
+   * The project a caller means, from a couple or from a bare id.
+   *
+   * A ref carrying its `orgId` — even an explicit `null` for a local project —
+   * names exactly one project and is looked up directly. A bare id is what a
+   * contained entity (an environment, a conversation) still carries, and it is
+   * resolved only while it answers for a single project: electing one of two
+   * would write into the wrong organization's vault.
+   */
+  resolveKey(target) {
+    if (typeof target !== "string" && target.orgId !== void 0) return projectKey(target);
+    const id = typeof target === "string" ? target : target.id;
+    const matches = Array.from(this.projects.values()).filter((p) => p.id === id);
+    if (matches.length > 1) {
+      throw new AmbiguousProjectError(id, matches.map((p) => p.orgId ?? null));
+    }
+    return matches[0] ? projectKey(matches[0]) : null;
+  }
+  find(target) {
+    const key = this.resolveKey(target);
+    const project = key ? this.projects.get(key) : void 0;
+    return key && project ? { key, project } : null;
+  }
+  async list() {
+    await this.load();
+    return Array.from(this.projects.values());
+  }
+  async get(target) {
+    await this.load();
+    return this.find(target)?.project ?? null;
+  }
+  async create(input) {
+    await this.load();
+    if (!input.orgId) {
+      const existing = Array.from(this.projects.values()).find((p) => !p.orgId);
+      if (existing) {
+        throw new LocalProjectExistsError(existing.name);
+      }
+    }
+    const project = {
+      id: randomUUID(),
+      orgId: input.orgId ?? null,
+      name: input.name,
+      description: input.description ?? "",
+      serviceIds: input.serviceIds ?? [],
+      environmentIds: input.environmentIds ?? [],
+      activeEnvironmentId: input.activeEnvironmentId,
+      groupOrder: input.groupOrder ?? []
+    };
+    this.projects.set(projectKey(project), project);
+    setProjectVault(project, vaultFor(project).root);
+    setProjectServices(project, project.serviceIds);
+    await this.save();
+    return project;
+  }
+  /**
+   * `input.orgId` names which project is being updated, it does not move it:
+   * a project is born local or in an organization and stays there, so treating
+   * it as a new value would silently relocate a vault instead of editing it.
+   */
+  async update(input) {
+    await this.load();
+    const found = this.find(input);
+    if (!found) return null;
+    const { key, project: existing } = found;
+    const updated = {
+      ...existing,
+      ...input.name !== void 0 && { name: input.name },
+      ...input.description !== void 0 && { description: input.description },
+      ...input.serviceIds !== void 0 && { serviceIds: input.serviceIds },
+      ...input.environmentIds !== void 0 && { environmentIds: input.environmentIds },
+      ...input.activeEnvironmentId !== void 0 && { activeEnvironmentId: input.activeEnvironmentId },
+      ...input.groupOrder !== void 0 && { groupOrder: input.groupOrder }
+    };
+    this.projects.set(key, updated);
+    setProjectVault(updated, vaultFor(updated).root);
+    setProjectServices(updated, updated.serviceIds);
+    await this.save();
+    return updated;
+  }
+  /**
+   * Faire passer le projet local de ce dossier dans une organisation.
+   *
+   * Le seul déplacement de coffre qu'on s'autorise, et il ne va que dans ce
+   * sens : le projet quitte `<cwd>/.runeya` pour
+   * `~/.runeya/orgs/<org>/projects/<id>/`, en gardant son identifiant. Il n'y a
+   * donc jamais deux copies à réconcilier — c'est ce qui rendait « publier »
+   * dangereux tant que le projet restait aussi local.
+   *
+   * Refusé si l'organisation porte déjà ce projet : la copie d'ici écraserait
+   * celle du cloud, et ces deux histoires ne sont pas à nous de les fusionner.
+   *
+   * Ce qui suit le projet est écrit par les stores eux-mêmes : `save()` réécrit
+   * chaque coffre — le fichier local disparaît, celui de l'org apparaît — puis
+   * les contenus sont relogés depuis le registre, qui pointe désormais ailleurs.
+   */
+  async moveToOrg(projectId, orgId) {
+    await this.load();
+    const local = this.projects.get(projectKey({ id: projectId, orgId: null }));
+    if (!local) throw new Error("PROJECT_NOT_LOCAL");
+    if (this.projects.get(projectKey({ id: projectId, orgId }))) {
+      throw new Error("PROJECT_ALREADY_IN_ORG");
+    }
+    const moved = { ...local, orgId };
+    this.projects.delete(projectKey(local));
+    forgetProject(local);
+    this.projects.set(projectKey(moved), moved);
+    setProjectVault(moved, vaultFor(moved).root);
+    setProjectServices(moved, moved.serviceIds ?? []);
+    await this.save();
+    await serviceStore.reassignOrg(moved.serviceIds ?? [], orgId);
+    await environmentStore.relocateAll();
+    return moved;
+  }
+  async delete(target) {
+    await this.load();
+    const found = this.find(target);
+    if (!found) return false;
+    const { key, project } = found;
+    this.projects.delete(key);
+    await this.save();
+    await this.discardVault(project);
+    await projectPathStore.clear(project);
+    return true;
+  }
+  /**
+   * Remove what a deleted cloud project left behind.
+   *
+   * Its vault is a directory of its own, so dropping the project means dropping
+   * the directory — otherwise `readCloudVaults` would resurrect it on the next
+   * load. Local projects share their vault with the directory's own files and
+   * are only removed from the list.
+   */
+  async discardVault(project) {
+    forgetProject(project);
+    if (!project.orgId) return;
+    await rm(vaultFor(project).root, { recursive: true, force: true }).catch(() => {
+    });
+  }
+  /**
+   * Stop holding a project on this machine, leaving the doc alone.
+   *
+   * Memory only: the caller removes the vault itself. Its contents are dropped
+   * too, because a service or environment surviving in memory would be written
+   * back on the next save — and, its project being unknown by then, into the
+   * local vault.
+   */
+  async forgetLocally(target) {
+    await this.load();
+    const found = this.find(target);
+    if (!found) return;
+    const { key, project } = found;
+    this.projects.delete(key);
+    forgetProject(project);
+    await serviceStore.forgetLocally(project.serviceIds ?? []);
+    await environmentStore.forgetByProject(project.id);
+    await projectPathStore.clear(project);
+  }
+  /** All projects linked to a given organization (for the sync bridge). */
+  async listByOrg(orgId) {
+    await this.load();
+    return Array.from(this.projects.values()).filter((p) => p.orgId === orgId);
+  }
+  /** Projects of an organization in their on-disk form (what the cloud mirrors). */
+  async listDiskFormByOrg(orgId) {
+    return (await this.listByOrg(orgId)).map(toDiskForm);
+  }
+  /**
+   * Apply a project received from the cloud, in its on-disk form.
+   *
+   * Validated rather than trusted: a peer on another version — or a tampered
+   * doc — must not be able to write arbitrary shapes into `projects.json`.
+   * `activeEnvironmentId` is runtime-only and stays whatever it is locally.
+   * Diff-guarded: an identical project neither saves nor emits (loop-safe).
+   * Returns whether a new local project was created, so the caller can
+   * bootstrap project-local state (e.g. a default environment).
+   */
+  async applyRemoteUpsert(id, fields) {
+    await this.load();
+    const parsed = ProjectSchema.safeParse({ ...fields, id });
+    if (!parsed.success) {
+      console.error("[project-store] Rejected remote project %s:", id, parsed.error.message);
+      return null;
+    }
+    const incoming = toDiskForm(parsed.data);
+    const key = projectKey(parsed.data);
+    const existing = this.projects.get(key);
+    if (existing) {
+      if (JSON.stringify(toDiskForm(existing)) === JSON.stringify(incoming)) {
+        return { project: existing, created: false };
+      }
+      const updated = { ...incoming, activeEnvironmentId: existing.activeEnvironmentId };
+      this.projects.set(key, updated);
+      setProjectVault(updated, vaultFor(updated).root);
+      setProjectServices(updated, updated.serviceIds);
+      await this.save();
+      return { project: updated, created: false };
+    }
+    const project = { ...incoming, activeEnvironmentId: void 0 };
+    this.projects.set(key, project);
+    setProjectVault(project, vaultFor(project).root);
+    setProjectServices(project, project.serviceIds);
+    await this.save();
+    return { project, created: true };
+  }
+  /** Delete a project that was removed on another peer. */
+  async applyRemoteDelete(target) {
+    await this.load();
+    const found = this.find(target);
+    if (!found) return false;
+    const { key, project } = found;
+    this.projects.delete(key);
+    await this.save();
+    await this.discardVault(project);
+    return true;
+  }
+  async addService(target, serviceId) {
+    await this.load();
+    const found = this.find(target);
+    if (!found) return null;
+    const { key, project } = found;
+    if (project.serviceIds.includes(serviceId)) return project;
+    const updated = { ...project, serviceIds: [...project.serviceIds, serviceId] };
+    this.projects.set(key, updated);
+    setProjectServices(updated, updated.serviceIds);
+    await this.save();
+    return updated;
+  }
+  async removeService(target, serviceId) {
+    await this.load();
+    const found = this.find(target);
+    if (!found) return null;
+    const { key, project } = found;
+    const updated = { ...project, serviceIds: project.serviceIds.filter((id) => id !== serviceId) };
+    this.projects.set(key, updated);
+    setProjectServices(updated, updated.serviceIds);
+    await this.save();
+    return updated;
+  }
+  async addEnvironment(target, environmentId) {
+    await this.load();
+    const found = this.find(target);
+    if (!found) return null;
+    const { key, project } = found;
+    if (project.environmentIds?.includes(environmentId)) return project;
+    const updated = {
+      ...project,
+      environmentIds: [...project.environmentIds ?? [], environmentId]
+    };
+    this.projects.set(key, updated);
+    await this.save();
+    return updated;
+  }
+  async removeEnvironment(target, environmentId) {
+    await this.load();
+    const found = this.find(target);
+    if (!found) return null;
+    const { key, project } = found;
+    const updated = {
+      ...project,
+      environmentIds: (project.environmentIds ?? []).filter((id) => id !== environmentId),
+      // Clear activeEnvironmentId if it was the removed environment
+      ...project.activeEnvironmentId === environmentId && { activeEnvironmentId: void 0 }
+    };
+    this.projects.set(key, updated);
+    await this.save();
+    return updated;
+  }
+  async setActiveEnvironment(target, environmentId) {
+    await this.load();
+    const found = this.find(target);
+    if (!found) return null;
+    const { key, project } = found;
+    const updated = {
+      ...project,
+      activeEnvironmentId: environmentId
+    };
+    this.projects.set(key, updated);
+    return updated;
+  }
+};
+var projectStore = new ProjectStore();
+registerProjectLoader(() => projectStore.list().then(() => void 0));
+
+// ../server/src/services/conversation-store.ts
+var FILENAME3 = "conversations.private.json";
+async function localProjectId() {
+  const projects = await projectStore.list().catch(() => []);
+  return projects.find((p) => !p.orgId)?.id ?? null;
+}
+var ConversationStore = class {
+  conversations = /* @__PURE__ */ new Map();
+  /** Which vault each conversation was read from, until its project is known. */
+  roots = /* @__PURE__ */ new Map();
+  /**
+   * Les conversations qu'on n'a pas su déchiffrer, par coffre, sous leur forme
+   * de disque.
+   *
+   * Une entrée illisible était simplement ignorée. Tant qu'aucune de ses
+   * voisines ne se chargeait, le fichier n'était jamais réécrit et la donnée
+   * survivait par accident ; dès qu'une seule s'ouvrait, la sauvegarde suivante
+   * réécrivait le fichier avec elle seule — et effaçait les autres. Elles sont
+   * donc gardées ici, telles quelles, et réémises à l'identique.
+   */
+  unreadable = /* @__PURE__ */ new Map();
+  loaded = false;
+  events = new EventEmitter2().setMaxListeners(0);
+  saveQueue = Promise.resolve();
+  snapshotConversation(conv) {
+    return structuredClone(conv);
+  }
+  /**
+   * Encrypted, so it lives beside the key that opens it — usually the machine
+   * root, but a launch directory owning its own key keeps both together.
+   */
+  getFilePath() {
+    return keyedFilePath(FILENAME3);
+  }
+  /** Where older versions kept it — read only, so an older Runeya keeps working. */
+  getLegacyFilePath() {
+    return legacyMachineFilePath(FILENAME3);
+  }
+  /**
+   * Read the machine file, falling back to the launch directory of old.
+   *
+   * The legacy file is left in place: the next save writes the new location,
+   * and a directory still opened by an older Runeya keeps working meanwhile.
+   */
+  async readFromDisk() {
+    try {
+      return await readFile3(await this.getFilePath(), "utf-8");
+    } catch {
+      return readFile3(this.getLegacyFilePath(), "utf-8");
+    }
+  }
+  async ensureDir() {
+    await mkdir3(dirname(await this.getFilePath()), { recursive: true });
+  }
+  encryptMessages(messages, vault) {
+    return encryptValue(JSON.stringify(messages), vault);
+  }
+  decryptMessages(encrypted, vault) {
+    const json = decryptValue(encrypted, vault);
+    return JSON.parse(json);
+  }
+  /**
+   * Refuser d'écrire dans le coffre d'une organisation sans nommer sa clé.
+   *
+   * `getEncryptionKey(undefined)` rend la clé machine, et c'est le bon défaut
+   * pour le coffre local. Appliqué à un fichier rangé sous `orgs/<org>/`, il
+   * produit un chiffré que ce coffre n'emploie pas — lisible par personne à la
+   * relecture, et impossible à distinguer d'une corruption.
+   *
+   * Le cas a été observé plusieurs fois sans qu'on parvienne à nommer le
+   * chemin fautif : les garde-fous en place traitent le coffre fermé, le
+   * coffre mal résolu et la copie périmée, aucun ne couvrait « coffre non
+   * précisé ». Ces écritures-là n'ont jamais fonctionné — elles échouaient en
+   * silence, ce qui est pire. On les saute désormais en le disant, avec la
+   * pile d'appels qui manquait pour remonter au chemin fautif.
+   */
+  isVaultNamed(root, vault) {
+    const orgId = orgIdOfRoot(root);
+    if (!orgId || vault) return true;
+    console.error(
+      `[conversation-store] \xC9criture ignor\xE9e dans le coffre de l'organisation ${orgId} (${root}) : aucune cl\xE9 d'organisation nomm\xE9e, le contenu serait chiffr\xE9 par la cl\xE9 machine et illisible \xE0 la relecture.
+${new Error("trace").stack}`
+    );
+    return false;
+  }
+  toDisk(conv, vault) {
+    return {
+      id: conv.id,
+      projectId: conv.projectId,
+      title: conv.title,
+      encryptedMessages: this.encryptMessages(conv.messages, vault),
+      isCli: conv.isCli,
+      runner: conv.runner,
+      providerId: conv.providerId,
+      codexThreadId: conv.codexThreadId,
+      contextUsage: conv.contextUsage,
+      workflowId: conv.workflowId,
+      workflowType: conv.workflowType,
+      kanbanBoardId: conv.kanbanBoardId,
+      kanbanCardId: conv.kanbanCardId,
+      companionEnabled: conv.companionEnabled,
+      companionRunner: conv.companionRunner,
+      companionConversationId: conv.companionConversationId,
+      isCompanion: conv.isCompanion,
+      archived: conv.archived,
+      createdAt: conv.createdAt,
+      updatedAt: conv.updatedAt
+    };
+  }
+  fromDisk(disk, vault) {
+    const workflowType = (disk.workflowType === "scenario" ? "scenario" : void 0) ?? (disk.scenarioId ? "scenario" : void 0);
+    return {
+      id: disk.id,
+      projectId: disk.projectId,
+      title: disk.title,
+      messages: this.decryptMessages(disk.encryptedMessages, vault),
+      isCli: disk.isCli ?? disk.isClaudeCode ?? false,
+      runner: disk.runner,
+      providerId: disk.providerId,
+      codexThreadId: disk.codexThreadId,
+      contextUsage: disk.contextUsage,
+      workflowId: disk.workflowId ?? disk.scenarioId,
+      workflowType,
+      kanbanBoardId: disk.kanbanBoardId,
+      kanbanCardId: disk.kanbanCardId,
+      companionEnabled: disk.companionEnabled,
+      companionRunner: disk.companionRunner,
+      companionConversationId: disk.companionConversationId,
+      isCompanion: disk.isCompanion,
+      archived: disk.archived,
+      createdAt: disk.createdAt,
+      updatedAt: disk.updatedAt
+    };
+  }
+  /**
+   * Read every project vault, then the homes older versions used.
+   *
+   * A conversation found in a legacy file is attributed to the local project of
+   * that directory — which is what it was about, back when one directory meant
+   * one project. With no local project to point at, it is left unattributed
+   * rather than filed under a project picked at random.
+   */
+  async load() {
+    if (this.loaded) return;
+    if (!getEncryptionKey()) {
+      return;
+    }
+    this.loaded = true;
+    this.unreadable.clear();
+    await ensureProjectsLoaded();
+    const vaults = await allVaultRoots();
+    const legacyPaths = [this.getLegacyFilePath(), await keyedFilePath(FILENAME3)];
+    const sources = [
+      ...legacyPaths.map((path) => ({ path, legacy: true })),
+      ...vaults.map((root) => ({ path: join4(root, FILENAME3), legacy: false }))
+    ];
+    for (const { path, legacy } of sources) {
+      let data;
+      try {
+        data = JSON.parse(await readFile3(path, "utf-8"));
+      } catch {
+        continue;
+      }
+      const inherited = legacy ? await localProjectId() : null;
+      const root = dirname(path);
+      await rememberFile(path);
+      for (const item of data) {
+        try {
+          const conv = this.fromDisk(item, vaultIdOfRoot(root));
+          if (!conv.projectId && inherited) conv.projectId = inherited;
+          this.conversations.set(item.id, conv);
+          this.roots.set(item.id, root);
+        } catch {
+          const bucket = this.unreadable.get(root) ?? [];
+          bucket.push(item);
+          this.unreadable.set(root, bucket);
+        }
+      }
+    }
+  }
+  /**
+   * Oublier ce qui a été lu, pour tout relire sous la clé courante.
+   *
+   * Appelé après l'adoption d'une clé d'organisation : le disque vient d'être
+   * re-chiffré sous les pieds du store, si bien que sa mémoire décrit un état
+   * qui n'existe plus. La laisser en place n'affichait pas seulement des
+   * comptes périmés — la sauvegarde suivante réécrivait l'ancien chiffré
+   * par-dessus le nouveau, et défaisait l'adoption.
+   */
+  resetCache() {
+    this.conversations.clear();
+    this.roots.clear();
+    this.unreadable.clear();
+    this.loaded = false;
+    this.events.emit("changed", { type: "reloaded" });
+  }
+  /**
+   * Combien de conversations ce coffre garde sans savoir les lire, par
+   * organisation. La machine elle-même est rangée sous `null`.
+   */
+  async unreadableByVault() {
+    await this.load();
+    const out = /* @__PURE__ */ new Map();
+    for (const [root, items] of this.unreadable) {
+      const vault = vaultIdOfRoot(root) ?? null;
+      out.set(vault, (out.get(vault) ?? 0) + items.length);
+    }
+    return out;
+  }
+  /**
+   * Write each vault that holds — or held — a conversation.
+   *
+   * A vault emptied by this save is still written, as an empty list: a
+   * conversation that found its project must not survive in the file it was
+   * read from.
+   */
+  async saveInternal() {
+    if (!getEncryptionKey()) return;
+    const byRoot = /* @__PURE__ */ new Map();
+    for (const root of this.roots.values()) byRoot.set(root, []);
+    for (const conv of this.conversations.values()) {
+      const root = await this.rootFor(conv);
+      this.roots.set(conv.id, root);
+      const bucket = byRoot.get(root) ?? [];
+      const vault = vaultIdOfRoot(root);
+      if (!this.isVaultNamed(root, vault)) continue;
+      bucket.push(this.toDisk(conv, vault));
+      byRoot.set(root, bucket);
+    }
+    for (const [root, items] of this.unreadable) {
+      byRoot.set(root, [...items, ...byRoot.get(root) ?? []]);
+    }
+    const stale = /* @__PURE__ */ new Set();
+    for (const root of byRoot.keys()) {
+      const path = join4(root, FILENAME3);
+      if (wasRead(path) && await hasChangedSinceRead(path)) stale.add(root);
+    }
+    for (const [root, data] of byRoot) {
+      const filePath = join4(root, FILENAME3);
+      if (stale.has(root)) {
+        console.warn(
+          `[conversation-store] ${filePath} a chang\xE9 depuis sa lecture \u2014 \xE9criture ignor\xE9e pour ne pas \xE9craser une r\xE9paration faite en dehors du serveur.`
+        );
+        continue;
+      }
+      await mkdir3(root, { recursive: true });
+      const tmpPath = `${filePath}.tmp`;
+      await writeFile4(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+      await rename3(tmpPath, filePath);
+      await chmod3(filePath, 384);
+      await rememberFile(filePath);
+    }
+  }
+  /**
+   * The vault a conversation is written to: its project's.
+   *
+   * One that names no project stays where it was read, falling back to the
+   * key's own directory — never lost for want of an owner.
+   */
+  async rootFor(conv) {
+    const known = this.roots.get(conv.id) ?? null;
+    if (conv.projectId) return rootOfProjectAmong(conv.projectId, known);
+    return known ?? dirname(await keyedFilePath(FILENAME3));
+  }
+  /**
+   * Le projet d'une conversation, organisation comprise.
+   *
+   * Ce que la conversation ne dit pas d'elle-même : elle ne nomme que l'id.
+   * Le coffre d'où elle vient fournit l'organisation, et c'est ce couple qu'il
+   * faut pour retrouver le répertoire de travail du projet.
+   */
+  async projectRefOf(conv) {
+    if (!conv.projectId) return null;
+    const known = this.roots.get(conv.id) ?? null;
+    const ref = refOfProjectAmong(conv.projectId, known);
+    return { id: ref.id, orgId: ref.orgId ?? null };
+  }
+  /**
+   * Réécrire chaque coffre, en déplaçant ce qui appartient désormais ailleurs.
+   *
+   * Appelé quand un projet a changé de coffre : ses conversations sont écrites
+   * dans le nouveau, et le fichier d'où elles viennent est réécrit sans elles.
+   */
+  async relocateAll() {
+    await this.load();
+    await this.save();
+  }
+  async save() {
+    const write = this.saveQueue.then(() => this.saveInternal());
+    this.saveQueue = write.catch(() => {
+    });
+    return write;
+  }
+  async list() {
+    await this.load();
+    return Array.from(this.conversations.values()).sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  /**
+   * Les conversations d'un projet.
+   *
+   * Celle qui ne nomme aucun projet — écrite avant le champ, ou qu'une
+   * migration n'a pas su attribuer — n'est rendue que dans les projets de son
+   * propre coffre : elle reste atteignable là où elle a été écrite, sans se
+   * déverser dans toutes les organisations de la machine.
+   */
+  async listForProject(ref) {
+    const belongs = await this.matcherForProject(ref);
+    return (await this.list()).filter(belongs);
+  }
+  /**
+   * Le test d'appartenance à un projet, préparé une fois.
+   *
+   * Le flux temps réel en a besoin autant que la liste : une conversation qui
+   * arrive par événement doit passer le même filtre, sans quoi elle se
+   * réinvite dans un projet qui ne l'a jamais demandée.
+   */
+  async matcherForProject(ref) {
+    await this.load();
+    let projectRoot = null;
+    try {
+      projectRoot = ref.orgId === void 0 ? rootOfProjectAmong(ref.id, null) : rootOfProjectRef({ id: ref.id, orgId: ref.orgId ?? null });
+    } catch {
+      projectRoot = null;
+    }
+    return (conv) => {
+      if (conv.projectId) return conv.projectId === ref.id;
+      if (!projectRoot) return true;
+      return this.roots.get(conv.id) === projectRoot;
+    };
+  }
+  async get(id) {
+    await this.load();
+    return this.conversations.get(id) ?? null;
+  }
+  async create(title, isCli = false, workflowId, workflowType, runner, kanbanBoardId, kanbanCardId, providerId, projectId, orgId, extra) {
+    await this.load();
+    const now = Date.now();
+    const conv = {
+      id: randomUUID2(),
+      projectId,
+      title: title ?? "New conversation",
+      messages: [],
+      isCli,
+      runner,
+      providerId,
+      workflowId,
+      workflowType,
+      kanbanBoardId,
+      kanbanCardId,
+      isCompanion: extra?.isCompanion,
+      companionEnabled: extra?.companionEnabled,
+      companionRunner: extra?.companionRunner,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.conversations.set(conv.id, conv);
+    if (projectId && orgId !== void 0) {
+      this.roots.set(conv.id, vaultFor({ id: projectId, orgId }).root);
+    }
+    await this.save();
+    this.events.emit("changed", { type: "created", conversation: this.snapshotConversation(conv) });
+    return conv;
+  }
+  async update(id, patch, options) {
+    await this.load();
+    const conv = this.conversations.get(id);
+    if (!conv) return null;
+    if (patch.title !== void 0) conv.title = patch.title;
+    if (patch.messages !== void 0) conv.messages = patch.messages;
+    if (patch.contextUsage !== void 0) conv.contextUsage = patch.contextUsage;
+    if (patch.workflowId !== void 0) conv.workflowId = patch.workflowId;
+    if (patch.archived !== void 0) conv.archived = patch.archived;
+    if (patch.codexThreadId !== void 0) conv.codexThreadId = patch.codexThreadId;
+    if (patch.companionEnabled !== void 0) conv.companionEnabled = patch.companionEnabled;
+    if (patch.companionRunner !== void 0) conv.companionRunner = patch.companionRunner;
+    if (patch.companionConversationId !== void 0) conv.companionConversationId = patch.companionConversationId;
+    if (options?.touch !== false) conv.updatedAt = Date.now();
+    await this.save();
+    if (!options?.silent) {
+      this.events.emit("changed", { type: "updated", conversation: this.snapshotConversation(conv) });
+    }
+    return conv;
+  }
+  /**
+   * Synchronously update the last assistant message content in memory, then schedule a save.
+   * Used by activeSessionRegistry.persistNow() to avoid the async get() → .then() race.
+   */
+  updateLastAssistantContent(id, content, parts) {
+    const conv = this.conversations.get(id);
+    if (!conv) return;
+    const lastMsg = conv.messages[conv.messages.length - 1];
+    if (!lastMsg || lastMsg.role !== "assistant") return;
+    lastMsg.content = content;
+    if (parts !== void 0) lastMsg.parts = parts;
+    conv.updatedAt = Date.now();
+    this.save().catch(() => {
+    });
+  }
+  async listByKanbanBoardId(boardId) {
+    await this.load();
+    return Array.from(this.conversations.values()).filter((c) => c.kanbanBoardId === boardId);
+  }
+  async listByKanbanCardId(cardId) {
+    await this.load();
+    return Array.from(this.conversations.values()).filter((c) => c.kanbanCardId === cardId);
+  }
+  async delete(id) {
+    await this.load();
+    const existed = this.conversations.delete(id);
+    await this.save();
+    if (existed) {
+      this.events.emit("changed", { type: "deleted", id });
+    }
+  }
+  onChanged(handler) {
+    this.events.on("changed", handler);
+  }
+  offChanged(handler) {
+    this.events.off("changed", handler);
+  }
+};
+var conversationStore = new ConversationStore();
+
+// ../server/src/services/turn-events.ts
+import { EventEmitter as EventEmitter3 } from "events";
+var bus = new EventEmitter3();
+bus.setMaxListeners(0);
+function emitTurnFinished(conversationId) {
+  bus.emit("turn-finished", conversationId);
+}
+function onTurnFinished(listener) {
+  bus.on("turn-finished", listener);
+  return () => {
+    bus.off("turn-finished", listener);
+  };
+}
+
+// ../server/src/services/claude-transcript-sync.ts
+import { readdir, access, readFile as readFile4 } from "fs/promises";
+import { watch } from "fs";
+import { homedir } from "os";
+import { join as join5 } from "path";
+var PROJECTS_DIR = join5(homedir(), ".claude", "projects");
+var DEFAULT_TITLES = /* @__PURE__ */ new Set(["", "New conversation", "Nouvelle conversation"]);
+async function findClaudeSessionFile(sessionId) {
+  let entries;
+  try {
+    entries = await readdir(PROJECTS_DIR);
+  } catch {
+    return null;
+  }
+  const filename = `${sessionId}.jsonl`;
+  for (const dir of entries) {
+    const candidate = join5(PROJECTS_DIR, dir, filename);
+    try {
+      await access(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+async function claudeSessionExists(sessionId) {
+  return await findClaudeSessionFile(sessionId) !== null;
+}
+async function readClaudeTranscript(sessionId) {
+  const path = await findClaudeSessionFile(sessionId);
+  if (!path) return { found: false, path: null, entries: [] };
+  const raw = await readFile4(path, "utf-8");
+  const entries = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return { found: true, path, entries };
+}
+function claudeEntriesToMessages(entries) {
+  const messages = [];
+  const toolPartById = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.type !== "user" && entry.type !== "assistant") continue;
+    const msg = entry.message;
+    if (!msg) continue;
+    const role = msg.role === "user" || msg.role === "assistant" ? msg.role : entry.type;
+    const content = msg.content;
+    const texts = [];
+    const parts = [];
+    let consumedByToolResult = false;
+    if (typeof content === "string") {
+      texts.push(content);
+    } else if (Array.isArray(content)) {
+      for (const block of content) {
+        if (typeof block === "string") {
+          texts.push(block);
+          continue;
+        }
+        if (!block || typeof block !== "object") continue;
+        const b = block;
+        if (b.type === "text" && typeof b.text === "string") {
+          texts.push(b.text);
+          parts.push({ type: "text", text: b.text });
+        } else if (b.type === "tool_use" && b.id) {
+          const part = {
+            type: "tool",
+            id: b.id,
+            name: b.name ?? "tool",
+            input: b.input,
+            pending: true
+          };
+          parts.push(part);
+          toolPartById.set(b.id, part);
+        } else if (b.type === "tool_result" && b.tool_use_id) {
+          const target = toolPartById.get(b.tool_use_id);
+          if (target) {
+            target.result = b.content;
+            target.isError = b.is_error;
+            target.pending = false;
+          }
+          consumedByToolResult = true;
+        }
+      }
+    }
+    if (role === "user" && consumedByToolResult && texts.length === 0) continue;
+    const last = messages[messages.length - 1];
+    if (last && last.role === role) {
+      const joinedText = [last.content, texts.join("\n").trim()].filter(Boolean).join("\n");
+      last.content = joinedText;
+      if (parts.length > 0) {
+        last.parts = [...last.parts ?? [], ...parts];
+      }
+      continue;
+    }
+    messages.push({
+      role,
+      content: texts.join("\n").trim(),
+      parts: parts.length > 0 ? parts : void 0
+    });
+  }
+  return messages;
+}
+function lastFinishedTurnId(entries) {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i];
+    if (entry.type !== "assistant") continue;
+    if (entry.message?.stop_reason !== "end_turn") return null;
+    return entry.uuid ?? `${entry.timestamp ?? ""}#${i}`;
+  }
+  return null;
+}
+var announcedTurns = /* @__PURE__ */ new Map();
+function shouldAnnounceTurn(conversationId, turnId) {
+  if (!turnId) return false;
+  if (announcedTurns.get(conversationId) === turnId) return false;
+  announcedTurns.set(conversationId, turnId);
+  return true;
+}
+function forgetAnnouncedTurns(conversationId) {
+  announcedTurns.delete(conversationId);
+}
+async function syncConversationFromClaudeTranscript(conversationId) {
+  const conv = await conversationStore.get(conversationId);
+  if (!conv) return false;
+  const transcript = await readClaudeTranscript(conversationId);
+  if (!transcript.found) return false;
+  const messages = claudeEntriesToMessages(transcript.entries);
+  const isDefaultTitle = !conv.title || DEFAULT_TITLES.has(conv.title);
+  const sameLength = messages.length === conv.messages.length;
+  const sameLastContent = sameLength && (messages.at(-1)?.content ?? "") === (conv.messages.at(-1)?.content ?? "");
+  if (sameLength && sameLastContent && !isDefaultTitle) {
+    return false;
+  }
+  const patch = { messages };
+  if (isDefaultTitle) {
+    const firstUserMsg = messages.find((m) => m.role === "user" && m.content.trim().length > 0);
+    if (firstUserMsg) {
+      const firstLine = firstUserMsg.content.split("\n")[0].trim();
+      patch.title = firstLine.length > 80 ? firstLine.slice(0, 80) + "\u2026" : firstLine;
+    }
+  }
+  await conversationStore.update(conversationId, patch, { touch: false });
+  if (shouldAnnounceTurn(conversationId, lastFinishedTurnId(transcript.entries))) {
+    emitTurnFinished(conversationId);
+  }
+  return true;
+}
+var lastTranscriptActivity = /* @__PURE__ */ new Map();
+function getLastTranscriptActivity(sessionId) {
+  return lastTranscriptActivity.get(sessionId) ?? null;
+}
+var started = false;
+var watchers = [];
+var pendingResyncs = /* @__PURE__ */ new Map();
+var RESYNC_DEBOUNCE_MS = 250;
+function scheduleResync(sessionId) {
+  const existing = pendingResyncs.get(sessionId);
+  if (existing) clearTimeout(existing);
+  pendingResyncs.set(
+    sessionId,
+    setTimeout(() => {
+      pendingResyncs.delete(sessionId);
+      syncConversationFromClaudeTranscript(sessionId).catch((err) => {
+        console.warn("[claude-transcript-sync] resync failed for", sessionId, err);
+      });
+    }, RESYNC_DEBOUNCE_MS)
+  );
+}
+function handleFsEvent(filename) {
+  if (!filename) return;
+  if (!filename.endsWith(".jsonl")) return;
+  const base = filename.split("/").pop();
+  const sessionId = base.slice(0, -".jsonl".length);
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(sessionId)) return;
+  lastTranscriptActivity.set(sessionId, Date.now());
+  scheduleResync(sessionId);
+}
+async function startClaudeTranscriptWatcher() {
+  if (started) return;
+  started = true;
+  let topLevel;
+  try {
+    topLevel = await readdir(PROJECTS_DIR);
+  } catch {
+    return;
+  }
+  try {
+    const w = watch(PROJECTS_DIR, { recursive: true }, (_event, filename) => {
+      handleFsEvent(filename ? filename.toString() : null);
+    });
+    w.on("error", (err) => console.warn("[claude-transcript-sync] watcher error:", err));
+    watchers.push(w);
+    return;
+  } catch {
+  }
+  for (const dir of topLevel) {
+    try {
+      const w = watch(join5(PROJECTS_DIR, dir), (_event, filename) => {
+        handleFsEvent(filename ? filename.toString() : null);
+      });
+      w.on("error", () => {
+      });
+      watchers.push(w);
+    } catch {
+    }
+  }
+}
+function stopClaudeTranscriptWatcher() {
+  for (const w of watchers) {
+    try {
+      w.close();
+    } catch {
+    }
+  }
+  watchers.length = 0;
+  for (const t of pendingResyncs.values()) clearTimeout(t);
+  pendingResyncs.clear();
+  started = false;
+}
+
+// ../server/src/services/codex-transcript-sync.ts
+import { watch as watch2 } from "fs";
+import { dirname as dirname2 } from "path";
+var announced = /* @__PURE__ */ new Map();
+function forgetCodexTurns(conversationId) {
+  announced.delete(conversationId);
+}
+async function syncConversationFromCodexTranscript(conversationId) {
+  const conv = await conversationStore.get(conversationId);
+  if (!conv?.codexThreadId) return false;
+  const messages = threadMessages(conv.codexThreadId);
+  if (messages.length === 0) return false;
+  const same = messages.length === conv.messages.length && (messages.at(-1)?.content ?? "") === (conv.messages.at(-1)?.content ?? "");
+  if (!same) await conversationStore.update(conversationId, { messages }, { touch: false });
+  const turn = lastTurn(conv.codexThreadId);
+  if (turn?.completedAt && announced.get(conversationId) !== turn.turnId) {
+    announced.set(conversationId, turn.turnId);
+    emitTurnFinished(conversationId);
+  }
+  return !same;
+}
+var watcher = null;
+var debounce = null;
+async function resyncAll() {
+  const convs = await conversationStore.list();
+  await bindPendingSpawns(convs.map((c) => c.codexThreadId).filter((x) => !!x));
+  for (const c of await conversationStore.list()) {
+    if (!c.codexThreadId) continue;
+    await syncConversationFromCodexTranscript(c.id).catch(() => false);
+  }
+}
+var BIND_MARGIN_SECONDS = 10;
+async function bindPendingSpawns(boundThreadIds) {
+  for (const [spawnId, spawn] of spawnConversations) {
+    const conv = await conversationStore.get(spawn.conversationId);
+    if (!conv) {
+      spawnConversations.delete(spawnId);
+      continue;
+    }
+    if (conv.codexThreadId) {
+      spawnConversations.delete(spawnId);
+      continue;
+    }
+    if (conv.runner !== "codex") continue;
+    const candidates = threadsStartedAfter(spawn.startedAt - BIND_MARGIN_SECONDS).filter((id) => !boundThreadIds.includes(id));
+    if (candidates.length !== 1) continue;
+    await conversationStore.update(conv.id, { codexThreadId: candidates[0] });
+    boundThreadIds.push(candidates[0]);
+    spawnConversations.delete(spawnId);
+  }
+}
+function startCodexTranscriptWatcher() {
+  if (watcher) return;
+  const db = findThreadDb();
+  if (!db) return;
+  try {
+    watcher = watch2(dirname2(db), (_event, filename) => {
+      if (!filename || !/^thread_history_\d+\.sqlite/.test(filename.toString())) return;
+      if (debounce) clearTimeout(debounce);
+      debounce = setTimeout(() => {
+        debounce = null;
+        void resyncAll();
+      }, 400);
+    });
+    watcher.on("error", (err) => console.warn("[codex-thread-sync]", err));
+  } catch {
+  }
+}
+function stopCodexTranscriptWatcher() {
+  watcher?.close();
+  watcher = null;
+  if (debounce) {
+    clearTimeout(debounce);
+    debounce = null;
+  }
+  tails.clear();
+  spawnConversations.clear();
+}
+var CODEX_RESUME_RE = /codex resume[\s\S]{0,300}?\(([0-9a-fA-F]{8}-[0-9a-fA-F-]{27})\)/;
+var MAX_TAIL = 4e3;
+var tails = /* @__PURE__ */ new Map();
+var spawnConversations = /* @__PURE__ */ new Map();
+function noteSpawnConversation(spawnId, conversationId) {
+  if (!conversationId) return;
+  spawnConversations.set(spawnId, { conversationId, startedAt: Math.floor(Date.now() / 1e3) });
+}
+function codexSessionIdIn(text) {
+  return CODEX_RESUME_RE.exec(text)?.[1] ?? null;
+}
+function observePtyChunk(spawnId, data) {
+  const spawn = spawnConversations.get(spawnId);
+  if (!spawn) return;
+  const conversationId = spawn.conversationId;
+  const tail = (tails.get(spawnId) ?? "") + data;
+  const sessionId = codexSessionIdIn(tail);
+  if (!sessionId) {
+    tails.set(spawnId, tail.slice(-MAX_TAIL));
+    return;
+  }
+  tails.delete(spawnId);
+  spawnConversations.delete(spawnId);
+  void (async () => {
+    const conv = await conversationStore.get(conversationId);
+    if (!conv || conv.codexThreadId === sessionId) return;
+    await conversationStore.update(conversationId, { codexThreadId: sessionId });
+    await syncConversationFromCodexTranscript(conversationId).catch(() => false);
+  })();
+}
+function forgetSpawn(spawnId) {
+  tails.delete(spawnId);
+  spawnConversations.delete(spawnId);
+}
+
+// ../server/src/services/auth-token.ts
+import { randomBytes } from "crypto";
+import { SignJWT, jwtVerify } from "jose";
+var jwtSecret = null;
+var jwtSecretGeneratedAt = 0;
+function generateJwtSecret() {
+  jwtSecret = new Uint8Array(randomBytes(32));
+  jwtSecretGeneratedAt = Math.floor(Date.now() / 1e3);
+}
+function getJwtSecretGeneratedAt() {
+  return jwtSecretGeneratedAt;
+}
+function getJwtSecret() {
+  if (!jwtSecret) throw new Error("JWT secret not yet generated");
+  return jwtSecret;
+}
+async function signJwt() {
+  const secret = getJwtSecret();
+  return new SignJWT({ sub: "app" }).setProtectedHeader({ alg: "HS256" }).setIssuedAt().setExpirationTime("8h").sign(secret);
+}
+async function verifyJwt(token) {
+  const secret = getJwtSecret();
+  const { payload } = await jwtVerify(token, secret);
+  return { exp: payload.exp, iat: payload.iat };
+}
+
+// ../server/src/services/live-pty.ts
+async function findLivePty(sessionId) {
+  for (const agent of agentManager.listAgents()) {
+    const agentId = agent.config.id;
+    try {
+      const pty = await agentManager.agentQuery(
+        agentId,
+        "ai.findPtyBySession",
+        { sessionId }
+      );
+      if (pty?.status === "running") return { agentId, spawnId: pty.spawnId };
+    } catch {
+    }
+  }
+  return null;
+}
+
+// ../server/src/services/companion.ts
+var MAX_CONSECUTIVE_RELAUNCHES = 3;
+var MAX_EXCHANGE_CHARS = 2e4;
+var VERDICT_NOTHING = "RAS";
+var RELAY_OPEN = COMPANION_RELAY_OPEN;
+var RELAY_CLOSE = COMPANION_RELAY_CLOSE;
+var relaunches = /* @__PURE__ */ new Map();
+function resetRelaunches(conversationId) {
+  relaunches.delete(conversationId);
+}
+function takeRelaunchSlot(conversationId) {
+  const used = relaunches.get(conversationId) ?? 0;
+  if (used >= MAX_CONSECUTIVE_RELAUNCHES) {
+    relaunches.delete(conversationId);
+    return false;
+  }
+  relaunches.set(conversationId, used + 1);
+  return true;
+}
+function relayableMessage(raw) {
+  const text = (raw ?? "").trim();
+  if (!text) return null;
+  const inner = extractCompanionRelay(text);
+  if (inner !== null) return isNothing(inner) ? null : inner;
+  if (text.includes(RELAY_OPEN)) return null;
+  return isNothing(text) ? null : text;
+}
+function isNothing(text) {
+  const bare = (v) => v.replace(/^[\s"'«»([.,;:—-]+|[\s"'«»)\].,;:!—-]+$/g, "");
+  if (bare(text).toUpperCase() === VERDICT_NOTHING) return true;
+  const lines = text.split("\n").map((l) => l.trim()).filter(Boolean);
+  const last = lines[lines.length - 1] ?? "";
+  return bare(last).toUpperCase() === VERDICT_NOTHING;
+}
+var reviewedUpTo = /* @__PURE__ */ new Map();
+function forgetReviewProgress(conversationId) {
+  reviewedUpTo.delete(conversationId);
+}
+function reviewWindow(messages, reviewed) {
+  const list = messages ?? [];
+  const count = list.length;
+  let lastUser = -1;
+  for (let i = count - 1; i >= 0; i--) {
+    if (list[i].role === "user") {
+      lastUser = i;
+      break;
+    }
+  }
+  const mark = reviewed === void 0 ? lastUser >= 0 ? lastUser : Math.max(0, count - 2) : Math.min(Math.max(0, reviewed), count);
+  return {
+    from: lastUser >= 0 ? Math.min(mark, lastUser) : mark,
+    hasNew: count > mark
+  };
+}
+function formatExchange(messages, from) {
+  const text = (messages ?? []).slice(from).map((m) => [`[${m.role}]`, m.contextNote ? `(contexte : ${m.contextNote})` : "", m.content ?? ""].filter(Boolean).join("\n")).join("\n\n");
+  return text.length > MAX_EXCHANGE_CHARS ? text.slice(-MAX_EXCHANGE_CHARS) : text;
+}
+function fullInstructions() {
+  return [
+    "Tu relis le travail d'un autre agent, dans la m\xEAme conversation que lui.",
+    "Tu ne modifies rien : tu regardes, et tu d\xE9cides si tu as quelque chose \xE0 dire.",
+    "Cela vaut aussi pour la carte kanban si la conversation en a une : tu peux la",
+    "lire \u2014 elle dit ce qui a \xE9t\xE9 demand\xE9, donc ce que \xAB termin\xE9 \xBB veut dire ici \u2014",
+    "mais tu ne la d\xE9places pas, tu ne la commentes pas, tu ne la modifies pas.",
+    "Ton seul produit est le message que tu renvoies.",
+    "",
+    "Les images ne te sont PAS jointes : l'\xE9change n'en porte que le chemin, sous",
+    "la forme [Image: source: /chemin/vers/le/fichier.png]. Quand on te demande",
+    "d'en lire une, OUVRE ce chemin avec ton outil de lecture de fichiers \u2014 tu en",
+    "as un, et il lit les images.",
+    "N'invente JAMAIS le contenu d'une image que tu n'as pas ouverte : si le",
+    "chemin manque ou que la lecture \xE9choue, dis-le. On te croirait.",
+    "",
+    "R\xC8GLE 1 \u2014 ON PEUT T'ADRESSER LA PAROLE, ET ALORS TU R\xC9PONDS.",
+    "Si l'\xE9change ci-dessous te parle, te nomme, te pose une question ou te",
+    "demande quelque chose : tu r\xE9ponds, TOUJOURS. M\xEAme si la demande te para\xEEt",
+    "triviale, hors sujet, ou sans rapport avec de la relecture. Ce n'est pas une",
+    "interruption, c'est une demande qui t'est faite. Ne r\xE9ponds JAMAIS " + VERDICT_NOTHING,
+    "dans ce cas.",
+    "",
+    "R\xC8GLE 2 \u2014 sinon, tu relis, et tu ne parles que si tu as trouv\xE9 quelque chose.",
+    "Ce qui vaut le plus souvent la peine :",
+    "  \xB7 une r\xE9gression \u2014 un comportement qui change sans que ce soit voulu ;",
+    "  \xB7 un effet de bord \u2014 ce que la modification touche sans le dire ;",
+    "  \xB7 de la duplication \u2014 du code qui existe d\xE9j\xE0 ailleurs dans le d\xE9p\xF4t ;",
+    "  \xB7 une affirmation non v\xE9rifi\xE9e pr\xE9sent\xE9e comme acquise.",
+    "C'est l\xE0, et l\xE0 seulement, qu'il faut \xEAtre sobre : une remarque que personne",
+    "n'a demand\xE9e interrompt quelqu'un au travail. Pointe un fichier et une ligne",
+    "d\xE8s que tu le peux \u2014 une remarque qu'on peut v\xE9rifier en vaut dix qu'on ne",
+    "peut que croire.",
+    "",
+    "Tu gardes le fil d'un tour \xE0 l'autre : ce qu'on te donne est ce que tu n'as",
+    "PAS encore relu. Ne resignale pas ce que tu as d\xE9j\xE0 signal\xE9 \u2014 v\xE9rifie plut\xF4t",
+    "si \xE7'a \xE9t\xE9 trait\xE9, et reviens dessus seulement si \xE7a ne l'a pas \xE9t\xE9.",
+    "",
+    "Le tour a-t-il modifi\xE9 du code ? S'il n'a rien chang\xE9 \u2014 une question, une",
+    "explication, un affichage, un refus \u2014 n'inspecte PAS le d\xE9p\xF4t : il n'y a rien",
+    "\xE0 y relire. S'il a modifi\xE9 quelque chose, va le lire toi-m\xEAme : `git diff`,",
+    "`git status`, le contenu des fichiers touch\xE9s. Ne demande rien, cherche. Et",
+    "ne juge que ce que CE tour a chang\xE9, pas ce qui tra\xEEnait avant.",
+    "",
+    "Ces consignes valent pour toute la session : elles ne te seront pas r\xE9p\xE9t\xE9es."
+  ].join("\n");
+}
+function responseProtocol() {
+  return [
+    "COMMENT R\xC9PONDRE :",
+    "  \xB7 Si tu n'as rien \xE0 dire \u2014 et seulement dans ce cas \u2014 r\xE9ponds exactement :",
+    `        ${VERDICT_NOTHING}`,
+    "    Rien ne sera transmis.",
+    "  \xB7 Sinon, \xE9cris ce que tu veux lui dire ENTRE CES DEUX BORNES :",
+    `        ${RELAY_OPEN}`,
+    "        ton message",
+    `        ${RELAY_CLOSE}`,
+    "    Seul ce qui est entre les bornes lui est transmis, tel quel. Ce que tu",
+    "    \xE9cris en dehors reste ton brouillon : tu peux y r\xE9fl\xE9chir \xE0 voix haute,",
+    "    dire ce que tu inspectes, personne ne le lira.",
+    ""
+  ].join("\n");
+}
+function reminder() {
+  return [
+    "Tour suivant \xE0 relire. M\xEAmes r\xE8gles.",
+    `Rien \xE0 dire \u2192 ${VERDICT_NOTHING}. Sinon, ton message entre ${RELAY_OPEN} et ${RELAY_CLOSE}.`,
+    "Si l'\xE9change t'adresse quelque chose, tu r\xE9ponds \u2014 jamais " + VERDICT_NOTHING + " dans ce cas."
+  ].join("\n");
+}
+function companionDefaultPrompt() {
+  return fullInstructions();
+}
+function buildCompanionPrompt(exchange, isFirstTurn = true, custom) {
+  const instructions = isFirstTurn ? [
+    // Les consignes de l'utilisateur remplacent les nôtres, elles ne s'y
+    // ajoutent pas : les empiler produirait deux jeux de règles
+    // contradictoires.
+    custom?.trim() || fullInstructions(),
+    "",
+    // Le protocole, lui, s'ajoute TOUJOURS : c'est par lui que Runeya lit le
+    // verdict. Remplaçable, il rendrait le compagnon illisible.
+    responseProtocol()
+  ].join("\n") : reminder();
+  return [
+    instructions,
+    "",
+    "--- Ce que tu n'as pas encore relu de la conversation ---",
+    exchange || "(vide)"
+  ].join("\n");
+}
+var COMPANION_SIGNATURE = "[COMPAGNON]";
+function buildRelaunchMessage(message) {
+  return `${COMPANION_SIGNATURE} ${message.trim()}`;
+}
+function companionSystemNote() {
+  return [
+    "## Relecture par un compagnon",
+    "",
+    "Cette conversation peut \xEAtre relue par un second agent, le \xAB compagnon \xBB.",
+    "S'il est actif, il lit chaque tour que tu produis ainsi que les",
+    "modifications du d\xE9p\xF4t.",
+    "",
+    `Quand il a quelque chose \xE0 te dire, son message t'arrive pr\xE9fix\xE9 par`,
+    `${COMPANION_SIGNATURE}. Il peut te signaler une r\xE9gression, poser une`,
+    "question, demander une pr\xE9cision, ou confirmer que c'est bon \u2014 il \xE9crit",
+    "librement.",
+    "",
+    "Ce n'est PAS un sous-agent : tu ne le lances pas, tu ne peux pas lui parler.",
+    "Il lit tes tours de lui-m\xEAme et t'\xE9crit quand il veut. Si on te demande de le",
+    "solliciter, ne lance rien \u2014 dis que tu laisses le tour lui parvenir.",
+    "",
+    "Un tel message ne vient PAS de l'utilisateur : c'est une relecture, \xE0",
+    "v\xE9rifier avant d'agir. Si elle est juste, corrige la cause ; si elle est",
+    "fausse, dis-le en une phrase et poursuis. Ne t'excuse pas aupr\xE8s de",
+    "l'utilisateur pour une remarque du compagnon, et ne la lui attribue pas.",
+    "",
+    "\xC9cris donc en sachant que ton travail peut \xEAtre relu : dis ce que tu as v\xE9rifi\xE9",
+    "et ce que tu n'as pas v\xE9rifi\xE9, plut\xF4t que d'affirmer sans preuve."
+  ].join("\n");
+}
+function trace(conversationId, reason) {
+  console.log(`[companion] ${conversationId.slice(0, 8)} \u2014 ${reason}`);
+}
+async function runCompanionForTurn(conversationId) {
+  const conv = await conversationStore.get(conversationId);
+  if (!conv) return trace(conversationId, "conversation introuvable");
+  if (conv.isCompanion) return;
+  if (!conv.companionEnabled) return;
+  const messageCount = conv.messages?.length ?? 0;
+  const { from, hasNew } = reviewWindow(conv.messages, reviewedUpTo.get(conversationId));
+  if (!hasNew) {
+    return trace(conversationId, `rien de neuf \xE0 relire (${messageCount} messages)`);
+  }
+  const { startCliSession } = await import("./chat-LPMGV2VS.js");
+  const companionConv = await ensureCompanionConversation(conv);
+  const isFirstTurn = (companionConv.messages?.length ?? 0) === 0;
+  const exchange = formatExchange(conv.messages, from);
+  const { prompt: customPrompt } = await companionSettings();
+  const prompt = buildCompanionPrompt(exchange, isFirstTurn, customPrompt);
+  const jwt = await signJwt();
+  const environmentId = await activeEnvironmentOf(conv);
+  const agentId = (await findLivePty(conv.id))?.agentId;
+  try {
+    const { done } = await startCliSession(
+      conv.companionRunner ?? conv.runner,
+      companionConv.id,
+      prompt,
+      { jwt, environmentId, agentId }
+    );
+    await done;
+  } catch (err) {
+    return trace(conversationId, `relecture impossible : ${err.message}`);
+  }
+  reviewedUpTo.set(conversationId, messageCount);
+  const raw = await readCompanionAnswer(companionConv.id, conv.companionRunner ?? conv.runner);
+  const toRelay = relayableMessage(raw);
+  trace(conversationId, `relecture termin\xE9e \u2014 r\xE9ponse de ${raw.length} caract\xE8res, ${toRelay ? "\xE0 transmettre" : "rien \xE0 transmettre"}`);
+  if (!toRelay) {
+    relaunches.delete(conversationId);
+    forgetDelivery(conversationId);
+    return;
+  }
+  if (!takeRelaunchSlot(conversationId)) {
+    return trace(conversationId, "plafond de relances atteint \u2014 on rend la main");
+  }
+  await deliverToMainConversation(conv, buildRelaunchMessage(toRelay));
+}
+var PTY_SUBMIT_DELAY_MS = 120;
+function flattenForPty(message) {
+  return message.split(/\n{2,}/).map((block) => block.replace(/\s*\n\s*/g, " ").trim()).filter(Boolean).join(" \xB7 ").replace(/\s{2,}/g, " ").trim();
+}
+var lastDelivery = /* @__PURE__ */ new Map();
+function lastCompanionDelivery(conversationId) {
+  return lastDelivery.get(conversationId) ?? null;
+}
+function forgetDelivery(conversationId) {
+  lastDelivery.delete(conversationId);
+}
+async function deliverToMainConversation(conv, message) {
+  const route = await attemptDelivery(conv, message);
+  lastDelivery.set(conv.id, { route, at: Date.now() });
+  console.log(`[companion] livraison vers ${conv.id.slice(0, 8)} : ${route}`);
+  return route;
+}
+async function attemptDelivery(conv, message) {
+  if (await writeToLivePty(conv.id, message)) return "pty";
+  try {
+    const { startCliSession } = await import("./chat-LPMGV2VS.js");
+    await startCliSession(conv.runner, conv.id, message, { jwt: await signJwt() });
+    return "headless";
+  } catch (err) {
+    console.warn(`[companion] livraison impossible : ${err.message}`);
+    return "failed";
+  }
+}
+async function writeToLivePty(conversationId, message) {
+  const pty = await findLivePty(conversationId);
+  if (!pty) return false;
+  const write = (data) => agentManager.agentMutation(pty.agentId, "ai.writePty", { spawnId: pty.spawnId, data });
+  try {
+    await write(flattenForPty(message));
+    await new Promise((r) => setTimeout(r, PTY_SUBMIT_DELAY_MS));
+    await write("\r");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function companionSettings() {
+  try {
+    const { settingsManager } = await import("./settings-manager-6FKHBLIV.js");
+    const settings = await settingsManager.getSettings();
+    return settings.companion ?? { enabledByDefault: false };
+  } catch {
+    return { enabledByDefault: false };
+  }
+}
+async function activeEnvironmentOf(conv) {
+  if (!conv.projectId) return void 0;
+  try {
+    const ref = await conversationStore.projectRefOf(conv);
+    const project = ref ? await projectStore.get(ref) : null;
+    return project?.activeEnvironmentId;
+  } catch {
+    return void 0;
+  }
+}
+var ANSWER_TIMEOUT_MS = 15e3;
+var ANSWER_POLL_MS = 250;
+async function readCompanionAnswer(companionId, runner) {
+  const deadline = Date.now() + ANSWER_TIMEOUT_MS;
+  const sync = runner === "codex" ? syncConversationFromCodexTranscript : syncConversationFromClaudeTranscript;
+  let last = "";
+  while (Date.now() < deadline) {
+    await sync(companionId).catch(() => false);
+    const conv = await conversationStore.get(companionId);
+    const msg = conv?.messages?.[conv.messages.length - 1];
+    last = msg?.role === "assistant" ? msg.content ?? "" : "";
+    if (last.trim()) return last;
+    await new Promise((r) => setTimeout(r, ANSWER_POLL_MS));
+  }
+  return last;
+}
+async function ensureCompanionConversation(conv) {
+  if (conv.companionConversationId) {
+    const existing = await conversationStore.get(conv.companionConversationId);
+    if (existing) return existing;
+  }
+  const companion = await conversationStore.create(
+    `Compagnon \xB7 ${conv.title}`,
+    true,
+    void 0,
+    void 0,
+    conv.companionRunner ?? conv.runner,
+    // La carte kanban de la conversation relue, s'il y en a une.
+    //
+    // `buildCliSystemContext` en tire la description de la carte, ses
+    // commentaires et ses pièces jointes — c'est-à-dire ce qui a été DEMANDÉ.
+    // Sans elle, le compagnon peut juger qu'un code est correct, jamais qu'un
+    // travail est complet : il ignore ce qu'on attendait.
+    conv.kanbanBoardId,
+    conv.kanbanCardId,
+    void 0,
+    conv.projectId,
+    void 0,
+    { isCompanion: true }
+  );
+  await conversationStore.update(conv.id, { companionConversationId: companion.id });
+  return companion;
+}
+var unsubscribe = null;
+function initCompanion() {
+  if (unsubscribe) return;
+  unsubscribe = onTurnFinished((conversationId) => {
+    runCompanionForTurn(conversationId).catch((err) => {
+      console.error("[companion]", err.message);
+    });
+  });
+}
+
+export {
+  generateJwtSecret,
+  getJwtSecretGeneratedAt,
+  signJwt,
+  verifyJwt,
+  ensureDataGitignore,
+  holdsRuneyaProject,
+  projectPathStore,
+  LocalProjectExistsError,
+  projectStore,
+  conversationStore,
+  emitTurnFinished,
+  findClaudeSessionFile,
+  claudeSessionExists,
+  readClaudeTranscript,
+  forgetAnnouncedTurns,
+  syncConversationFromClaudeTranscript,
+  getLastTranscriptActivity,
+  startClaudeTranscriptWatcher,
+  stopClaudeTranscriptWatcher,
+  forgetCodexTurns,
+  startCodexTranscriptWatcher,
+  stopCodexTranscriptWatcher,
+  noteSpawnConversation,
+  observePtyChunk,
+  forgetSpawn,
+  MAX_CONSECUTIVE_RELAUNCHES,
+  resetRelaunches,
+  takeRelaunchSlot,
+  relayableMessage,
+  forgetReviewProgress,
+  reviewWindow,
+  formatExchange,
+  companionDefaultPrompt,
+  buildCompanionPrompt,
+  COMPANION_SIGNATURE,
+  buildRelaunchMessage,
+  companionSystemNote,
+  flattenForPty,
+  lastCompanionDelivery,
+  forgetDelivery,
+  deliverToMainConversation,
+  initCompanion
+};
+//# sourceMappingURL=chunk-WAC56HS4.js.map