@runeya/runeya 2.0.138 → 2.0.139

package/{chunk-C6LIGJFX.js → chunk-GLIU3J47.js}

@@ -1,9 +1,3 @@
-import {
-  findThreadDb,
-  lastTurn,
-  threadMessages,
-  threadsStartedAfter
-} from "./chunk-MD3VW4HQ.js";
 import {
   AmbiguousProjectError,
   StoreDiskCoordinator,
@@ -23,48 +17,61 @@ import {
   serviceStore,
   setProjectServices,
   setProjectVault
-} from "./chunk-ALWA4K5L.js";
+} from "./chunk-MSICJEZD.js";
 import {
   atomicWriteSecure,
   fingerprintFiles,
   hasChangedSinceRead,
   rememberFile,
   wasRead
-} from "./chunk-BDQOBEZ3.js";
+} from "./chunk-GOMF7NWS.js";
+import {
+  findThreadDb,
+  lastTurn,
+  threadMessages,
+  threadsStartedAfter
+} from "./chunk-MD3VW4HQ.js";
 import {
   COMPANION_RELAY_CLOSE,
   COMPANION_RELAY_OPEN,
   ProjectSchema,
   extractCompanionRelay
-} from "./chunk-5EMEJNVU.js";
+} from "./chunk-LE6XQ3OV.js";
 import {
   allVaultRoots,
-  ensureLocalVault,
+  collidesWithMachineRoot,
+  forgetLocalProjectRoot,
   keyedFilePath,
   legacyMachineFilePath,
   listCloudVaults,
+  localProjectVaultRoot,
+  localVaultCollidesWithMachineRoot,
   localVaultRoot,
   machineFilePath,
   machineRoot,
   orgIdOfRoot,
+  readLocalProjectDirs,
+  registerLocalProjectDir,
+  setLocalProjectRoot,
+  unregisterLocalProjectDir,
   vaultFor,
   vaultIdOfRoot
-} from "./chunk-ZFELQG4B.js";
+} from "./chunk-EV3TBM7E.js";
 
 // ../server/src/services/companion.ts
 import { EventEmitter as EventEmitter4 } from "events";
 
 // ../server/src/services/conversation-store.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { readFile as readFile3, mkdir as mkdir2 } from "fs/promises";
-import { dirname, join as join4 } from "path";
+import { readFile as readFile3, mkdir as mkdir3 } 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 } from "crypto";
 import { EventEmitter } from "events";
-import { readFile as readFile2, rename as rename2, rm } from "fs/promises";
-import { join as join3 } from "path";
+import { mkdir as mkdir2, readFile as readFile2, 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";
@@ -198,14 +205,7 @@ 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;
+  return stat(join2(path, ".runeya", "project.json")).then(() => true, () => false);
 }
 var projectPathStore = new ProjectPathStore();
 
@@ -242,6 +242,17 @@ async function readLocalProject() {
   }
   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 readFile2(join3(root, FILENAME2), "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()) {
@@ -254,7 +265,9 @@ async function readCloudProjects() {
   }
   return found;
 }
