@runeya/runeya 2.0.137 → 2.0.139

package/{src-7O3GCEIB.js → src-KWLVQD36.js}

@@ -51,11 +51,8 @@ import {
   requireEnvAction,
   requireLoopbackOrToken,
   requireServiceAction,
-  resolveAgentCwd,
-  resolveConversationCwd,
   resolveEffectiveAgentId,
   resolveServiceVariables,
-  resolveWorkspaceCwd,
   router,
   scenarioRunStore,
   scenarioStore,
@@ -65,12 +62,12 @@ import {
   soleAccountScope,
   startCliSession,
   vaultOfProject
-} from "./chunk-P65BO7WZ.js";
+} from "./chunk-WNCXZ6E7.js";
 import {
   settingsManager
-} from "./chunk-I7JHF5FE.js";
+} from "./chunk-XHGJHYDC.js";
 import {
-  LocalProjectExistsError,
+  LocalProjectRefusedError,
   activeSessionRegistry,
   companionDefaultPrompt,
   companionSettings,
@@ -81,14 +78,16 @@ import {
   holdsRuneyaProject,
   projectPathStore,
   projectStore,
+  resolveAgentCwd,
+  resolveConversationCwd,
+  resolveWorkspaceCwd,
   signJwt,
   startClaudeTranscriptWatcher,
   startCodexTranscriptWatcher,
   stopClaudeTranscriptWatcher,
   stopCodexTranscriptWatcher,
   verifyJwt
-} from "./chunk-FJLMXLMK.js";
-import "./chunk-MD3VW4HQ.js";
+} from "./chunk-GLIU3J47.js";
 import {
   agentManager,
   agentSpawner,
@@ -127,13 +126,14 @@ import {
   stableEncryptValue,
   traefikManager,
   unregisterInstance
-} from "./chunk-J4GLFY7G.js";
+} from "./chunk-MSICJEZD.js";
 import {
   atomicWriteSecure,
   renameWithRetry,
   resolveConversationRunDir,
   sweepStaleTempFiles
-} from "./chunk-BDQOBEZ3.js";
+} from "./chunk-GOMF7NWS.js";
+import "./chunk-MD3VW4HQ.js";
 import {
   AGENT_LONG_FETCH_TIMEOUT,
   AGENT_STOP_FETCH_TIMEOUT,
@@ -170,9 +170,10 @@ import {
   serviceSlug,
   suggestBuiltinReferences,
   writeEntity
-} from "./chunk-5EMEJNVU.js";
+} from "./chunk-LE6XQ3OV.js";
 import {
   allVaultRoots,
+  backfillOrgCloud,
   env,
   forgetOrgLogo,
   keyRoot,
@@ -180,6 +181,7 @@ import {
   legacyVaultRoot,
   listCloudVaults,
   listOrgVaults,
+  localVaultCollidesWithMachineRoot,
   machineFilePath,
   machineRoot,
   orgVaultRoot,
@@ -192,14 +194,15 @@ import {
   rememberOrgAccount,
   rememberOrgLogo,
   rememberOrgName,
-  stampOrgCloud
-} from "./chunk-ZFELQG4B.js";
+  stampOrgCloud,
+  vaultFor
+} from "./chunk-EV3TBM7E.js";
 import {
   decryptValueWith,
   encryptValueWith,
   resolveCliInvocation,
   whichCommand
-} from "./chunk-NURPXHLB.js";
+} from "./chunk-OZBSOSAS.js";
 
 // ../server/src/create-server.ts
 import express from "express";
