@runeya/runeya 2.0.146 → 2.0.147

package/{chunk-UD42LACH.js → chunk-JNK6H5KH.js}

@@ -1,23 +1,23 @@
 import {
-  AmbiguousProjectError,
+  projectPathStore,
+  projectStore
+} from "./chunk-7QXP4FXD.js";
+import {
+  agentManager
+} from "./chunk-5XG3X2TM.js";
+import {
+  serviceStore
+} from "./chunk-4D3GCBPO.js";
+import {
   StoreDiskCoordinator,
-  agentManager,
   decryptValue,
   encryptValue,
   ensureProjectsLoaded,
-  environmentStore,
-  forgetProject,
   getEncryptionKey,
-  projectKey,
-  recordDetached,
   refOfProjectAmong,
-  registerProjectLoader,
   rootOfProjectAmong,
-  rootOfProjectRef,
-  serviceStore,
-  setProjectServices,
-  setProjectVault
-} from "./chunk-KV4GJKXU.js";
+  rootOfProjectRef
+} from "./chunk-DFPZ4MTI.js";
 import {
   atomicWriteSecure,
   fingerprintFiles,
@@ -34,977 +34,44 @@ import {
 } from "./chunk-MD3VW4HQ.js";
 import {
   allVaultRoots,
-  collidesWithMachineRoot,
   env,
-  forgetLocalProjectRoot,
   keyedFilePath,
   legacyMachineFilePath,
-  listCloudVaults,
-  localProjectVaultRoot,
-  localVaultCollidesWithMachineRoot,
   localVaultRoot,
-  machineFilePath,
-  machineRoot,
   orgIdOfRoot,
-  readLocalProjectDirs,
-  registerLocalProjectDir,
-  setLocalProjectRoot,
-  unregisterLocalProjectDir,
   vaultFor,
   vaultIdOfRoot
 } from "./chunk-VPSQJOSN.js";
 import {
   COMPANION_RELAY_CLOSE,
   COMPANION_RELAY_OPEN,
-  ProjectSchema,
   extractCompanionRelay
 } from "./chunk-MZSDTA4A.js";
 
 // ../server/src/services/companion.ts
-import { EventEmitter as EventEmitter4 } from "events";
+import { EventEmitter as EventEmitter3 } from "events";
 
 // ../server/src/services/conversation-store.ts
-import { randomUUID as randomUUID3 } from "crypto";
-import { readFile as readFile4, readdir, mkdir as mkdir3, rename as rename3, rm as rm2, stat as stat2 } from "fs/promises";
-import { dirname as dirname2, join as join4 } from "path";
-import { EventEmitter as EventEmitter2 } from "events";
-
-// ../server/src/services/project-store.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { EventEmitter } from "events";
-import { mkdir as mkdir2, readFile as readFile3, rename as rename2, rm } from "fs/promises";
-import { dirname, join as join3, resolve as resolve2 } 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/conversation-section-store.ts
 import { randomUUID } from "crypto";
-import { readFile } from "fs/promises";
-var FILENAME = "conversation-sections.json";
-function isSectionMap(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  return Object.values(value).every((list) => Array.isArray(list) && list.every((s) => !!s && typeof s === "object" && typeof s.id === "string" && typeof s.name === "string" && typeof s.order === "number"));
-}
-var ConversationSectionStore = class {
-  async read() {
-    try {
-      const parsed = JSON.parse(await readFile(machineFilePath(FILENAME), "utf-8"));
-      return isSectionMap(parsed) ? parsed : {};
-    } catch {
-      return {};
-    }
-  }
-  async write(map) {
-    await atomicWriteSecure(machineFilePath(FILENAME), JSON.stringify(map, null, 2));
-  }
-  /** Les sections d'un projet, dans l'ordre choisi. */
-  async list(projectId) {
-    const map = await this.read();
-    return (map[projectId] ?? []).slice().sort((a, b) => a.order - b.order);
-  }
-  async get(projectId, id) {
-    return (await this.list(projectId)).find((s) => s.id === id) ?? null;
-  }
-  /** Crée une section, posée après les autres. */
-  async create(projectId, name) {
-    const map = await this.read();
-    const list = map[projectId] ?? [];
-    const order = list.length > 0 ? Math.max(...list.map((s) => s.order)) + 1 : 0;
-    const section = { id: randomUUID(), name, order };
-    map[projectId] = [...list, section];
-    await this.write(map);
-    return section;
-  }
-  async rename(projectId, id, name) {
-    const map = await this.read();
-    const section = map[projectId]?.find((s) => s.id === id);
-    if (!section) return null;
-    section.name = name;
-    await this.write(map);
-    return section;
-  }
-  /** Retire une section. Rend `false` si elle n'existait pas. */
-  async remove(projectId, id) {
-    const map = await this.read();
-    const list = map[projectId] ?? [];
-    const next = list.filter((s) => s.id !== id);
-    if (next.length === list.length) return false;
-    if (next.length > 0) map[projectId] = next;
-    else delete map[projectId];
-    await this.write(map);
-    return true;
-  }
-  /**
-   * Range les sections du projet dans l'ordre de `ids`.
-   *
-   * Une section absente de `ids` passe après les autres, dans son ordre
-   * d'avant : un appel parti avant la création d'une section ne la fait pas
-   * disparaître. Un id inconnu est ignoré.
-   */
-  async reorder(projectId, ids) {
-    const map = await this.read();
-    const list = (map[projectId] ?? []).slice().sort((a, b) => a.order - b.order);
-    if (list.length === 0) return;
-    const rank = new Map(Array.from(new Set(ids)).map((id, i) => [id, i]));
-    const listed = list.filter((s) => rank.has(s.id)).sort((a, b) => rank.get(a.id) - rank.get(b.id));
-    const others = list.filter((s) => !rank.has(s.id));
-    map[projectId] = [...listed, ...others].map((s, i) => ({ ...s, order: i }));
-    await this.write(map);
-  }
-  /** Oublie les sections d'un projet supprimé. */
-  async forgetProject(projectId) {
-    const map = await this.read();
-    if (!(projectId in map)) return;
-    delete map[projectId];
-    await this.write(map);
-  }
-};
-var conversationSectionStore = new ConversationSectionStore();
-
-// ../server/src/services/project-path-store.ts
-import { readFile as readFile2, writeFile as writeFile2, rename, mkdir, chmod, stat } from "fs/promises";
-import { isAbsolute, join as join2, resolve } from "path";
-var FILENAME2 = "project-paths.json";
-var ProjectPathStore = class {
-  paths = null;
-  async load() {
-    if (this.paths) return this.paths;
-    try {
-      const raw = await readFile2(machineFilePath(FILENAME2), "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(FILENAME2);
-    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.
-   *
-   * `isKnown` écarte les entrées d'un projet que ce poste ne connaît plus : un
-   * projet disparu ne doit pas continuer de retenir son dossier.
-   */
-  async projectAt(path, exclude, isKnown = () => true) {
-    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 && isKnown(key)) 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) {
-  return stat(join2(path, ".runeya", "project.json")).then(() => true, () => false);
-}
-var projectPathStore = new ProjectPathStore();
-
-// ../server/src/services/project-store.ts
-var FILENAME3 = "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 readFile3(join3(root, FILENAME3), "utf-8");
-    const parsed = ProjectSchema.safeParse(JSON.parse(raw));
-    if (parsed.success) current = parsed.data;
-  } catch {
-  }
-  let legacy;
-  try {
-    legacy = JSON.parse(await readFile3(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 };
-}
-function isRegistrable(root) {
-  return localProjectVaultRoot(dirname(root)) === resolve2(root);
-}
-async function readLocalProjectAt(root) {
-  try {
-    const parsed = ProjectSchema.safeParse(JSON.parse(await readFile3(join3(root, FILENAME3), "utf-8")));
-    return parsed.success && !parsed.data.orgId ? parsed.data : null;
-  } catch {
-    return null;
-  }
-}
-async function readCloudProjects() {
-  const found = [];
-  for (const { orgId, projectId, root } of await listCloudVaults()) {
-    try {
-      const raw = await readFile3(join3(root, FILENAME3), "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 LocalProjectRefusedError = class extends Error {
-};
-var LocalProjectExistsError = class extends LocalProjectRefusedError {
-  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 LocalProjectInMachineRootError = class extends LocalProjectRefusedError {
-  code = "LOCAL_PROJECT_IN_MACHINE_ROOT";
-  constructor() {
-    super(
-      "This directory holds Runeya's own data. A local project here would mix its files with the machine's vaults: launch Runeya from another directory, or create the project in an organization."
-    );
-    this.name = "LocalProjectInMachineRootError";
-  }
-};
-var LocalProjectCloudLinkedError = class extends LocalProjectRefusedError {
-  code = "LOCAL_PROJECT_CLOUD_LINKED";
-  constructor() {
-    super("This directory is already linked to an organization project. Choose another directory.");
-    this.name = "LocalProjectCloudLinkedError";
-  }
-};
-var LocalProjectNotFoundError = class extends LocalProjectRefusedError {
-  code = "LOCAL_PROJECT_NOT_FOUND";
-  constructor() {
-    super("This directory holds no local Runeya project to import.");
-    this.name = "LocalProjectNotFoundError";
-  }
-};
-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();
-  /**
-   * Les coffres où un projet local a été lu ou écrit. À l'écriture, un coffre
-   * de cette liste qui n'a plus de projet perd sa fiche : c'est ainsi qu'une
-   * suppression ou une publication vide le dossier qu'elle quitte.
-   */
-  localRoots = /* @__PURE__ */ new Set();
-  loaded = false;
-  /**
-   * L'état du disque tel qu'il était au dernier chargement.
-   *
-   * Plusieurs Runeya partagent la racine machine — l'application installée et
-   * celle qu'on développe, couramment — et créent donc des projets dans les
-   * mêmes coffres. Un store chargé une fois pour toutes ne voit jamais le
-   * travail de l'autre : il faudrait le redémarrer pour qu'un projet créé à
-   * côté existe pour lui.
-   */
-  fingerprint = "";
-  disk = new StoreDiskCoordinator();
-  /** Emits `'saved'` after every persisted mutation, for the cloud sync bridge. */
-  events = new EventEmitter();
-  getFilePath(root = localVaultRoot()) {
-    return join3(root, FILENAME3);
-  }
-  /** Adopt a project read from disk, remembering which vault it came from. */
-  async absorb(into, p, root) {
-    const projectEnvs = await environmentStore.getByProjectId(p.id).catch(() => []);
-    const defaultEnv = projectEnvs.find((e) => e.default);
-    into.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]
-    });
-    if (!p.orgId) {
-      setLocalProjectRoot(p.id, root);
-      this.localRoots.add(root);
-    }
-    setProjectVault(p, root);
-    setProjectServices(p, p.serviceIds ?? []);
-  }
-  /**
-   * Ce que le disque porte : quels coffres, et quand leur fiche a changé.
-   *
-   * Les coffres sont demandés à `listCloudVaults`, qui les découvre déjà par
-   * balayage — en refaire un ici donnerait deux inventaires à tenir d'accord.
-   * Seules les dates sont relevées : lire et analyser les fiches, puis les
-   * absorber (ce qui va interroger les environnements), est justement ce que ce
-   * repère évite de refaire à chaque appel.
-   */
-  async diskFingerprint() {
-    return fingerprintFiles([
-      this.getFilePath(),
-      ...(await readLocalProjectDirs()).map((dir) => this.getFilePath(localProjectVaultRoot(dir))),
-      ...(await listCloudVaults()).map((v) => this.getFilePath(v.root))
-    ]);
-  }
-  /**
-   * 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.
-   *
-   * Relu quand le disque a bougé, pas une fois pour toutes : une autre instance
-   * partageant cette racine machine y crée des projets, et ne jamais relire
-   * reviendrait à exiger un redémarrage pour les voir.
-   */
-  async load() {
-    let migrated = false;
-    await this.disk.load(async () => {
-      const fingerprint = await this.diskFingerprint();
-      if (this.loaded && fingerprint === this.fingerprint) return null;
-      const next = await this.readVaults();
-      return () => {
-        for (const [key, project] of next.projects) {
-          const before = this.projects.get(key)?.activeEnvironmentId;
-          if (before && project.environmentIds.includes(before)) {
-            project.activeEnvironmentId = before;
-          } else {
-            this.unsettled.add(key);
-          }
-        }
-        this.projects = next.projects;
-        this.fingerprint = fingerprint;
-        this.loaded = true;
-        migrated = next.migrated;
-      };
-    });
-    if (migrated) {
-      await this.save();
-      await serviceStore.relocateAll();
-      await environmentStore.relocateAll();
-    }
-  }
-  /** Le parcours proprement dit, dans une table neuve que `load` substitue. */
-  async readVaults() {
-    const projects = /* @__PURE__ */ new Map();
-    this.localRoots = /* @__PURE__ */ new Set();
-    const { local, strayCloud } = await readLocalProject();
-    if (local) {
-      await this.absorb(projects, local, localVaultRoot());
-      if (!localVaultCollidesWithMachineRoot() && isRegistrable(localVaultRoot())) {
-        await registerLocalProjectDir(dirname(localVaultRoot())).catch(() => {
-        });
-      }
-    }
-    for (const dir of await readLocalProjectDirs()) {
-      const root = localProjectVaultRoot(dir);
-      if (root === localVaultRoot()) continue;
-      const found = await readLocalProjectAt(root);
-      if (!found || projects.has(projectKey(found))) continue;
-      await this.absorb(projects, found, root);
-    }
-    let migrated = false;
-    for (const project of strayCloud) {
-      try {
-        await this.absorb(projects, project, vaultFor(project).root);
-        migrated = true;
-      } catch {
-      }
-    }
-    for (const { project, root } of await readCloudProjects()) {
-      await this.absorb(projects, project, root);
-    }
-    return { projects, migrated };
-  }
-  /**
-   * 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.
-   */
-  save() {
-    return this.disk.save(() => this.writeVaults());
-  }
-  async writeVaults() {
-    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 });
-    }
-    const written = /* @__PURE__ */ new Map();
-    for (const local of locals) {
-      const root = vaultFor(local).root;
-      const other = written.get(root);
-      if (other) {
-        throw new Error(
-          `Refusing to save two local projects in ${root}: "${other.name}" and "${local.name}". A directory holds a single local project.`
-        );
-      }
-      written.set(root, local);
-    }
-    for (const [root, local] of written) {
-      await mkdir2(root, { recursive: true });
-      await ensureDataGitignore(root);
-      await atomicWriteSecure(this.getFilePath(root), JSON.stringify(toDiskForm(local), null, 2));
-      this.localRoots.add(root);
-    }
-    for (const root of this.localRoots) {
-      if (written.has(root)) continue;
-      await rm(this.getFilePath(root), { force: true }).catch(() => {
-      });
-      if (isRegistrable(root)) await unregisterLocalProjectDir(dirname(root)).catch(() => {
-      });
-      this.localRoots.delete(root);
-    }
-    await rename2(join3(localVaultRoot(), LEGACY_FILENAME), join3(localVaultRoot(), LEGACY_FILENAME + ".bak")).catch(() => {
-    });
-    for (const { project, root } of cloud) {
-      await atomicWriteSecure(this.getFilePath(root), JSON.stringify(toDiskForm(project), null, 2));
-      setProjectVault(project, root);
-    }
-    this.fingerprint = await this.diskFingerprint();
-    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;
-  }
-  /**
-   * Le projet déjà placé dans ce dossier, parmi ceux que ce poste connaît.
-   *
-   * Une entrée de `project-paths.json` peut survivre à son projet (supprimé
-   * ailleurs, ou avant que la suppression ne la nettoie). Elle ne réserve plus
-   * rien : le refus qui en découlait nommait un projet introuvable.
-   */
-  async projectAtPath(path, exclude) {
-    await this.load();
-    const ids = new Set(Array.from(this.projects.values(), (p) => p.id));
-    return projectPathStore.projectAt(path, exclude, (key) => this.projects.has(key) || ids.has(key));
-  }
-  async list() {
-    await this.load();
-    await this.settleActiveEnvironments();
-    return Array.from(this.projects.values());
-  }
-  async get(target) {
-    await this.load();
-    await this.settleActiveEnvironments();
-    return this.find(target)?.project ?? null;
-  }
-  /**
-   * Projets dont l'environnement actif vient d'un repli et n'a pas été vérifié.
-   *
-   * Au chargement, les environnements ne sont pas encore lisibles : leur magasin
-   * attend justement la fin de ce chargement. `absorb` retient donc le premier
-   * id de `environmentIds`, qui peut désigner un environnement disparu. Le
-   * sélecteur affichait alors cet id brut, absent de sa liste.
-   */
-  unsettled = /* @__PURE__ */ new Set();
-  settling = false;
-  /** Retenir, pour chaque projet non vérifié, un environnement qui existe. */
-  async settleActiveEnvironments() {
-    if (this.settling || this.unsettled.size === 0) return;
-    this.settling = true;
-    try {
-      for (const key of this.unsettled) {
-        const project = this.projects.get(key);
-        if (!project) {
-          this.unsettled.delete(key);
-          continue;
-        }
-        const envs = (await environmentStore.getByProjectId(project.id, project.orgId ?? null).catch(() => [])).filter((e) => e.scope !== "service");
-        if (envs.length === 0) continue;
-        const current = envs.find((e) => e.id === project.activeEnvironmentId);
-        const chosen = envs.find((e) => e.default) ?? current ?? envs[0];
-        project.activeEnvironmentId = chosen.id;
-        this.unsettled.delete(key);
-      }
-    } finally {
-      this.settling = false;
-    }
-  }
-  /**
-   * Vérifier qu'un dossier peut accueillir un projet local, et rendre son coffre.
-   *
-   * Refusé si son `.runeya` serait la racine machine, si le dossier est déjà
-   * l'emplacement d'un projet d'organisation, ou s'il porte déjà un projet.
-   */
-  async localRootFor(root) {
-    if (collidesWithMachineRoot(root)) throw new LocalProjectInMachineRootError();
-    if (await this.projectAtPath(dirname(root))) throw new LocalProjectCloudLinkedError();
-    const known = Array.from(this.projects.values()).find((p) => !p.orgId && vaultFor(p).root === root);
-    if (known) throw new LocalProjectExistsError(known.name);
-    const onDisk = await readLocalProjectAt(root);
-    if (onDisk) throw new LocalProjectExistsError(onDisk.name);
-    if (root !== localVaultRoot() && await holdsRuneyaProject(dirname(root))) throw new LocalProjectExistsError("");
-    return root;
-  }
-  /**
-   * `localDir` : le dossier d'un projet local. Omis, c'est le dossier de
-   * lancement, comme avant que les projets locaux aient chacun le leur.
-   */
-  async create(input, localDir) {
-    await this.load();
-    const localRoot = input.orgId ? null : await this.localRootFor(localDir ? localProjectVaultRoot(localDir) : localVaultRoot());
-    const project = {
-      id: randomUUID2(),
-      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);
-    if (localRoot) {
-      setLocalProjectRoot(project.id, localRoot);
-      if (isRegistrable(localRoot)) await registerLocalProjectDir(dirname(localRoot));
-    }
-    setProjectVault(project, vaultFor(project).root);
-    setProjectServices(project, project.serviceIds);
-    await this.save();
-    return project;
-  }
-  /**
-   * Ce qu'un dossier permet pour un projet local : en créer un (`available`),
-   * importer celui qu'il porte (`importable`), rien parce qu'il est déjà dans
-   * la liste (`listed`), ou rien parce qu'il est refusé.
-   */
-  async inspectLocalDir(dir) {
-    await this.load();
-    const root = localProjectVaultRoot(dir);
-    if (collidesWithMachineRoot(root)) return { status: "machine-root", projectName: null };
-    if (await this.projectAtPath(resolve2(dir))) return { status: "cloud-linked", projectName: null };
-    const known = Array.from(this.projects.values()).find((p) => !p.orgId && vaultFor(p).root === root);
-    if (known) return { status: "listed", projectName: known.name };
-    const onDisk = await readLocalProjectAt(root);
-    if (onDisk) return { status: "importable", projectName: onDisk.name };
-    if (await holdsRuneyaProject(dirname(root))) return { status: "unreadable", projectName: null };
-    return { status: "available", projectName: null };
-  }
-  /**
-   * Ajouter à la liste le projet local déjà présent dans ce dossier.
-   *
-   * Son `.runeya` n'est pas touché : le dossier est seulement enregistré, et le
-   * projet relu comme les autres.
-   */
-  async importLocal(dir) {
-    await this.load();
-    const root = localProjectVaultRoot(dir);
-    if (collidesWithMachineRoot(root)) throw new LocalProjectInMachineRootError();
-    if (await this.projectAtPath(resolve2(dir))) throw new LocalProjectCloudLinkedError();
-    const found = await readLocalProjectAt(root);
-    if (!found) throw new LocalProjectNotFoundError();
-    const known = this.projects.get(projectKey(found));
-    if (known) return known;
-    await registerLocalProjectDir(dirname(root));
-    this.loaded = false;
-    await this.load();
-    return this.projects.get(projectKey(found)) ?? found;
-  }
-  /**
-   * `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 }
-    };
-    recordDetached(existing.id, "serviceIds", existing.serviceIds ?? [], updated.serviceIds ?? []);
-    recordDetached(existing.id, "environmentIds", existing.environmentIds ?? [], updated.environmentIds ?? []);
-    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 localRoot = vaultFor(local).root;
-    const localDir = localRoot === localVaultRoot() ? null : dirname(localRoot);
-    const moved = { ...local, orgId };
-    this.projects.delete(projectKey(local));
-    forgetProject(local);
-    forgetLocalProjectRoot(local.id);
-    this.projects.set(projectKey(moved), moved);
-    setProjectVault(moved, vaultFor(moved).root);
-    setProjectServices(moved, moved.serviceIds ?? []);
-    await this.save();
-    if (localDir && !await projectPathStore.get(moved)) {
-      await projectPathStore.set(moved, localDir);
-    }
-    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);
-    await conversationSectionStore.forgetProject(project.id);
-    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) forgetLocalProjectRoot(project.id);
-    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);
-  }
-  /**
-   * Le projet qui porte un service, ou `null` s'il n'est rattaché à aucun.
-   *
-   * Un service n'appartient qu'à un projet : la recherche s'arrête au premier.
-   */
-  async ofService(serviceId) {
-    await this.load();
-    for (const project of this.projects.values()) {
-      if (project.serviceIds.includes(serviceId)) return project;
-    }
-    return null;
-  }
-  /** 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);
-    await projectPathStore.clear(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) };
-    recordDetached(project.id, "serviceIds", project.serviceIds, updated.serviceIds);
-    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 }
-    };
-    recordDetached(project.id, "environmentIds", project.environmentIds ?? [], updated.environmentIds);
-    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);
-    this.unsettled.delete(key);
-    return updated;
-  }
-};
-var projectStore = new ProjectStore();
-registerProjectLoader(() => projectStore.list().then(() => void 0));
-
-// ../server/src/services/conversation-store.ts
-var FILENAME4 = "conversations.private.json";
+import { readFile, readdir, mkdir, rename, rm, stat } from "fs/promises";
+import { dirname, join } from "path";
+import { EventEmitter } from "events";
+var FILENAME = "conversations.private.json";
 var CONVERSATIONS_DIRNAME = "conversations";
 var FILE_SUFFIX = ".private.json";
 var SAFE_ID_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/;
 function conversationDir(root) {
-  return join4(root, CONVERSATIONS_DIRNAME);
+  return join(root, CONVERSATIONS_DIRNAME);
 }
 function conversationPath(root, id) {
-  return join4(root, CONVERSATIONS_DIRNAME, `${id}${FILE_SUFFIX}`);
+  return join(root, CONVERSATIONS_DIRNAME, `${id}${FILE_SUFFIX}`);
 }
 function migratedAggregateName(now) {
   return `conversations.migrated-${now.toISOString().replace(/[:.]/g, "-").substring(0, 19)}.private.json`;
 }
 async function fileStamp(path) {
   try {
-    const s = await stat2(path);
+    const s = await stat(path);
     return `${s.mtimeMs}:${s.size}:${s.ino}`;
   } catch {
     return null;
@@ -1039,7 +106,7 @@ var ConversationStore = class {
    * conversation écrite dans l'autre fenêtre.
    */
   fingerprint = "";
-  events = new EventEmitter2().setMaxListeners(0);
+  events = new EventEmitter().setMaxListeners(0);
   disk = new StoreDiskCoordinator();
   /** Le fichier où chaque conversation est écrite aujourd'hui, s'il existe. */
   written = /* @__PURE__ */ new Map();
@@ -1070,11 +137,11 @@ var ConversationStore = class {
    * root, but a launch directory owning its own key keeps both together.
    */
   getFilePath() {
-    return keyedFilePath(FILENAME4);
+    return keyedFilePath(FILENAME);
   }
   /** Where older versions kept it — read only, so an older Runeya keeps working. */
   getLegacyFilePath() {
-    return legacyMachineFilePath(FILENAME4);
+    return legacyMachineFilePath(FILENAME);
   }
   /**
    * Read the machine file, falling back to the launch directory of old.
@@ -1084,13 +151,13 @@ var ConversationStore = class {
    */
   async readFromDisk() {
     try {
-      return await readFile4(await this.getFilePath(), "utf-8");
+      return await readFile(await this.getFilePath(), "utf-8");
     } catch {
-      return readFile4(this.getLegacyFilePath(), "utf-8");
+      return readFile(this.getLegacyFilePath(), "utf-8");
     }
   }
   async ensureDir() {
-    await mkdir3(dirname2(await this.getFilePath()), { recursive: true });
+    await mkdir(dirname(await this.getFilePath()), { recursive: true });
   }
   encryptMessages(messages, vault) {
     return encryptValue(JSON.stringify(messages), vault);
@@ -1197,10 +264,10 @@ ${new Error("trace").stack}`
   /** Les fichiers dont ce store tire son contenu : les coffres, et l'hérité. */
   async sourcePaths() {
     const vaults = await allVaultRoots();
-    const legacyPaths = [this.getLegacyFilePath(), await keyedFilePath(FILENAME4)];
+    const legacyPaths = [this.getLegacyFilePath(), await keyedFilePath(FILENAME)];
     const all = [
       ...legacyPaths.map((path) => ({ path, legacy: true })),
-      ...vaults.map((root) => ({ path: join4(root, FILENAME4), legacy: false }))
+      ...vaults.map((root) => ({ path: join(root, FILENAME), legacy: false }))
     ];
     return all.filter((source, i) => !all.slice(i + 1).some((later) => later.path === source.path));
   }
@@ -1209,7 +276,7 @@ ${new Error("trace").stack}`
    * doublon. Le dossier de lancement hérité en fait partie.
    */
   async sourceRoots() {
-    return Array.from(new Set((await this.sourcePaths()).map((s) => dirname2(s.path))));
+    return Array.from(new Set((await this.sourcePaths()).map((s) => dirname(s.path))));
   }
   /**
    * L'état du disque : les anciens fichiers, et les dossiers `conversations/`.
@@ -1220,7 +287,7 @@ ${new Error("trace").stack}`
    */
   async diskFingerprint() {
     const paths = (await this.sourcePaths()).map((s) => s.path);
-    const dirs = Array.from(new Set(paths.map((path) => conversationDir(dirname2(path)))));
+    const dirs = Array.from(new Set(paths.map((path) => conversationDir(dirname(path)))));
     return fingerprintFiles([...paths, ...dirs]);
   }
   async load() {
@@ -1295,7 +362,7 @@ ${new Error("trace").stack}`
       }
       const now = /* @__PURE__ */ new Date();
       for (const { path } of aggregates) {
-        await rename3(path, join4(dirname2(path), migratedAggregateName(now)));
+        await rename(path, join(dirname(path), migratedAggregateName(now)));
         forgetFile(path);
         console.log(`[conversation-store] ${path} converti en un fichier par conversation.`);
       }
@@ -1323,18 +390,18 @@ ${new Error("trace").stack}`
       unreadable.set(root, bucket);
     };
     const sources = await this.sourcePaths();
-    const legacyRoots = new Set(sources.filter((s) => s.legacy).map((s) => dirname2(s.path)));
+    const legacyRoots = new Set(sources.filter((s) => s.legacy).map((s) => dirname(s.path)));
     const inheritedProject = legacyRoots.size > 0 ? await localProjectId() : null;
     for (const { path, legacy } of sources) {
       let data;
       try {
-        data = JSON.parse(await readFile4(path, "utf-8"));
+        data = JSON.parse(await readFile(path, "utf-8"));
       } catch {
         continue;
       }
       aggregates.push({ path });
       const inherited = legacy ? inheritedProject : null;
-      const root = dirname2(path);
+      const root = dirname(path);
       await rememberFile(path);
       for (const item of data) {
         try {
@@ -1357,14 +424,14 @@ ${new Error("trace").stack}`
         continue;
       }
       for (const name of names) {
-        const path = join4(dir, name);
+        const path = join(dir, name);
         const stamp = await fileStamp(path);
         if (!stamp) continue;
         let entry = this.parsed.get(path);
         if (!entry || entry.stamp !== stamp) {
           let item2;
           try {
-            item2 = JSON.parse(await readFile4(path, "utf-8"));
+            item2 = JSON.parse(await readFile(path, "utf-8"));
           } catch {
             continue;
           }
@@ -1479,7 +546,7 @@ ${new Error("trace").stack}`
       if (previous && previous !== path) removed.push(previous);
     }
     for (const path of removed) {
-      await rm2(path, { force: true });
+      await rm(path, { force: true });
       forgetFile(path);
       this.parsed.delete(path);
     }
@@ -1494,7 +561,7 @@ ${new Error("trace").stack}`
   async rootFor(conv) {
     const known = this.roots.get(conv.id) ?? null;
     if (conv.projectId) return rootOfProjectAmong(conv.projectId, known);
-    return known ?? dirname2(await keyedFilePath(FILENAME4));
+    return known ?? dirname(await keyedFilePath(FILENAME));
   }
   /**
    * Le projet d'une conversation, organisation comprise.
@@ -1569,7 +636,7 @@ ${new Error("trace").stack}`
     await this.load();
     const now = Date.now();
     const conv = {
-      id: randomUUID3(),
+      id: randomUUID(),
       projectId,
       title: title ?? "New conversation",
       messages: [],
@@ -1746,13 +813,13 @@ ${new Error("trace").stack}`
 var conversationStore = new ConversationStore();
 
 // ../server/src/services/workspace-cwd.ts
-import { isAbsolute as isAbsolute2, join as join5, dirname as dirname3 } from "path";
+import { isAbsolute, join as join2, dirname as dirname2 } from "path";
 async function projectRoot(ref) {
   const project = await projectStore.get(ref);
   if (!project) return null;
   if (!project.orgId) {
     const root = vaultFor(project).root;
-    return root === localVaultRoot() ? null : dirname3(root);
+    return root === localVaultRoot() ? null : dirname2(root);
   }
   return projectPathStore.get(project);
 }
@@ -1777,11 +844,11 @@ async function resolveWorkspaceCwd(target) {
 }
 function anchor(base, raw) {
   if (!raw || raw === ".") return base;
-  if (raw.startsWith("~") || raw.startsWith("$") || isAbsolute2(raw)) return raw;
-  return join5(base, raw);
+  if (raw.startsWith("~") || raw.startsWith("$") || isAbsolute(raw)) return raw;
+  return join2(base, raw);
 }
 function localVaultRootParent() {
-  return dirname3(localVaultRoot());
+  return dirname2(localVaultRoot());
 }
 async function resolveAgentCwd(target) {
   if (target.serviceId) {
@@ -1809,8 +876,8 @@ async function resolveConversationCwd(conversationId) {
 }
 
 // ../server/src/services/turn-events.ts
-import { EventEmitter as EventEmitter3 } from "events";
-var bus = new EventEmitter3();
+import { EventEmitter as EventEmitter2 } from "events";
+var bus = new EventEmitter2();
 bus.setMaxListeners(0);
 function emitTurnFinished(conversationId) {
   bus.emit("turn-finished", conversationId);
@@ -1823,11 +890,11 @@ function onTurnFinished(listener) {
 }
 
 // ../server/src/services/claude-transcript-sync.ts
-import { readdir as readdir2, access, readFile as readFile5 } from "fs/promises";
+import { readdir as readdir2, access, readFile as readFile2 } from "fs/promises";
 import { watch } from "fs";
 import { homedir } from "os";
-import { join as join6 } from "path";
-var PROJECTS_DIR = join6(homedir(), ".claude", "projects");
+import { join as join3 } from "path";
+var PROJECTS_DIR = join3(homedir(), ".claude", "projects");
 var DEFAULT_TITLES = /* @__PURE__ */ new Set(["", "New conversation", "Nouvelle conversation"]);
 async function findClaudeSessionFile(sessionId) {
   let entries;
@@ -1838,7 +905,7 @@ async function findClaudeSessionFile(sessionId) {
   }
   const filename = `${sessionId}.jsonl`;
   for (const dir of entries) {
-    const candidate = join6(PROJECTS_DIR, dir, filename);
+    const candidate = join3(PROJECTS_DIR, dir, filename);
     try {
       await access(candidate);
       return candidate;
@@ -1853,7 +920,7 @@ async function claudeSessionExists(sessionId) {
 async function readClaudeTranscript(sessionId) {
   const path = await findClaudeSessionFile(sessionId);
   if (!path) return { found: false, path: null, entries: [] };
-  const raw = await readFile5(path, "utf-8");
+  const raw = await readFile2(path, "utf-8");
   const entries = [];
   for (const line of raw.split("\n")) {
     if (!line.trim()) continue;
@@ -2028,7 +1095,7 @@ async function startClaudeTranscriptWatcher() {
   }
   for (const dir of topLevel) {
     try {
-      const w = watch(join6(PROJECTS_DIR, dir), (_event, filename) => {
+      const w = watch(join3(PROJECTS_DIR, dir), (_event, filename) => {
         handleFsEvent(filename ? filename.toString() : null);
       });
       w.on("error", () => {
@@ -2053,7 +1120,7 @@ function stopClaudeTranscriptWatcher() {
 
 // ../server/src/services/codex-transcript-sync.ts
 import { watch as watch2 } from "fs";
-import { dirname as dirname4 } from "path";
+import { dirname as dirname3 } from "path";
 var announced = /* @__PURE__ */ new Map();
 function forgetCodexTurns(conversationId) {
   announced.delete(conversationId);
@@ -2107,7 +1174,7 @@ function startCodexTranscriptWatcher() {
   const db = findThreadDb();
   if (!db) return;
   try {
-    watcher = watch2(dirname4(db), (_event, filename) => {
+    watcher = watch2(dirname3(db), (_event, filename) => {
       if (!filename || !/^thread_history_\d+\.sqlite/.test(filename.toString())) return;
       if (debounce) clearTimeout(debounce);
       debounce = setTimeout(() => {
@@ -2220,6 +1287,100 @@ async function findLivePty(sessionId) {
   return null;
 }
 
+// ../server/src/services/pty-input.ts
+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();
+}
+async function submitToPty(write, message) {
+  await write(flattenForPty(message));
+  await new Promise((r) => setTimeout(r, PTY_SUBMIT_DELAY_MS));
+  await write("\r");
+}
+var PASTE_START = "\x1B[200~";
+var PASTE_END = "\x1B[201~";
+async function pasteToPty(write, text, options = {}) {
+  if (options.lead) await write(`${options.lead} `);
+  await write(`${PASTE_START}${text}${PASTE_END}`);
+  const delay = Math.min(PTY_SUBMIT_DELAY_MS + Math.ceil(text.length / 100), 3e3);
+  await new Promise((r) => setTimeout(r, delay));
+  await write("\r");
+}
+var PTY_INPUT_MIN_MS = { "claude-code": 1200, codex: 500 };
+var PTY_INPUT_QUIET_MS = 400;
+var PTY_INPUT_MAX_MS = 8e3;
+var PTY_MCP_READY_MAX_MS = 15e3;
+var PTY_QUIET_AFTER_MCP_MAX_MS = 3e3;
+async function waitForPtyInput(opts) {
+  const { agentId, spawnId, mcpReadyId, runner, signal } = opts;
+  if (signal?.aborted) return { status: "aborted" };
+  const { agentManager: agentManager2 } = await import("./agent-manager-46C4NIQ2.js");
+  const { waitForMcpReady } = await import("./mcp-ready-TAPBAOZY.js");
+  return new Promise((resolve) => {
+    const startedAt = Date.now();
+    const floor = PTY_INPUT_MIN_MS[runner];
+    const inner = new AbortController();
+    let done = false;
+    let mcpReady;
+    let quietArmed = !mcpReadyId;
+    let quietTimer = null;
+    let maxTimer = null;
+    let unsub = null;
+    const finish = (status) => {
+      if (done) return;
+      done = true;
+      if (quietTimer) clearTimeout(quietTimer);
+      if (maxTimer) clearTimeout(maxTimer);
+      signal?.removeEventListener("abort", onAbort);
+      inner.abort();
+      unsub?.();
+      resolve(mcpReadyId ? { status, mcpReady: mcpReady ?? false } : { status });
+    };
+    const onAbort = () => finish("aborted");
+    const scheduleQuiet = () => {
+      if (!quietArmed || done) return;
+      if (quietTimer) clearTimeout(quietTimer);
+      const wait = Math.max(PTY_INPUT_QUIET_MS, floor - (Date.now() - startedAt));
+      quietTimer = setTimeout(() => finish("ready"), wait);
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    try {
+      unsub = agentManager2.agentSubscribe(
+        agentId,
+        "ai.stream",
+        { spawnId, fromOffset: 0 },
+        (data) => {
+          const chunk = data.chunk;
+          if (chunk?.type === "exit") {
+            finish("exited");
+            return;
+          }
+          scheduleQuiet();
+        },
+        () => {
+        }
+      );
+    } catch {
+    }
+    if (done) {
+      unsub?.();
+      return;
+    }
+    if (mcpReadyId) {
+      void waitForMcpReady(mcpReadyId, PTY_MCP_READY_MAX_MS, inner.signal).then((ready) => {
+        if (done) return;
+        mcpReady = ready;
+        quietArmed = true;
+        scheduleQuiet();
+        maxTimer = setTimeout(() => finish("ready"), PTY_QUIET_AFTER_MCP_MAX_MS);
+      });
+    } else {
+      maxTimer = setTimeout(() => finish("ready"), PTY_INPUT_MAX_MS);
+    }
+  });
+}
+var PASTED_TASK_LEAD = "Here is your task. Follow the instructions below:";
+
 // ../server/src/services/active-session-registry.ts
 var MAX_BUFFER = 5e3;
 var PERSIST_DEBOUNCE_MS = 100;
@@ -2637,10 +1798,13 @@ function companionAgentId(livePtyAgentId, lastSessionAgentId) {
 function trace(conversationId, reason) {
   console.log(`[companion] ${conversationId.slice(0, 8)} \u2014 ${reason}`);
 }
+function companionApplies(conv) {
+  return !conv.isCompanion && conv.workflowType !== "scenario";
+}
 async function runCompanionForTurn(conversationId) {
   const conv = await conversationStore.get(conversationId);
   if (!conv) return trace(conversationId, "conversation introuvable");
-  if (conv.isCompanion) return;
+  if (!companionApplies(conv)) return;
   if (!conv.companionEnabled) return;
   const stopsAtStart = stops.get(conversationId) ?? 0;
   const stopped = () => (stops.get(conversationId) ?? 0) !== stopsAtStart;
@@ -2649,7 +1813,7 @@ async function runCompanionForTurn(conversationId) {
   if (!hasNew) {
     return skip(conversationId, "nothingNew", `rien de neuf \xE0 relire (${messageCount} messages)`);
   }
-  const { startCliSession } = await import("./chat-LPML22J5.js");
+  const { startCliSession } = await import("./chat-CMNDMXIP.js");
   const companionConv = await ensureCompanionConversation(conv);
   const exchange = formatExchange(conv.messages, from);
   const baseSha = await ensureCompanionBase(conv);
@@ -2700,11 +1864,7 @@ async function runCompanionForTurn(conversationId) {
     endThinking();
   }
 }
-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 bus2 = new EventEmitter4();
+var bus2 = new EventEmitter3();
 bus2.setMaxListeners(0);
 var thinking = /* @__PURE__ */ new Map();
 function companionThinkingIds() {
@@ -2768,7 +1928,7 @@ async function deliverToMainConversation(conv, message) {
 async function attemptDelivery(conv, message) {
   if (await writeToLivePty(conv.id, message)) return "pty";
   try {
-    const { startCliSession } = await import("./chat-LPML22J5.js");
+    const { startCliSession } = await import("./chat-CMNDMXIP.js");
     await startCliSession(conv.runner, conv.id, message, { jwt: await signJwt() });
     return "headless";
   } catch (err) {
@@ -2781,9 +1941,7 @@ async function writeToLivePty(conversationId, message) {
   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");
+    await submitToPty(write, message);
     return true;
   } catch {
     return false;
@@ -2903,7 +2061,7 @@ var capturingBase = /* @__PURE__ */ new Set();
 var baseTriedOnChange = /* @__PURE__ */ new Set();
 async function ensureCompanionBase(conv) {
   if (conv.companionBaseSha) return conv.companionBaseSha;
-  if (conv.isCompanion || !conv.companionEnabled || capturingBase.has(conv.id)) return void 0;
+  if (!companionApplies(conv) || !conv.companionEnabled || capturingBase.has(conv.id)) return void 0;
   capturingBase.add(conv.id);
   try {
     const agentId = conv.agentId ?? agentManager.getDefaultAgentId();
@@ -2948,12 +2106,6 @@ export {
   signJwt,
   setMcpClientCheck,
   verifyJwt,
-  ensureDataGitignore,
-  conversationSectionStore,
-  holdsRuneyaProject,
-  projectPathStore,
-  LocalProjectRefusedError,
-  projectStore,
   CONVERSATIONS_DIRNAME,
   conversationStore,
   resolveWorkspaceCwd,
@@ -2973,6 +2125,11 @@ export {
   noteSpawnConversation,
   observePtyChunk,
   forgetSpawn,
+  flattenForPty,
+  pasteToPty,
+  PTY_MCP_READY_MAX_MS,
+  waitForPtyInput,
+  PASTED_TASK_LEAD,
   activeSessionRegistry,
   MAX_CONSECUTIVE_RELAUNCHES,
   MAX_EXCHANGE_CHARS,
@@ -2989,7 +2146,7 @@ export {
   buildRelaunchMessage,
   companionSystemNote,
   companionAgentId,
-  flattenForPty,
+  companionApplies,
   companionThinkingIds,
   isCompanionThinking,
   onCompanionThinkingChanged,
@@ -3007,4 +2164,4 @@ export {
   headCommit,
   initCompanion
 };
-//# sourceMappingURL=chunk-UD42LACH.js.map
+//# sourceMappingURL=chunk-JNK6H5KH.js.map