-var LocalProjectExistsError = class extends Error {
+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.`
@@ -264,6 +277,29 @@ var LocalProjectExistsError = class extends Error {
   }
   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:
@@ -272,6 +308,12 @@ var ProjectStore = class {
    * 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.
@@ -300,6 +342,10 @@ var ProjectStore = class {
       // 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 ?? []);
   }
@@ -315,6 +361,7 @@ var ProjectStore = class {
   async diskFingerprint() {
     return fingerprintFiles([
       this.getFilePath(),
+      ...(await readLocalProjectDirs()).map((dir) => this.getFilePath(localProjectVaultRoot(dir))),
       ...(await listCloudVaults()).map((v) => this.getFilePath(v.root))
     ]);
   }
@@ -358,8 +405,22 @@ var ProjectStore = class {
   /** 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 (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 {
@@ -390,20 +451,30 @@ var ProjectStore = class {
       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 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);
     }
-    const [local] = locals;
-    if (local) {
-      await ensureLocalVault();
-      await ensureDataGitignore(localVaultRoot());
-      await atomicWriteSecure(this.getFilePath(), JSON.stringify(toDiskForm(local), null, 2));
-    } else {
-      await rm(this.getFilePath(), { force: true }).catch(() => {
+    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(() => {
     });
@@ -445,14 +516,29 @@ var ProjectStore = class {
     await this.load();
     return this.find(target)?.project ?? null;
   }
-  async create(input) {
+  /**
+   * 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 projectPathStore.projectAt(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();
-    if (!input.orgId) {
-      const existing = Array.from(this.projects.values()).find((p) => !p.orgId);
-      if (existing) {
-        throw new LocalProjectExistsError(existing.name);
-      }
-    }
+    const localRoot = input.orgId ? null : await this.localRootFor(localDir ? localProjectVaultRoot(localDir) : localVaultRoot());
     const project = {
       id: randomUUID(),
       orgId: input.orgId ?? null,
@@ -464,11 +550,52 @@ var ProjectStore = class {
       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 projectPathStore.projectAt(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 projectPathStore.projectAt(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
@@ -519,13 +646,19 @@ var ProjectStore = class {
     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;
@@ -551,6 +684,7 @@ var ProjectStore = class {
    */
   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(() => {
     });
@@ -775,7 +909,7 @@ var ConversationStore = class {
     }
   }
   async ensureDir() {
-    await mkdir2(dirname(await this.getFilePath()), { recursive: true });
+    await mkdir3(dirname2(await this.getFilePath()), { recursive: true });
   }
   encryptMessages(messages, vault) {
     return encryptValue(JSON.stringify(messages), vault);
@@ -823,9 +957,11 @@ ${new Error("trace").stack}`
       workflowType: conv.workflowType,
       kanbanBoardId: conv.kanbanBoardId,
       kanbanCardId: conv.kanbanCardId,
+      agentId: conv.agentId,
       companionEnabled: conv.companionEnabled,
       companionRunner: conv.companionRunner,
       companionConversationId: conv.companionConversationId,
+      companionBaseSha: conv.companionBaseSha,
       isCompanion: conv.isCompanion,
       archived: conv.archived,
       pinOrder: conv.pinOrder,
@@ -849,9 +985,11 @@ ${new Error("trace").stack}`
       workflowType,
       kanbanBoardId: disk.kanbanBoardId,
       kanbanCardId: disk.kanbanCardId,
+      agentId: disk.agentId,
       companionEnabled: disk.companionEnabled,
       companionRunner: disk.companionRunner,
       companionConversationId: disk.companionConversationId,
+      companionBaseSha: disk.companionBaseSha,
       isCompanion: disk.isCompanion,
       archived: disk.archived,
       pinOrder: disk.pinOrder,
@@ -910,7 +1048,7 @@ ${new Error("trace").stack}`
         continue;
       }
       const inherited = legacy ? await localProjectId() : null;