@@ -520,6 +523,7 @@ var changelogRouter = router({
 
 // ../server/src/trpc/routers/project.ts
 import { z as z4 } from "zod";
+import { dirname as dirname2, isAbsolute } from "path";
 import { TRPCError as TRPCError2 } from "@trpc/server";
 
 // ../server/src/services/current-project.ts
@@ -887,19 +891,22 @@ var projectRouter = router({
       name: z4.string().min(1).max(200),
       description: z4.string().max(1e4).optional(),
       orgId: z4.string().max(128).nullable().optional(),
-      serviceIds: z4.array(z4.string().max(128)).max(1e4).optional()
+      serviceIds: z4.array(z4.string().max(128)).max(1e4).optional(),
+      /** Le dossier d'un projet local. Omis : le dossier de lancement. */
+      localPath: z4.string().min(1).max(4096).refine(isAbsolute, "Chemin absolu attendu").optional()
     })
   ).mutation(async ({ input }) => {
+    const { localPath, ...fields } = input;
     let project;
     try {
       project = await projectStore.create({
-        ...input,
-        description: input.description ?? "",
-        serviceIds: input.serviceIds ?? [],
+        ...fields,
+        description: fields.description ?? "",
+        serviceIds: fields.serviceIds ?? [],
         environmentIds: []
-      });
+      }, fields.orgId ? void 0 : localPath);
     } catch (err) {
-      if (err instanceof LocalProjectExistsError) {
+      if (err instanceof LocalProjectRefusedError) {
         throw new TRPCError2({ code: "CONFLICT", message: err.code, cause: err });
       }
       throw new TRPCError2({ code: "CONFLICT", message: err.message });
@@ -1125,8 +1132,16 @@ var projectRouter = router({
       dangling: graph.dangling.filter((d) => allowed.has(d.from))
     };
   }),
+  /**
+   * Le dossier de chaque projet sur cette machine, par clé `org:projet`
+   * (`local:<id>` pour un projet local, dont le dossier contient son `.runeya`).
+   */
   localPaths: protectedProcedure.query(async () => {
-    return projectPathStore.all();
+    const paths = await projectPathStore.all();
+    for (const project of await projectStore.list()) {
+      if (!project.orgId) paths[`local:${project.id}`] = dirname2(vaultFor(project).root);
+    }
+    return paths;
   }),
   getLocalPath: protectedProcedure.input(z4.object({
     id: z4.string().min(1).max(128),
@@ -1141,6 +1156,19 @@ var projectRouter = router({
    * project was already placed in: two projects sharing a directory is what
    * makes services run against the wrong code.
    */
+  /** Ajouter à la liste le projet local déjà présent dans un dossier. */
+  importLocal: protectedProcedure.input(z4.object({ path: z4.string().min(1).max(4096).refine(isAbsolute, "Chemin absolu attendu") })).mutation(async ({ input }) => {
+    try {
+      const project = await projectStore.importLocal(input.path);
+      await auditService.log({ userId: "local", action: "update", entityType: "project", entityId: project.id, metadata: { importedFrom: input.path } });
+      return project;
+    } catch (err) {
+      if (err instanceof LocalProjectRefusedError) {
+        throw new TRPCError2({ code: "CONFLICT", message: err.code, cause: err });
+      }
+      throw err;
+    }
+  }),
   setLocalPath: protectedProcedure.input(z4.object({
     id: z4.string().min(1).max(128),
     orgId: z4.string().max(128).nullable().optional(),
@@ -1884,10 +1912,12 @@ var setupRouter = router({
     keyHex: z8.string().length(64).regex(/^[0-9a-f]+$/i, "Invalid hex format")
   })).query(async ({ input }) => {
     const canary = await readVerifyFile(orgVaultRoot(input.orgId));
-    if (!canary) return { isCurrentKey: false, hasCanary: false };
+    const locked = isVaultLocked(input.orgId);
+    if (!canary) return { isCurrentKey: false, hasCanary: false, locked };
     return {
       isCurrentKey: matchesCanary(canary, Buffer.from(input.keyHex, "hex")),
-      hasCanary: true
+      hasCanary: true,
+      locked
     };
   }),
   /**
@@ -2451,7 +2481,12 @@ var settingsRouter = router({
     dataDir: env.DATA_DIR,
     // Where cloud projects live: their vaults belong to the machine, not to
     // whichever directory the server happened to be started in.
-    machineDir: machineRoot()
+    machineDir: machineRoot(),
+    // Un projet local peut-il naître ici ? Là où le coffre local se confond
+    // avec la racine machine, non : ses fichiers se mêleraient à ceux de la
+    // machine. Répondu ici pour que l'interface n'offre pas un emplacement que
+    // la création refuserait — la règle reste écrite une seule fois.
+    canCreateLocalProject: !localVaultCollidesWithMachineRoot()
   })),
   /**
    * Où le serveur écoute, et s'il est joignable depuis le réseau local.
@@ -3308,7 +3343,7 @@ var editorRouter = router({
 import { z as z13 } from "zod";
 import { TRPCError as TRPCError9 } from "@trpc/server";
 import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
-import { join as join5, dirname as dirname2 } from "path";
+import { join as join5, dirname as dirname3 } from "path";
 var ALLOWED_SKILL_PATHS = /* @__PURE__ */ new Set([
   ".claude/skills/runeya/SKILL.md",
   ".cursor/rules/runeya.mdc",
@@ -3356,7 +3391,7 @@ var apiKeysRouter = router({
       throw new TRPCError9({ code: "BAD_REQUEST", message: "Chemin non autoris\xE9" });
     }
     const abs = join5(await resolveWorkspaceCwd({}), input.relativePath);
-    await mkdir3(dirname2(abs), { recursive: true });
+    await mkdir3(dirname3(abs), { recursive: true });
     await writeFile3(abs, input.content, { encoding: "utf-8", mode: 420 });
     return { path: input.relativePath };
   })
@@ -6016,6 +6051,11 @@ function safeLocalName(id, name) {
   const ext = /\.([A-Za-z0-9]{1,12})$/.exec(name)?.[1];
   return ext ? `${base}.${ext.toLowerCase()}` : base;
 }
+async function attachmentScope(input) {
+  if (input.orgId) return accountForOrgScope(input.orgId);
+  if (input.boardId) return kanbanStore.accountForBoard(input.boardId);
+  return soleAccountScope();
+}
 var kanbanRouter = router({
   /**
    * The organization's boards, without their cards — a board carries its whole
@@ -6190,6 +6230,28 @@ var kanbanRouter = router({
     }
     return { ok: true };
   }),
+  /**
+   * Les références : la même carte posée sur un autre tableau, sans copie.
+   * `boardId` est le tableau où on la pose (ou d'où on la retire) ; la carte
+   * reste sur son tableau d'origine.
+   */
+  getCardPlacements: protectedProcedure.input(z19.object({ boardId: z19.string().max(128), cardId: z19.string().max(128) })).query(async ({ input }) => ({ placements: await kanbanStore.cardPlacements(input.boardId, input.cardId) })),
+  placeCard: protectedProcedure.input(z19.object({ boardId: z19.string().max(128), cardId: z19.string().max(128), column: z19.string().min(1).max(200) })).mutation(async ({ input }) => {
+    const res = await kanbanStore.placeCard(input.boardId, input.cardId, input.column);
+    if (!res.ok) {
+      throw new TRPCError16({
+        code: "BAD_REQUEST",
+        message: res.reason ?? "The cloud refused the placement (unknown card or column, archived card, or already on this board)."
+      });
+    }
+    return { ok: true };
+  }),
+  unplaceCard: protectedProcedure.input(z19.object({ boardId: z19.string().max(128), cardId: z19.string().max(128) })).mutation(async ({ input }) => {
+    if (!await kanbanStore.unplaceCard(input.boardId, input.cardId)) {
+      throw new TRPCError16({ code: "NOT_FOUND", message: "This card is not placed on this board." });
+    }
+    return { ok: true };
+  }),
   moveCard: protectedProcedure.input(z19.object({
     boardId: z19.string().max(128),
     cardId: z19.string().max(128),
@@ -6285,10 +6347,14 @@ var kanbanRouter = router({
   downloadAttachment: protectedProcedure.input(z19.object({
     attachmentId: z19.string().max(128),
     // La pièce jointe appartient à une organisation : la nommer dit sous quel
-    // compte la demander. C'est le SEUL appel qui tolère de ne pas l'avoir —
-    // un agent n'a qu'un identifiant de fichier — et il échoue alors en le
-    // disant dès que ce poste a plusieurs comptes.
-    orgId: z19.string().max(128).optional()
+    // compte la demander.
+    orgId: z19.string().max(128).optional(),
+    // À défaut, le tableau d'où vient la carte suffit : il désigne un compte
+    // comme le fait n'importe quel autre appel du kanban. Sans lui, la route
+    // retombait sur le compte unique du poste et refusait de servir dès qu'il
+    // y en avait plusieurs — alors que l'agent, qui n'a qu'un identifiant de
+    // fichier, n'avait aucun moyen de nommer l'organisation.
+    boardId: z19.string().max(128).optional()
   })).mutation(async ({ input }) => {
     const id = input.attachmentId;
     if (!ATTACHMENT_ID_REGEX.test(id)) {
@@ -6296,7 +6362,7 @@ var kanbanRouter = router({
     }
     const res = await cloudFetch2(`/api/kanban/file/${id}`, {
       timeoutMs: 12e4,
-      accountId: input.orgId ? await accountForOrgScope(input.orgId) : await soleAccountScope()
+      accountId: await attachmentScope(input)
     });
     if (res.status === 404) {
       throw new TRPCError16({ code: "NOT_FOUND", message: `Attachment ${id} not found` });
@@ -6487,7 +6553,7 @@ var utilityRouter = router({
 import { z as z22 } from "zod";
 import { TRPCError as TRPCError18 } from "@trpc/server";
 import { readFile as readFile3, readdir as readdir2, stat as stat4, realpath, writeFile as writeFile5, mkdir as mkdir6, rename, rm as rm2 } from "fs/promises";
-import { resolve as resolvePath, join as join8, relative, sep, dirname as dirname3 } from "path";
+import { resolve as resolvePath, join as join8, relative, sep, dirname as dirname4 } from "path";
 var SCOPE_SCHEMA = z22.union([
   z22.literal("global"),
   z22.string().regex(/^service:[A-Za-z0-9_-]{1,128}$/, "Invalid service scope")
@@ -6525,7 +6591,7 @@ async function resolveScope(scope) {
     }
     const dataDirAbs = resolvePath(env.DATA_DIR);
     await mkdir6(dataDirAbs, { recursive: true });
-    const base = dirname3(await realpath(dataDirAbs));
+    const base = dirname4(await realpath(dataDirAbs));
     const target = resolvePath(base, sub);
     if (target !== base && !(target + sep).startsWith(base + sep)) {
       throw new TRPCError18({ code: "FORBIDDEN", message: "Hors du dossier de donn\xE9es du serveur" });
@@ -6591,7 +6657,7 @@ async function resolveSafeLocal(root, relPath, requireExist) {
     }
     return real;
   }
-  const parent = dirname3(target);
+  const parent = dirname4(target);
   let realParent;
   try {
     realParent = await realpath(parent);
@@ -6637,7 +6703,7 @@ var wikiRouter = router({
       return agentManager.agentMutation(target.agentId, "wiki.writeMarkdown", { cwd: target.cwd, path: input.path, content: input.content });
     }
     const file = await resolveSafeLocal(target.root, input.path, false);
-    await mkdir6(dirname3(file), { recursive: true });
+    await mkdir6(dirname4(file), { recursive: true });
     await writeFile5(file, input.content, "utf-8");
     return { path: input.path, ok: true };
   }),
@@ -6656,7 +6722,7 @@ var wikiRouter = router({
     } catch (err) {
       if (err instanceof TRPCError18) throw err;
     }
-    await mkdir6(dirname3(file), { recursive: true });
+    await mkdir6(dirname4(file), { recursive: true });
     await writeFile5(file, "", "utf-8");
     return { path: input.path, ok: true };
   }),
@@ -6682,7 +6748,7 @@ var wikiRouter = router({
     } catch (err) {
       if (err instanceof TRPCError18) throw err;
     }
-    await mkdir6(dirname3(to), { recursive: true });
+    await mkdir6(dirname4(to), { recursive: true });
     await rename(from, to);
     return { fromPath: input.fromPath, toPath: input.toPath, ok: true };
   }),
@@ -6749,10 +6815,10 @@ async function orgsToSync() {
   for (const vault of await listCloudVaults()) {
     if (targets.has(vault.orgId)) continue;
     const stamped = stamps[vault.orgId]?.replace(/\/+$/, "");
-    if (stamped ? !known.has(stamped) : fallback === null) continue;
-    const cloudUrl = stamped ?? fallback;
-    if (!cloudUrl) continue;
     const accountId = stampedAccounts[vault.orgId] ?? (accounts.length === 1 ? accounts[0].id : void 0);
+    const accountCloud = accountId ? accounts.find((a) => a.id === accountId)?.cloudUrl.replace(/\/+$/, "") : void 0;
+    const cloudUrl = stamped ?? accountCloud ?? fallback;
+    if (!cloudUrl || !known.has(cloudUrl)) continue;
     if (await isMaterialized(vault.root)) {
       targets.set(vault.orgId, { orgId: vault.orgId, cloudUrl, ...accountId ? { accountId } : {} });
     }
@@ -6814,7 +6880,7 @@ import * as Y2 from "yjs";
 // ../server/src/services/sync-doc-cache.ts
 import { readFileSync, renameSync, rmSync, writeFileSync, mkdirSync } from "fs";
 import { readFile as readFile4 } from "fs/promises";
-import { dirname as dirname4, join as join10 } from "path";
+import { dirname as dirname5, join as join10 } from "path";
 import { randomUUID as randomUUID6 } from "crypto";
 import * as Y from "yjs";
 var FILE = "sync-doc.bin";
@@ -6846,7 +6912,7 @@ function writeSyncDocSync(orgId, state) {
     existing = new Uint8Array(readFileSync(path));
   } catch {
   }
-  mkdirSync(dirname4(path), { recursive: true });
+  mkdirSync(dirname5(path), { recursive: true });
   const tmp = `${path}.${process.pid}.${randomUUID6()}.tmp`;
   try {
     writeFileSync(tmp, mergeWith(existing, state), { mode: 384 });
@@ -7897,10 +7963,27 @@ async function jsonFilesIn(root) {
 async function exists(path) {
   return stat5(path).then(() => true, () => false);
 }
+async function adoptIntoLockedVault(orgId, newKey, masterPassword) {
+  const canary = await readVerifyFile(orgVaultRoot(orgId));
+  if (canary && !matchesCanary(canary, newKey)) {
+    throw new Error("ORG_KEY_DOES_NOT_OPEN_VAULT");
+  }
+  await readEncryptedKey(await keyRoot(), masterPassword);
+  await installOrgKey(orgId, newKey, masterPassword);
+  clearVaultLock(orgId);
+  environmentStore.resetCache();
+  serviceStore.resetCache();
+  conversationStore.resetCache();
+  apiKeyStore.resetCache();
+  return { converted: [], backups: [] };
+}
 async function adoptOrgKey(orgId, newKey, masterPassword, now) {
   const currentKey = getEncryptionKey(orgId);
   if (!currentKey) {
-    throw new Error("La cl\xE9 actuelle de cette organisation n'est pas charg\xE9e.");
+    if (!isVaultLocked(orgId)) {
+      throw new Error("La cl\xE9 actuelle de cette organisation n'est pas charg\xE9e.");
+    }
+    return adoptIntoLockedVault(orgId, newKey, masterPassword);
   }
   if (newKey.equals(currentKey)) {
     throw new Error("ORG_KEY_ALREADY_CURRENT");
@@ -7953,6 +8036,17 @@ async function adoptOrgKey(orgId, newKey, masterPassword, now) {
   apiKeyStore.resetCache();
   return { converted: pending.map(({ path, values }) => ({ file: path, values })), backups };
 }
+async function resetOrgKeyToFresh(orgId, masterPassword, now) {
+  const freshKey = randomBytes2(32);
+  if (isVaultLocked(orgId) || !getEncryptionKey(orgId)) {
+    await readEncryptedKey(await keyRoot(), masterPassword);
+    await installOrgKey(orgId, freshKey, masterPassword);
+    clearVaultLock(orgId);
+    return { converted: [], backups: [], keyHex: freshKey.toString("hex") };
+  }
+  const report = await adoptOrgKey(orgId, freshKey, masterPassword, now);
+  return { ...report, keyHex: freshKey.toString("hex") };
+}
 
 // ../server/src/trpc/routers/cloud-sync.ts
 async function cloudMessage(res) {
@@ -8150,9 +8244,10 @@ var cloudSyncRouter = router({
   /**
    * Faire adopter à cette machine la clé d'une organisation.
    *
-   * Le pendant de `resetOrgKey` : là où celle-ci fait plier l'organisation à la
-   * clé d'ici, celle-là fait plier cette machine à la sienne — et c'est la
-   * seule des deux qui rend lisible ce qui avait déjà été chiffré sous elle.
+   * Le pendant de `resetOrgKey` : là où celle-ci repart sous une clé neuve, en
+   * abandonnant ce qui avait été chiffré sous l'ancienne, celle-là fait plier
+   * cette machine à la clé existante — et c'est la seule des deux qui rend
+   * lisible ce qui avait déjà été chiffré sous elle.
    *
    * Bornée au coffre de l'organisation et à ceux de ses projets : les autres
    * organisations et la machine gardent leur clé.
@@ -8181,15 +8276,25 @@ var cloudSyncRouter = router({
    * d'un ancien coffre — laisse l'organisation insynchronisable pour toujours.
    * Cette route est la sortie de secours, réservée au propriétaire côté cloud.
    *
-   * Elle ne re-chiffre rien : ce qui a déjà été synchronisé sous l'ancienne clé
-   * reste illisible. L'interface le dit avant de la déclencher.
+   * L'organisation repart sous une clé TIRÉE POUR ELLE, et non sous celle de
+   * cette machine : cette dernière vaut pour toutes les organisations d'ici qui
+   * n'ont pas adopté la leur, et il faut ensuite transmettre la clé publiée aux
+   * autres membres. Le coffre local est re-chiffré au passage, ce qui exige le
+   * master password — comme l'adoption, dont c'est le même geste à l'envers.
+   *
+   * Ce qui a déjà été synchronisé sous l'ancienne clé de référence reste
+   * illisible : aucune clé d'ici ne l'ouvre. L'interface le dit avant.
    */
-  resetOrgKey: protectedProcedure.input(z23.object({ orgId: z23.string().min(1).max(128) })).mutation(async ({ input }) => {
-    const canary = await readVerifyFile(orgVaultRoot(input.orgId)) ?? await readVerifyFile(await keyRoot());
+  resetOrgKey: protectedProcedure.input(z23.object({
+    orgId: z23.string().min(1).max(128),
+    masterPassword: z23.string().min(1).max(1024)
+  })).mutation(async ({ input }) => {
+    const { keyHex } = await resetOrgKeyToFresh(input.orgId, input.masterPassword, /* @__PURE__ */ new Date());
+    const canary = await readVerifyFile(orgVaultRoot(input.orgId));
     if (!canary) {
       throw new TRPCError19({
         code: "PRECONDITION_FAILED",
-        message: "Cette machine n'a pas encore de cl\xE9 de chiffrement."
+        message: "Le coffre de cette organisation n'a pas re\xE7u sa cl\xE9."
       });
     }
     const res = await cloudFetch2("/api/auth/organization/canary/reset", {
@@ -8206,7 +8311,7 @@ var cloudSyncRouter = router({
     }
     const cloudUrl = (await orgsToSync()).find((l) => l.orgId === input.orgId)?.cloudUrl ?? getCloudApiUrl();
     await cloudSyncBridge.connect({ orgId: input.orgId, cloudUrl, ...await accountScope(input.orgId) });
-    return { state: syncState(input.orgId) };
+    return { state: syncState(input.orgId), keyHex };
   }),
   /**
    * Stop materializing one project of an org on this machine.
@@ -8302,12 +8407,22 @@ var cloudSyncRouter = router({
       candidates.set(orgId, [...candidates.get(orgId) ?? [], accountId]);
     }
     const current2 = await readOrgAccounts();
+    const stamped = await readOrgClouds();
+    const cloudOf = new Map(
+      (await cloudSessionStore.list()).map((a) => [a.id, a.cloudUrl.replace(/\/+$/, "")])
+    );
     let remembered = 0;
     for (const [orgId, accountIds] of candidates) {
       const kept = current2[orgId];
-      if (kept && accountIds.includes(kept)) continue;
-      await rememberOrgAccount(orgId, accountIds[0]);
-      remembered++;
+      const owner = kept && accountIds.includes(kept) ? kept : accountIds[0];
+      if (owner !== kept) {
+        await rememberOrgAccount(orgId, owner);
+        remembered++;
+      }
+      if (!stamped[orgId]) {
+        const cloudUrl = cloudOf.get(owner);
+        if (cloudUrl) await backfillOrgCloud(orgId, cloudUrl);
+      }
     }
     return { remembered };
   }),
@@ -8402,14 +8517,14 @@ var cloudSyncRouter = router({
 // ../server/src/trpc/routers/filesystem.ts
 import { readdir as readdir4, stat as stat6 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { isAbsolute, join as join12, resolve as resolve2, dirname as dirname5, basename } from "path";
+import { isAbsolute as isAbsolute2, join as join12, resolve as resolve2, dirname as dirname6, basename } from "path";
 import { z as z24 } from "zod";
 var MAX_ENTRIES2 = 500;
 var PATH_SCHEMA = z24.string().min(1).max(4096);
 function safeResolve(input) {
   if (input.includes("\0")) throw new Error("Chemin invalide");
   const expanded = input.startsWith("~") ? join12(homedir3(), input.slice(1)) : input;
-  if (!isAbsolute(expanded)) throw new Error("Le chemin doit \xEAtre absolu");
+  if (!isAbsolute2(expanded)) throw new Error("Le chemin doit \xEAtre absolu");
   return resolve2(expanded);
 }
 var filesystemRouter = router({
@@ -8450,13 +8565,24 @@ var filesystemRouter = router({
     return {
       path: dir,
       // Null at the filesystem root, which is what stops "up" from looping.
-      parent: dirname5(dir) === dir ? null : dirname5(dir),
+      parent: dirname6(dir) === dir ? null : dirname6(dir),
       name: basename(dir) || dir,
       entries: entries2,
       truncated,
       hasRuneyaProject: await holdsRuneyaProject(dir)
     };
   }),
+  /**
+   * Ce qu'un dossier permet pour un projet local : le créer, importer celui
+   * qui s'y trouve, ou rien (déjà dans la liste, lié à un projet d'organisation,
+   * racine machine).
+   */
+  checkLocalProjectTarget: protectedProcedure.input(z24.object({ path: PATH_SCHEMA })).query(async ({ input }) => {
+    const dir = safeResolve(input.path);
+    const info = await stat6(dir).catch(() => null);
+    if (!info?.isDirectory()) return { path: dir, status: "missing", projectName: null };
+    return { path: dir, ...await projectStore.inspectLocalDir(dir) };
+  }),
   /**
    * Whether a directory can receive this project.
    *
@@ -8486,12 +8612,12 @@ var filesystemRouter = router({
 
 // ../server/src/trpc/routers/desktop.ts
 import { z as z25 } from "zod";
-import { isAbsolute as isAbsolute3 } from "path";
+import { isAbsolute as isAbsolute4 } from "path";
 import { TRPCError as TRPCError20 } from "@trpc/server";
 
 // ../server/src/services/desktop-launcher.ts
 import { execFile as execFile4 } from "child_process";
-import { isAbsolute as isAbsolute2 } from "path";
+import { isAbsolute as isAbsolute3 } from "path";
 import { promisify as promisify3 } from "util";
 var exec = promisify3(execFile4);
 var INSTALL_TIMEOUT_MS2 = 3e4;
@@ -8512,7 +8638,7 @@ function suggestLauncher() {
 }
 async function installLauncher(input) {
   if (!cli) throw new Error("launcher-unavailable");
-  if (input.workingDir !== null && !isAbsolute2(input.workingDir)) {
+  if (input.workingDir !== null && !isAbsolute3(input.workingDir)) {
     throw new Error("launcher-working-dir-not-absolute");
   }
   const args = [
@@ -8584,7 +8710,7 @@ var desktopRouter = router({
      * absolu, refusé autrement : le dossier devient un argument positionnel
      * du CLI, où une valeur commençant par un tiret passerait pour un drapeau.
      */
-    workingDir: z25.string().max(4096).refine(isAbsolute3, {
+    workingDir: z25.string().max(4096).refine(isAbsolute4, {
       message: "Le dossier de travail doit \xEAtre un chemin absolu."
     }).nullable(),
     port: z25.number().int().min(1).max(65535),
@@ -8857,7 +8983,7 @@ import {
   access as access2,
   readdir as readdir6
 } from "fs/promises";
-import { join as join15, dirname as dirname6 } from "path";
+import { join as join15, dirname as dirname7 } from "path";
 var _require = createRequire(import.meta.url);
 var PARSER_ID_MAP = {
   "stack-monitor-parser-jsons": "native:json",
@@ -9466,7 +9592,7 @@ async function runOverrideOnlyMigration(dataDir) {
   const { resolve: resolve4 } = await import("path");
   const abDataDir = resolve4(dataDir);
   const candidateDirs = [
-    join15(dirname6(env.DATA_DIR), ".runeya", "dbs", "overrides"),
+    join15(dirname7(env.DATA_DIR), ".runeya", "dbs", "overrides"),
     join15(abDataDir, "dbs", "overrides")
   ];
   let overridesDir = null;
@@ -10157,31 +10283,6 @@ async function createLocalServer() {
       );
     }
     await runOverrideOnlyMigration(env.DATA_DIR);
-    if (env.MODE === "local-simple") {
-      const projects = await projectStore.list();
-      if (projects.length === 0) {
-        const project = await projectStore.create({
-          name: "My Local Project",
-          description: "Auto-generated default project for local development"
-        });
-        const localEnv = await environmentStore.create({
-          projectId: project.id,
-          name: "Local",
-          description: "Default local environment (immutable)",
-          variables: {},
-          parentIds: [],
-          color: "#22c55e",
-          immutable: true
-        }, project.orgId);
-        await projectStore.update({
-          id: project.id,
-          orgId: project.orgId,
-          environmentIds: [localEnv.id],
-          activeEnvironmentId: localEnv.id
-        });
-        console.log("[server] Created default project with Local environment");
-      }
-    }
     await agentManager.init();
     agentSpawner.spawnLocalAgent().catch((err) => {
       console.warn("[server] Failed to spawn the local agent:", err);
@@ -10830,7 +10931,7 @@ async function createLocalServer() {
     ]);
     console.log("[server] Shutdown complete");
   };
-  const { initCompanion } = await import("./companion-Q67RAO3N.js");
+  const { initCompanion } = await import("./companion-MGX62L4T.js");
   initCompanion();
   return { app, server, wss, shutdown };
 }
@@ -11220,7 +11321,7 @@ function listenWithRetry(server, port, host, wss, maxRetries = 20, delay = 500)
   });
 }
 async function main() {
-  const { ensureNodeBinOnPath, ensureUserBinsOnPath } = await import("./node-4UUJN2WG.js");
+  const { ensureNodeBinOnPath, ensureUserBinsOnPath } = await import("./node-RN4URNZ5.js");
   ensureNodeBinOnPath();
   await ensureUserBinsOnPath();
   console.log("Hello World 2");
@@ -11277,4 +11378,4 @@ export {
   startProcess,
   stopProcess
 };
-//# sourceMappingURL=src-7O3GCEIB.js.map
+//# sourceMappingURL=src-KWLVQD36.js.map