-      const root = dirname(path);
+      const root = dirname2(path);
       await rememberFile(path);
       for (const item of data) {
         try {
@@ -1006,7 +1144,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 ?? dirname(await keyedFilePath(FILENAME3));
+    return known ?? dirname2(await keyedFilePath(FILENAME3));
   }
   /**
    * Le projet d'une conversation, organisation comprise.
@@ -1059,16 +1197,16 @@ ${new Error("trace").stack}`
    */
   async matcherForProject(ref) {
     await this.load();
-    let projectRoot = null;
+    let projectRoot2 = null;
     try {
-      projectRoot = ref.orgId === void 0 ? rootOfProjectAmong(ref.id, null) : rootOfProjectRef({ id: ref.id, orgId: ref.orgId ?? null });
+      projectRoot2 = ref.orgId === void 0 ? rootOfProjectAmong(ref.id, null) : rootOfProjectRef({ id: ref.id, orgId: ref.orgId ?? null });
     } catch {
-      projectRoot = null;
+      projectRoot2 = null;
     }
     return (conv) => {
       if (conv.projectId) return conv.projectId === ref.id;
-      if (!projectRoot) return true;
-      return this.roots.get(conv.id) === projectRoot;
+      if (!projectRoot2) return true;
+      return this.roots.get(conv.id) === projectRoot2;
     };
   }
   async get(id) {
@@ -1090,6 +1228,7 @@ ${new Error("trace").stack}`
       workflowType,
       kanbanBoardId,
       kanbanCardId,
+      agentId: extra?.agentId,
       isCompanion: extra?.isCompanion,
       companionEnabled: extra?.companionEnabled,
       companionRunner: extra?.companionRunner,
@@ -1117,6 +1256,7 @@ ${new Error("trace").stack}`
     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 (patch.companionBaseSha !== void 0) conv.companionBaseSha = patch.companionBaseSha;
     if (options?.touch !== false) conv.updatedAt = Date.now();
     await this.save();
     if (!options?.silent) {
@@ -1209,6 +1349,69 @@ ${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";
+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 projectPathStore.get(project);
+}
+async function resolveWorkspaceCwd(target) {
+  const launchDir = localVaultRootParent();
+  if (target.serviceId) {
+    const service = await serviceStore.get(target.serviceId);
+    if (service) {
+      const raw = (target.override ?? service.cwd ?? "").trim();
+      const projects = await projectStore.list();
+      const owner = projects.find((p) => p.serviceIds.includes(service.id));
+      const root = owner ? await projectRoot(owner) : null;
+      return root ? anchor(root, raw) : raw || ".";
+    }
+  }
+  if (target.projectId) {
+    const root = await projectRoot({ id: target.projectId, orgId: target.orgId });
+    const raw = (target.override ?? "").trim();
+    return root ? anchor(root, raw) : raw || launchDir;
+  }
+  return anchor(launchDir, (target.override ?? "").trim());
+}
+function anchor(base, raw) {
+  if (!raw || raw === ".") return base;
+  if (raw.startsWith("~") || raw.startsWith("$") || isAbsolute2(raw)) return raw;
+  return join5(base, raw);
+}
+function localVaultRootParent() {
+  return dirname3(localVaultRoot());
+}
+async function resolveAgentCwd(target) {
+  if (target.serviceId) {
+    const service = await serviceStore.get(target.serviceId);
+    if (service) {
+      const projects = await projectStore.list();
+      const owner = projects.find((p) => p.serviceIds.includes(service.id));
+      const root = owner ? await projectRoot(owner) : null;
+      if (!root) return void 0;
+      return anchor(root, (target.override ?? service.cwd ?? "").trim());
+    }
+  }
+  if (target.projectId) {
+    const root = await projectRoot({ id: target.projectId, orgId: target.orgId });
+    if (!root) return void 0;
+    return anchor(root, (target.override ?? "").trim());
+  }
+  return void 0;
+}
+async function resolveConversationCwd(conversationId) {
+  const conv = await conversationStore.get(conversationId);
+  const ref = conv ? await conversationStore.projectRefOf(conv) : null;
+  if (!ref) return resolveAgentCwd({});
+  return resolveAgentCwd({ projectId: ref.id, orgId: ref.orgId });
+}
+
 // ../server/src/services/turn-events.ts
 import { EventEmitter as EventEmitter3 } from "events";
 var bus = new EventEmitter3();
@@ -1227,8 +1430,8 @@ function onTurnFinished(listener) {
 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");
+import { join as join6 } from "path";
+var PROJECTS_DIR = join6(homedir(), ".claude", "projects");
 var DEFAULT_TITLES = /* @__PURE__ */ new Set(["", "New conversation", "Nouvelle conversation"]);
 async function findClaudeSessionFile(sessionId) {
   let entries;
@@ -1239,7 +1442,7 @@ async function findClaudeSessionFile(sessionId) {
   }
   const filename = `${sessionId}.jsonl`;
   for (const dir of entries) {
-    const candidate = join5(PROJECTS_DIR, dir, filename);
+    const candidate = join6(PROJECTS_DIR, dir, filename);
     try {
       await access(candidate);
       return candidate;
@@ -1429,7 +1632,7 @@ async function startClaudeTranscriptWatcher() {
   }
   for (const dir of topLevel) {
     try {
-      const w = watch(join5(PROJECTS_DIR, dir), (_event, filename) => {
+      const w = watch(join6(PROJECTS_DIR, dir), (_event, filename) => {
         handleFsEvent(filename ? filename.toString() : null);
       });
       w.on("error", () => {
@@ -1454,7 +1657,7 @@ function stopClaudeTranscriptWatcher() {
 
 // ../server/src/services/codex-transcript-sync.ts
 import { watch as watch2 } from "fs";
-import { dirname as dirname2 } from "path";
+import { dirname as dirname4 } from "path";
 var announced = /* @__PURE__ */ new Map();
 function forgetCodexTurns(conversationId) {
   announced.delete(conversationId);
@@ -1508,7 +1711,7 @@ function startCodexTranscriptWatcher() {
   const db = findThreadDb();
   if (!db) return;
   try {
-    watcher = watch2(dirname2(db), (_event, filename) => {
+    watcher = watch2(dirname4(db), (_event, filename) => {
       if (!filename || !/^thread_history_\d+\.sqlite/.test(filename.toString())) return;
       if (debounce) clearTimeout(debounce);
       debounce = setTimeout(() => {
@@ -1873,70 +2076,35 @@ function formatExchange(messages, from) {
 }
 function fullInstructions() {
   return [
-    "Tu relis le travail d'un autre agent, dans la m\xEAme conversation que lui.",
-    "Tu ne modifies rien. Ton seul produit est le message que tu renvoies. La carte",
-    "kanban, si la conversation en a une, dit ce que \xAB termin\xE9 \xBB veut dire ici : tu peux la",
-    "lire, mais tu ne la d\xE9places pas, tu ne la commentes pas, tu ne la modifies pas.",
-    "",
-    "Les images ne te sont PAS jointes : l'\xE9change n'en porte que le chemin, sous la",
-    "forme [Image: source: /chemin/fichier.png]. Pour en lire une, ouvre ce chemin avec ton outil de lecture de fichiers \u2014 tu en as un.",
-    "N'invente JAMAIS le contenu d'une image que tu n'as pas ouverte : dis que la",
-    "lecture a \xE9chou\xE9. On te croirait.",
-    "",
-    "R\xC8GLE 1 \u2014 ON PEUT T'ADRESSER LA PAROLE, ET ALORS TU R\xC9PONDS.",
-    "Si l'\xE9change te parle, te nomme, te demande quelque chose : tu r\xE9ponds, TOUJOURS,",
-    "m\xEAme si c'est trivial ou sans rapport avec la relecture. Ne r\xE9ponds JAMAIS " + VERDICT_NOTHING,
-    "dans ce cas.",
-    "Quand l'agent r\xE9pond \xE0 ta remarque \u2014 il l'a corrig\xE9e, contest\xE9e, ou en prend acte \u2014",
-    "il ne t'adresse PAS la parole : il te r\xE9pond. Tu ne r\xE9ponds que s'il te pose une",
-    "question, ou si sa r\xE9ponse est fausse ou incompl\xE8te. Sinon : " + VERDICT_NOTHING + ".",
+    "Tu relis le travail d'un autre agent, dans la m\xEAme conversation. Tu ne modifies",
+    "rien : ni le code, ni la carte kanban, que tu peux lire mais pas d\xE9placer ni",
+    "commenter. Tu ne d\xE9l\xE8gues pas \xE0 un sous-agent.",
     "",
-    "ET DANS TOUS LES CAS \u2014 RIEN DE NEUF, RIEN DU TOUT. Jamais d'accus\xE9 de r\xE9ception (\xAB bien re\xE7u \xBB),",
-    "de remerciement, de \xAB rien \xE0 signaler \xBB, de \xAB c'est bon \xBB ni de \xAB aucun constat \xBB :",
-    "chacun de ces messages relance l'agent, qui te r\xE9pond, et la boucle tourne. Si ton",
-    "message ne contient ni d\xE9faut, ni question, ni r\xE9ponse \xE0 une question : " + VERDICT_NOTHING + ".",
+    "Images : l'\xE9change ne porte que leur chemin, [Image: source: /chemin.png].",
+    "Ouvre-le avec ton outil de lecture. Si la lecture \xE9choue, dis-le. N'invente",
+    "jamais le contenu d'une image.",
     "",
-    "R\xC8GLE 2 \u2014 sinon, tu relis, et tu ne parles que si tu as trouv\xE9 quelque chose :",
-    "  \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.",
-    "Sois sobre l\xE0, et seulement l\xE0 : une remarque que personne",
-    "n'a demand\xE9e interrompt quelqu'un au travail. Pointe un fichier et une ligne.",
+    "QUAND PARLER",
+    "- Si l'\xE9change te parle ou te pose une question, r\xE9ponds toujours.",
+    "- Sinon, parle seulement si tu as trouv\xE9 un d\xE9faut : r\xE9gression, effet de bord,",
+    "  duplication de code existant, faille de s\xE9curit\xE9, affirmation non v\xE9rifi\xE9e.",
+    "- Pas d'accus\xE9 de r\xE9ception, de remerciement ni de \xAB rien \xE0 signaler \xBB : chacun",
+    "  relance l'agent. Quand il r\xE9pond \xE0 ta remarque, tais-toi, sauf s'il pose une",
+    "  question ou si sa r\xE9ponse est fausse.",
     "",
-    "Ne te fie ni aux commentaires, ni aux messages de commit, ni \xE0 ce que l'agent principal",
-    "affirme : ils disent l'intention, pas le code. Va lire le code r\xE9el. Un d\xE9compte",
-    "ne prouve rien \u2014 \xAB appel\xE9 quatre fois \xBB, un `grep -c` s'\xE9crivent sans rien ouvrir ;",
-    "cite l'extrait de chaque site d'appel, sinon c'est \xAB non v\xE9rifi\xE9 \xBB.",
-    "",
-    "S\xC9CURIT\xC9 \u2014 regarde ce qui a \xE9t\xE9 RETIR\xC9 (validation supprim\xE9e, contr\xF4le d'acc\xE8s",
-    "d\xE9plac\xE9, entr\xE9e qui n'est plus \xE9chapp\xE9e : rien n'en reste dans le code final) et",
-    "ce qui n'a JAMAIS \xE9t\xE9 mis \u2014 un contr\xF4le absent d'une entr\xE9e ne figure dans aucun",
-    "diff, alors \xE9num\xE8re toutes les entr\xE9es qui livrent la ressource. Ne signale une",
-    "vuln\xE9rabilit\xE9 que si tu peux d\xE9crire le chemin complet d'une entr\xE9e r\xE9ellement",
-    "contr\xF4lable jusqu'au point vuln\xE9rable ; sinon tais-toi. Quatre exceptions, parce",
-    "que le d\xE9g\xE2t est d\xE9j\xE0 fait : secret expos\xE9, crypto maison, protection supprim\xE9e,",
-    "d\xE9pendance ajout\xE9e sans v\xE9rification.",
-    "",
-    "Classe : bloquant, risqu\xE9, mineur. Jamais de pr\xE9f\xE9rence de style.",
-    "Dis s\xE9par\xE9ment ce que tu n'as PAS pu v\xE9rifier \u2014 fichier non lu, d\xE9pendance",
-    "externe, comportement \xE0 l'ex\xE9cution \u2014 plut\xF4t que de supposer.",
-    "",
-    "D'un tour \xE0 l'autre tu gardes le fil : on ne te donne que ce que tu n'as pas",
-    "encore relu. Ne resignale pas ce que tu as d\xE9j\xE0 signal\xE9 \u2014 v\xE9rifie si \xE7'a \xE9t\xE9",
-    "trait\xE9, et reviens dessus seulement sinon.",
-    "",
-    "Le tour a-t-il modifi\xE9 du code ? S'il n'a rien chang\xE9 \u2014 question, explication,",
-    "refus \u2014 n'inspecte PAS le d\xE9p\xF4t. Sinon va le lire toi-m\xEAme : `git diff`, `git",
-    "status`, les fichiers touch\xE9s. Ne demande rien, cherche.",
-    "Le p\xE9rim\xE8tre n'est pas les lignes du diff, c'est ce dont ce tour est RESPONSABLE :",
-    "ce qu'il engage \u2014 appelants, autres entr\xE9es d'une m\xEAme ressource \u2014 et ce que le",
-    "code neuf aurait d\xFB pr\xE9voir. Un d\xE9faut dans du code non modifi\xE9 te regarde s'il",
-    "na\xEEt de ce tour ou si ce tour l'a rendu atteignable ; ce qui vivait sans lui, non.",
-    "",
-    "Tu v\xE9rifies dans ton propre tour : ne d\xE9l\xE8gue jamais \xE0 un sous-agent \u2014 ta r\xE9ponse",
-    "est lue au moment o\xF9 tu la renvoies, ce qu'un sous-agent dirait apr\xE8s",
-    "n'atteindrait plus personne. Lis, cherche, conclus \u2014 ou ne dis rien.",
+    "COMMENT RELIRE",
+    "- Lis le code r\xE9el : `git diff`, `git status`, les fichiers touch\xE9s, leurs",
+    "  appelants. Ne te fie ni aux commentaires, ni aux messages de commit, ni \xE0 ce",
+    "  qu'affirme l'agent : ils donnent l'intention, pas le code.",
+    "- Ce tour r\xE9pond de ce qu'il modifie et de ce qu'il rend atteignable, pas de ce",
+    "  qui existait sans lui.",
+    "- S\xE9curit\xE9 : regarde aussi ce qui a \xE9t\xE9 retir\xE9, et les contr\xF4les absents sur",
+    "  chaque entr\xE9e qui m\xE8ne \xE0 la ressource.",
+    "- Cite fichier et ligne. Classe : bloquant, risqu\xE9, mineur. Dis ce que tu n'as",
+    "  pas pu v\xE9rifier.",
+    "- Pas de tests complets, build, typecheck global ni serveur : s'il en faut, dis",
+    "  \xE0 l'agent quoi lancer.",
+    "- Ne resignale pas ce qui a d\xE9j\xE0 \xE9t\xE9 signal\xE9, sauf si ce n'est pas trait\xE9.",
     "",
     "Ces consignes valent pour toute la session : elles ne te seront pas r\xE9p\xE9t\xE9es."
   ].join("\n");
@@ -1970,7 +2138,10 @@ function reminder() {
 function companionDefaultPrompt() {
   return fullInstructions();
 }
-function buildCompanionPrompt(exchange, isFirstTurn = true, custom) {
+function baseLine(baseSha) {
+  return `Point de d\xE9part : le travail de la conversation, commits compris, est dans \`git diff ${baseSha}\`.`;
+}
+function buildCompanionPrompt(exchange, isFirstTurn = true, custom, baseSha) {
   const customInstructions = custom?.trim();
   const instructions = isFirstTurn ? [
     fullInstructions(),
@@ -1986,6 +2157,7 @@ function buildCompanionPrompt(exchange, isFirstTurn = true, custom) {
   ].join("\n") : reminder();
   return [
     instructions,
+    ...baseSha ? ["", baseLine(baseSha)] : [],
     "",
     "--- Ce que tu n'as pas encore relu de la conversation ---",
     exchange || "(vide)"
@@ -2037,12 +2209,13 @@ async function runCompanionForTurn(conversationId) {
   if (!hasNew) {
     return skip(conversationId, "nothingNew", `rien de neuf \xE0 relire (${messageCount} messages)`);
   }
-  const { startCliSession } = await import("./chat-SWYI4ENT.js");
+  const { startCliSession } = await import("./chat-Q2UMYXQL.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 baseSha = await ensureCompanionBase(conv);
+  const prompt = buildCompanionPrompt(exchange, isFirstTurn, customPrompt, baseSha);
   const jwt = await signJwt();
   const environmentId = await activeEnvironmentOf(conv);
   const agentId = companionAgentId(
@@ -2152,7 +2325,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-SWYI4ENT.js");
+    const { startCliSession } = await import("./chat-Q2UMYXQL.js");
     await startCliSession(conv.runner, conv.id, message, { jwt: await signJwt() });
     return "headless";
   } catch (err) {
@@ -2175,7 +2348,7 @@ async function writeToLivePty(conversationId, message) {
 }
 async function companionSettings() {
   try {
-    const { settingsManager } = await import("./settings-manager-J4QBIU3T.js");
+    const { settingsManager } = await import("./settings-manager-BBNCDDQJ.js");
     const settings = await settingsManager.getSettings();
     return settings.companion ?? { enabledByDefault: false };
   } catch {
@@ -2242,7 +2415,12 @@ async function ensureCompanionConversation(conv) {
     void 0,
     conv.projectId,
     void 0,
-    { isCompanion: true }
+    // Le même agent que la conversation relue — c'est lui qui décide du dépôt,
+    // et le compagnon relit ce dépôt-là. Le LANCEMENT visait déjà le bon agent
+    // (`companionAgentId`) ; ce qui manquait, c'est que sa conversation le dise :
+    // sans ce champ, tout ce qui la lit — bouton Git, terminal, activité du PTY —
+    // retombait sur l'agent par défaut du serveur, donc sur un autre dépôt.
+    { isCompanion: true, agentId: conv.agentId }
   );
   await conversationStore.update(conv.id, { companionConversationId: companion.id });
   return companion;
@@ -2252,14 +2430,58 @@ async function runCompanionNow(conversationId) {
   resetRelaunches(conversationId);
   await runCompanionForTurn(conversationId);
 }
+var SHA_RE = /^[0-9a-f]{40}$|^[0-9a-f]{64}$/;
+async function headCommit(queryLog) {
+  try {
+    const log = await queryLog();
+    const first = Array.isArray(log) ? log[0] : void 0;
+    const hash = first && typeof first === "object" && "hash" in first ? first.hash : void 0;
+    return typeof hash === "string" && SHA_RE.test(hash) ? hash : void 0;
+  } catch {
+    return void 0;
+  }
+}
+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;
+  capturingBase.add(conv.id);
+  try {
+    const agentId = conv.agentId ?? agentManager.getDefaultAgentId();
+    if (!agentId) return void 0;
+    const cwd = await resolveConversationCwd(conv.id) ?? ".";
+    const sha = await headCommit(() => agentManager.agentQuery(agentId, "git.log", { cwd, limit: 1 }));
+    if (!sha) return void 0;
+    await conversationStore.update(conv.id, { companionBaseSha: sha }, { silent: true, touch: false });
+    return sha;
+  } finally {
+    capturingBase.delete(conv.id);
+  }
+}
 var unsubscribe = null;
 function initCompanion() {
   if (unsubscribe) return;
-  unsubscribe = onTurnFinished((conversationId) => {
+  const offTurn = onTurnFinished((conversationId) => {
     runCompanionForTurn(conversationId).catch((err) => {
       console.error("[companion]", err.message);
     });
   });
+  const onChange = (event) => {
+    if (event.type !== "created" && event.type !== "updated") return;
+    const conv = event.conversation;
+    if (!conv.companionEnabled || conv.isCompanion || conv.companionBaseSha) return;
+    if (baseTriedOnChange.has(conv.id)) return;
+    baseTriedOnChange.add(conv.id);
+    ensureCompanionBase(conv).catch((err) => {
+      console.error("[companion] point de d\xE9part :", err.message);
+    });
+  };
+  conversationStore.onChanged(onChange);
+  unsubscribe = () => {
+    offTurn();
+    conversationStore.offChanged(onChange);
+  };
 }
 
 export {
@@ -2270,9 +2492,12 @@ export {
   ensureDataGitignore,
   holdsRuneyaProject,
   projectPathStore,
-  LocalProjectExistsError,
+  LocalProjectRefusedError,
   projectStore,
   conversationStore,
+  resolveWorkspaceCwd,
+  resolveAgentCwd,
+  resolveConversationCwd,
   findClaudeSessionFile,
   claudeSessionExists,
   readClaudeTranscript,
@@ -2315,6 +2540,7 @@ export {
   companionSettings,
   answerOfTurn,
   runCompanionNow,
+  headCommit,
   initCompanion
 };
-//# sourceMappingURL=chunk-C6LIGJFX.js.map
+//# sourceMappingURL=chunk-GLIU3J47.js.map