@wibeco/bridge 0.2.16 → 0.2.17

package/README.md

@@ -7,7 +7,8 @@ Dependency-light TypeScript foundations for normalizing agent hooks and sending
 - Adapters copy only explicit allow-listed metadata. Prompt text, tool input/output, file content,
   shell command text, messages, and transcripts are never captured by default.
 - Redaction is defense in depth, not permission to send arbitrary payloads.
-- Offline files are created with owner-only permissions. Set `WIBE_QUEUE_PATH` to relocate the queue.
+- Offline files are created with owner-only permissions and separated by Wibe project. Set
+  `WIBE_QUEUE_PATH` to relocate the queue directory.
 - Device authorization opens Wibe in the browser and stores the resulting
   revocable project-scoped bearer token in the operating-system keychain.
 - Event batches are schema-validated, bounded, idempotent, and sent only to the
@@ -41,14 +42,18 @@ saved token was rejected or revoked.
 
 `setup` keeps reviewable templates under `.wibe/integrations/<adapter>` and
 installs native project configuration only when the destination file does not
-already exist. Existing Cursor, Claude Code, or Codex configuration is never
-overwritten; merge the staged template when the project already has one.
+already exist. Existing hooks and unrelated agent configuration are never
+overwritten. Wibe-managed activity instructions and an existing Wibe MCP URL
+are refreshed to the repository's current project.
 
 `WIBE_APP_URL` overrides the default local Wibe URL during setup.
-`WIBE_QUEUE_PATH` optionally relocates the owner-only offline queue. CI and
+`WIBE_QUEUE_PATH` optionally relocates the owner-only per-project queue directory. If a legacy
+file path is supplied, project queues are stored beside it under a `.d` suffix. CI and
 headless environments can inject `WIBE_ACCESS_TOKEN`, `WIBE_PROJECT_ID`,
 `WIBE_ORGANIZATION_ID`, `WIBE_REPOSITORY_ID`, and `WIBE_DEVICE_ID`; interactive
-developer machines should use the keychain-backed browser flow.
+developer machines should use the keychain-backed browser flow. Environment
+credentials are accepted only when they match that repository's `.wibe/project.json`.
 
-Without a device credential, `emit` keeps normalized events in the offline
-queue and never sends them elsewhere.
+Without a device credential, `emit` keeps normalized events in a repository-scoped pending queue.
+Setup adopts only that repository's pending events. Legacy identity-less queues are quarantined
+and reported by `wibe doctor`; they are never delivered into an arbitrary project.

package/dist/{chunk-K7TK7FHF.js → chunk-4WIGVKDR.js}

@@ -514,74 +514,107 @@ var SignedBatchClient = class {
     return this.flush();
   }
   async flush() {
-    const queuedEvents = await this.options.queue.peek(this.batchSize);
-    if (queuedEvents.length === 0) return { sent: 0, remaining: 0 };
-    const events4 = queuedEvents.filter((event) => eventTypeForHook(event));
-    const ignoredIds = queuedEvents.filter((event) => !eventTypeForHook(event)).map((event) => event.id);
-    if (ignoredIds.length > 0) await this.options.queue.remove(ignoredIds);
-    if (events4.length === 0) {
-      return { sent: 0, remaining: await this.options.queue.size() };
-    }
-    const body = JSON.stringify({
-      batch_id: randomUUID2(),
-      events: events4.map((event) => toEnvelope(event, this.options))
-    });
-    try {
-      const response = await this.request(this.options.endpoint, {
-        method: "POST",
-        body,
-        signal: AbortSignal.timeout(this.timeoutMs),
-        headers: {
-          "content-type": "application/json",
-          "user-agent": "wibe-bridge/1",
-          authorization: `Bearer ${this.options.accessToken}`
-        }
+    return this.options.queue.withTransaction(async (queue) => {
+      const queuedEvents = await queue.peek(this.batchSize);
+      if (queuedEvents.length === 0) return { sent: 0, remaining: 0 };
+      const events4 = queuedEvents.filter((event) => eventTypeForHook(event));
+      const ignoredIds = queuedEvents.filter((event) => !eventTypeForHook(event)).map((event) => event.id);
+      if (ignoredIds.length > 0) await queue.remove(ignoredIds);
+      if (events4.length === 0) {
+        return { sent: 0, remaining: await queue.size() };
+      }
+      const body = JSON.stringify({
+        batch_id: randomUUID2(),
+        events: events4.map((event) => toEnvelope(event, this.options))
       });
-      if (!response.ok) {
-        const requestId = response.headers.get("x-request-id");
-        let detail = "";
-        try {
-          const body2 = await response.json();
-          const code = typeof body2.code === "string" ? body2.code.slice(0, 80) : void 0;
-          const message = typeof body2.error === "string" ? body2.error.slice(0, 160) : void 0;
-          detail = [code, message].filter(Boolean).join(": ");
-        } catch {
+      try {
+        const response = await this.request(this.options.endpoint, {
+          method: "POST",
+          body,
+          signal: AbortSignal.timeout(this.timeoutMs),
+          headers: {
+            "content-type": "application/json",
+            "user-agent": "wibe-bridge/1",
+            authorization: `Bearer ${this.options.accessToken}`
+          }
+        });
+        if (!response.ok) {
+          const requestId = response.headers.get("x-request-id");
+          let detail = "";
+          try {
+            const responseBody = await response.json();
+            const code = typeof responseBody.code === "string" ? responseBody.code.slice(0, 80) : void 0;
+            const message = typeof responseBody.error === "string" ? responseBody.error.slice(0, 160) : void 0;
+            detail = [code, message].filter(Boolean).join(": ");
+          } catch {
+          }
+          const suffix = [
+            detail ? `: ${detail}` : "",
+            requestId ? ` (request ${requestId.slice(0, 80)})` : ""
+          ].join("");
+          throw new Error(`Collector returned HTTP ${response.status}${suffix}`);
         }
-        const suffix = [
-          detail ? `: ${detail}` : "",
-          requestId ? ` (request ${requestId.slice(0, 80)})` : ""
-        ].join("");
-        throw new Error(`Collector returned HTTP ${response.status}${suffix}`);
+        await queue.remove(events4.map((event) => event.id));
+        return { sent: events4.length, remaining: await queue.size() };
+      } catch (error) {
+        return {
+          sent: 0,
+          remaining: await queue.size(),
+          error: error instanceof Error ? error.message : String(error)
+        };
       }
-      await this.options.queue.remove(events4.map((event) => event.id));
-      return { sent: events4.length, remaining: await this.options.queue.size() };
-    } catch (error) {
-      return {
-        sent: 0,
-        remaining: await this.options.queue.size(),
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
+    });
   }
 };
 
 // src/queue.ts
-import { mkdir, readFile, rename, writeFile } from "fs/promises";
+import { randomUUID as randomUUID3 } from "crypto";
+import {
+  mkdir,
+  open,
+  readFile,
+  rename,
+  stat,
+  unlink,
+  writeFile
+} from "fs/promises";
 import { dirname } from "path";
 var MemoryOfflineQueue = class {
   events = [];
+  operation = Promise.resolve();
   async enqueue(events4) {
-    this.events.push(...events4);
+    await this.withTransaction(async () => {
+      this.events.push(...events4);
+    });
   }
   async peek(limit) {
-    return this.events.slice(0, Math.max(0, limit));
+    return this.withTransaction((queue) => queue.peek(limit));
   }
   async remove(ids) {
-    const removed = new Set(ids);
-    this.events = this.events.filter((event) => !removed.has(event.id));
+    await this.withTransaction((queue) => queue.remove(ids));
   }
   async size() {
-    return this.events.length;
+    return this.withTransaction((queue) => queue.size());
+  }
+  async withTransaction(operation) {
+    return this.serialize(
+      () => operation({
+        peek: async (limit) => this.events.slice(0, Math.max(0, limit)),
+        remove: async (ids) => {
+          const removed = new Set(ids);
+          this.events = this.events.filter((event) => !removed.has(event.id));
+        },
+        size: async () => this.events.length
+      })
+    );
+  }
+  async serialize(operation) {
+    const next = this.operation.then(operation);
+    this.operation = next.then(
+      () => void 0,
+      () => void 0
+    );
+    return next;
   }
 };
 var JsonFileOfflineQueue = class {
@@ -591,21 +624,39 @@ var JsonFileOfflineQueue = class {
   filePath;
   operation = Promise.resolve();
   async enqueue(events4) {
-    await this.update((current) => [...current, ...events4]);
+    await this.withTransaction(async () => {
+      await this.updateUnlocked((current) => [...current, ...events4]);
+    });
   }
   async peek(limit) {
-    await this.operation;
-    return (await this.read()).slice(0, Math.max(0, limit));
+    return this.withTransaction((queue) => queue.peek(limit));
   }
   async remove(ids) {
-    const removed = new Set(ids);
-    await this.update((current) => current.filter((event) => !removed.has(event.id)));
+    await this.withTransaction((queue) => queue.remove(ids));
   }
   async size() {
-    await this.operation;
-    return (await this.read()).length;
+    return this.withTransaction((queue) => queue.size());
+  }
+  async withTransaction(operation) {
+    return this.serialize(async () => {
+      const release = await this.acquireLock();
+      try {
+        return await operation({
+          peek: async (limit) => (await this.readUnlocked()).slice(0, Math.max(0, limit)),
+          remove: async (ids) => {
+            const removed = new Set(ids);
+            await this.updateUnlocked(
+              (current) => current.filter((event) => !removed.has(event.id))
+            );
+          },
+          size: async () => (await this.readUnlocked()).length
+        });
+      } finally {
+        await release();
+      }
+    });
   }
-  async read() {
+  async readUnlocked() {
     try {
       const data = JSON.parse(await readFile(this.filePath, "utf8"));
       return canonicalHookEventSchema.array().parse(data);
@@ -614,21 +665,78 @@ var JsonFileOfflineQueue = class {
       throw error;
     }
   }
-  async update(transform) {
-    const next = this.operation.then(async () => {
-      const events4 = transform(await this.read());
-      await mkdir(dirname(this.filePath), { recursive: true, mode: 448 });
-      const temporary = `${this.filePath}.${process.pid}.tmp`;
-      await writeFile(temporary, JSON.stringify(events4), { encoding: "utf8", mode: 384 });
-      await rename(temporary, this.filePath);
+  async updateUnlocked(transform) {
+    const events4 = transform(await this.readUnlocked());
+    await mkdir(dirname(this.filePath), { recursive: true, mode: 448 });
+    const temporary = `${this.filePath}.${process.pid}.${randomUUID3()}.tmp`;
+    await writeFile(temporary, JSON.stringify(events4), {
+      encoding: "utf8",
+      mode: 384
     });
-    this.operation = next.catch(() => void 0);
-    await next;
+    await rename(temporary, this.filePath);
+  }
+  async serialize(operation) {
+    const next = this.operation.then(operation);
+    this.operation = next.then(
+      () => void 0,
+      () => void 0
+    );
+    return next;
+  }
+  async acquireLock() {
+    const lockPath = `${this.filePath}.lock`;
+    const token = randomUUID3();
+    const startedAt = Date.now();
+    await mkdir(dirname(this.filePath), { recursive: true, mode: 448 });
+    while (true) {
+      try {
+        const handle = await open(lockPath, "wx", 384);
+        try {
+          await handle.writeFile(
+            JSON.stringify({ pid: process.pid, token, createdAt: Date.now() }),
+            "utf8"
+          );
+        } catch (error) {
+          await handle.close().catch(() => void 0);
+          await unlink(lockPath).catch(() => void 0);
+          throw error;
+        }
+        await handle.close();
+        return async () => {
+          try {
+            const current = JSON.parse(
+              await readFile(lockPath, "utf8")
+            );
+            if (current.token === token) await unlink(lockPath);
+          } catch (error) {
+            if (error.code !== "ENOENT") throw error;
+          }
+        };
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+      }
+      try {
+        const details = await stat(lockPath);
+        if (Date.now() - details.mtimeMs > 3e4) {
+          const stalePath = `${lockPath}.${process.pid}.${token}.stale`;
+          await rename(lockPath, stalePath);
+          await unlink(stalePath).catch(() => void 0);
+          continue;
+        }
+      } catch (error) {
+        if (error.code === "ENOENT") continue;
+        throw error;
+      }
+      if (Date.now() - startedAt > 15e3) {
+        throw new Error(`Timed out waiting for offline queue lock: ${lockPath}`);
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, 25));
+    }
   }
 };
 
 // src/presence.ts
-import { createHash, randomUUID as randomUUID3 } from "crypto";
+import { createHash, randomUUID as randomUUID4 } from "crypto";
 import { spawn } from "child_process";
 import { mkdir as mkdir2, readFile as readFile2, readdir, rm, writeFile as writeFile2 } from "fs/promises";
 import { homedir } from "os";
@@ -642,7 +750,7 @@ async function startPresenceSession(source, sessionId, cwd = process.cwd()) {
   const statePath = presenceStatePath(source, sessionId, cwd);
   await rm(statePath, { force: true });
   await mkdir2(presenceDirectory(), { recursive: true, mode: 448 });
-  const instanceId = randomUUID3();
+  const instanceId = randomUUID4();
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const cliPath = process.argv[1];
   const state = {

package/dist/{chunk-E2RWE6UW.js → chunk-YLC4TF4F.js}

@@ -19,12 +19,21 @@ import {
   startPresenceSession,
   stopPresenceSession,
   updatePresenceSession
-} from "./chunk-K7TK7FHF.js";
+} from "./chunk-4WIGVKDR.js";
 
 // src/cli/commands.ts
-import { access, cp, mkdir, readFile, writeFile } from "fs/promises";
+import { createHash } from "crypto";
+import { realpathSync } from "fs";
+import {
+  access,
+  cp,
+  mkdir,
+  readFile,
+  rename,
+  writeFile
+} from "fs/promises";
 import { homedir, hostname } from "os";
-import { basename, join, resolve } from "path";
+import { basename, extname, join, resolve } from "path";
 import { fileURLToPath } from "url";
 import { execFile } from "child_process";
 
@@ -307,10 +316,12 @@ async function setupCommand(requestedAdapter, options = {}) {
       appUrl,
       options.projectId
     );
+    await adoptPendingQueue(cwd, options.projectId);
     const heartbeat2 = await sendVerificationHeartbeat(
       existingCredential,
       adapter,
-      "setup"
+      "setup",
+      cwd
     );
     return {
       exitCode: heartbeat2.error ? 1 : 0,
@@ -397,7 +408,13 @@ Confirm code ${authorization.user_code}
     appUrl,
     token.projectId
   );
-  const heartbeat = await sendVerificationHeartbeat(credential, adapter, "setup");
+  await adoptPendingQueue(cwd, token.projectId);
+  const heartbeat = await sendVerificationHeartbeat(
+    credential,
+    adapter,
+    "setup",
+    cwd
+  );
   return {
     exitCode: heartbeat.error ? 1 : 0,
     message: `${heartbeat.error ? `Connected ${adapter} to Wibe, but the verification heartbeat could not be delivered (${heartbeat.error}). It remains safe to retry with wibe doctor. Installed or refreshed ${installedNativeFiles.length} native config file(s); unmanaged configuration was left untouched.` : `Connected ${adapter} to Wibe and verified the event connection. Installed or refreshed ${installedNativeFiles.length} native config file(s); unmanaged configuration was left untouched and reviewable templates are at ${destination}.`}${adapterSetupNextSteps(adapter)}`
@@ -577,7 +594,13 @@ Install the Wibe GitHub App on ${repository}, then return here.
     appUrl,
     snapshot.project_id
   );
-  const heartbeat = await sendVerificationHeartbeat(credential, adapter, "setup");
+  await adoptPendingQueue(cwd, snapshot.project_id);
+  const heartbeat = await sendVerificationHeartbeat(
+    credential,
+    adapter,
+    "setup",
+    cwd
+  );
   if (heartbeat.error) {
     return {
       exitCode: 1,
@@ -620,9 +643,11 @@ async function waitForOnboarding(appUrl, sessionId, sessionSecret, ready) {
   throw new Error("Timed out waiting for the browser step to finish.");
 }
 async function statusCommand(cwd = process.cwd()) {
+  const legacyQueue = await quarantineLegacyQueue();
   const repo = await detectRepository(cwd);
   const credential = await loadCredential(cwd);
-  const queue = queuePath();
+  const queue = credential ? projectQueuePath(credential.projectId) : pendingQueuePath(repo?.root ?? cwd);
+  const queueBacklog = await new JsonFileOfflineQueue(queue).size();
   const installed = (await Promise.all(
     ADAPTERS.map(async (adapter) => ({
       adapter,
@@ -638,7 +663,9 @@ async function statusCommand(cwd = process.cwd()) {
         connected: Boolean(credential),
         projectId: credential?.projectId ?? null,
         eventEndpoint: credential ? `${credential.appUrl}/api/events/batch` : null,
-        offlineQueue: queue
+        offlineQueue: queue,
+        offlineQueueBacklog: queueBacklog,
+        legacyQueue: legacyQueue.pending ? legacyQueue.quarantined : null
       },
       null,
       2
@@ -757,8 +784,11 @@ async function emitCommand(adapter, eventName, input) {
   const publishableEvents = [event, ...repositoryEvents].filter(
     (candidate) => eventTypeForHook(candidate)
   );
-  const queue = new JsonFileOfflineQueue(queuePath());
   const credential = await loadCredential(process.cwd());
+  await quarantineLegacyQueue();
+  const queue = new JsonFileOfflineQueue(
+    credential ? projectQueuePath(credential.projectId) : pendingQueuePath(repo?.root ?? process.cwd())
+  );
   if (!credential) {
     if (publishableEvents.length) await queue.enqueue(publishableEvents);
     return {
@@ -797,6 +827,7 @@ async function shareProgressCommand(options, cwd = process.cwd()) {
   if (!projectConfig || !credential) {
     throw new Error("Wibe is not authorized in this repository. Run wibe setup first.");
   }
+  await quarantineLegacyQueue();
   const summary = options.summary?.trim() ?? "";
   const wordCount = summary.split(/\s+/).filter(Boolean).length;
   if (wordCount < 20 || wordCount > 55 || summary.length > 500) {
@@ -860,7 +891,7 @@ async function shareProgressCommand(options, cwd = process.cwd()) {
     projectId: credential.projectId,
     repositoryId: credential.repositoryId,
     deviceId: credential.deviceId,
-    queue: new JsonFileOfflineQueue(queuePath())
+    queue: new JsonFileOfflineQueue(projectQueuePath(credential.projectId))
   }).capture(event);
   return {
     exitCode: result.error ? 1 : 0,
@@ -868,16 +899,29 @@ async function shareProgressCommand(options, cwd = process.cwd()) {
   };
 }
 async function doctorCommand(cwd = process.cwd(), requestedRepository) {
+  const legacyQueue = await quarantineLegacyQueue();
   const credential = await loadCredential(cwd);
   const projectConfig = await readProjectConfig(join(cwd, ".wibe", "project.json"));
+  const repositoryForQueue = await detectRepository(cwd);
+  const queuePath = credential ? projectQueuePath(credential.projectId) : pendingQueuePath(repositoryForQueue?.root ?? cwd);
+  let queueBacklog;
+  let queueError;
+  try {
+    queueBacklog = await new JsonFileOfflineQueue(queuePath).size();
+  } catch (error) {
+    queueError = error instanceof Error ? error.message : String(error);
+  }
   const expectedRepository = requestedRepository ? normalizeGitHubRepository(requestedRepository) : projectConfig?.repository;
   if (requestedRepository && !expectedRepository) {
     throw new Error(
       `Expected repository "${requestedRepository}" is not a valid GitHub owner/repository.`
     );
   }
-  const repository = await detectRepository(cwd);
+  const repository = repositoryForQueue;
   const repositoryMatches = expectedRepository ? matchesGitHubRepository(repository?.remote, expectedRepository) : true;
+  const credentialMatchesProjectConfig = Boolean(
+    credential && projectConfig && credential.projectId === projectConfig.projectId && credential.appUrl.replace(/\/$/, "") === projectConfig.appUrl.replace(/\/$/, "")
+  );
   let adapter;
   let adapterError;
   try {
@@ -885,11 +929,17 @@ async function doctorCommand(cwd = process.cwd(), requestedRepository) {
   } catch (error) {
     adapterError = error instanceof Error ? error.message : String(error);
   }
-  const heartbeat = credential && adapter && repositoryMatches ? await sendVerificationHeartbeat(credential, adapter, "doctor") : void 0;
-  const nativeConfig = adapter ? await validateNativeConfigs(adapter, cwd) : { hooks: false, mcp: false, activityRule: false, projectTrust: void 0 };
+  const heartbeat = credential && adapter && repositoryMatches && credentialMatchesProjectConfig ? await sendVerificationHeartbeat(credential, adapter, "doctor", cwd) : void 0;
+  const nativeConfig = adapter ? await validateNativeConfigs(adapter, cwd, projectConfig?.projectId) : { hooks: false, mcp: false, activityRule: false, projectTrust: void 0 };
   const trustNotes = adapter === "codex" && nativeConfig.projectTrust === void 0 ? [
     "note  Codex project trust could not be verified because the user config was not found; trust this project in Codex and rerun doctor"
   ] : [];
+  const queueNotes = [
+    `note  project queue ${queuePath} contains ${queueBacklog ?? "unknown"} event(s)`,
+    ...legacyQueue.pending ? [
+      `note  legacy shared queue is quarantined at ${legacyQueue.quarantined} and will not be delivered automatically`
+    ] : []
+  ];
   const checks = [
     ["node", Number(process.versions.node.split(".")[0]) >= 20],
     ["git repository", Boolean(repository)],
@@ -902,6 +952,14 @@ async function doctorCommand(cwd = process.cwd(), requestedRepository) {
     ["device authorization", Boolean(credential)],
     ["event endpoint", Boolean(credential?.appUrl)],
     ["project scope", Boolean(credential?.projectId)],
+    [
+      "project config matches device credential",
+      credentialMatchesProjectConfig
+    ],
+    [
+      queueError ? `project queue (${queueError})` : "project queue",
+      queueError === void 0
+    ],
     [
       adapterError ? `adapter detection (${adapterError})` : "adapter detection",
       Boolean(adapter)
@@ -927,13 +985,14 @@ async function doctorCommand(cwd = process.cwd(), requestedRepository) {
     exitCode: failures ? 1 : 0,
     message: [
       ...checks.map(([name, okay]) => `${okay ? "ok" : "missing"}  ${name}`),
-      ...trustNotes
+      ...trustNotes,
+      ...queueNotes
     ].join("\n")
   };
 }
 async function loadCredential(cwd) {
   if (process.env.WIBE_ACCESS_TOKEN && process.env.WIBE_PROJECT_ID && process.env.WIBE_ORGANIZATION_ID && process.env.WIBE_DEVICE_ID) {
-    return {
+    const credential = {
       appUrl: process.env.WIBE_APP_URL ?? "http://localhost:3000",
       accessToken: process.env.WIBE_ACCESS_TOKEN,
       projectId: process.env.WIBE_PROJECT_ID,
@@ -941,17 +1000,22 @@ async function loadCredential(cwd) {
       repositoryId: process.env.WIBE_REPOSITORY_ID,
       deviceId: process.env.WIBE_DEVICE_ID
     };
+    const project = await readProjectConfig(join(cwd, ".wibe", "project.json"));
+    if (!project || project.projectId !== credential.projectId || project.appUrl.replace(/\/$/, "") !== credential.appUrl.replace(/\/$/, "")) {
+      return null;
+    }
+    return credential;
   }
   try {
-    const project = JSON.parse(
-      await readFile(join(cwd, ".wibe", "project.json"), "utf8")
-    );
-    if (!project.projectId) return null;
+    const project = await readProjectConfig(join(cwd, ".wibe", "project.json"));
+    if (!project) return null;
     const stored = await new SystemCredentialStore().get(
       "dev.wibe.bridge",
       project.projectId
     );
-    return stored ? JSON.parse(stored) : null;
+    if (!stored) return null;
+    const credential = JSON.parse(stored);
+    return credential.projectId === project.projectId && credential.appUrl.replace(/\/$/, "") === project.appUrl.replace(/\/$/, "") ? credential : null;
   } catch {
     return null;
   }
@@ -982,8 +1046,19 @@ async function installNativeConfigs(adapter, source, cwd, appUrl, projectId) {
   for (const [sourceName, destinationName] of files) {
     const destinationPath = join(cwd, destinationName);
     const destinationExists = await exists(destinationPath);
+    const isMcpConfig = destinationName === ".cursor/mcp.json" || destinationName === ".mcp.json" || destinationName === ".codex/config.toml";
     const isCursorActivityRule = adapter === "cursor" && destinationName === ".cursor/rules/wibe-activity.mdc";
     if (destinationExists) {
+      if (isMcpConfig) {
+        if (await refreshMcpConfig(
+          adapter,
+          destinationPath,
+          `${appUrl}/api/mcp/projects/${projectId}`
+        )) {
+          installed.push(destinationName);
+        }
+        continue;
+      }
       if (!isCursorActivityRule) continue;
       const existingRule = await readFile(destinationPath, "utf8");
       if (!existingRule.includes("# Wibe activity") || !existingRule.includes("wibe_share_progress")) {
@@ -1016,6 +1091,37 @@ async function installNativeConfigs(adapter, source, cwd, appUrl, projectId) {
   }
   return installed;
 }
+async function refreshMcpConfig(adapter, path, resourceUrl) {
+  const current = await readFile(path, "utf8");
+  if (adapter === "codex") {
+    const next = current.replace(
+      /(\[mcp_servers\.wibe\][\s\S]*?^\s*url\s*=\s*)["'][^"']*\/api\/mcp(?:\/projects\/[0-9a-f-]+)?\/?["']/m,
+      `$1${JSON.stringify(resourceUrl)}`
+    );
+    if (next === current) return false;
+    await writeFile(path, next, { mode: 384 });
+    return true;
+  }
+  let parsed;
+  try {
+    const value = JSON.parse(current);
+    if (!isRecord(value)) return false;
+    parsed = value;
+  } catch {
+    return false;
+  }
+  if (!isRecord(parsed.mcpServers) || !isRecord(parsed.mcpServers.wibe)) {
+    return false;
+  }
+  const existingUrl = parsed.mcpServers.wibe.url;
+  if (typeof existingUrl !== "string" || !existingUrl.includes("/api/mcp")) {
+    return false;
+  }
+  parsed.mcpServers.wibe.url = resourceUrl;
+  await writeFile(path, `${JSON.stringify(parsed, null, 2)}
+`, { mode: 384 });
+  return true;
+}
 function renderTemplate(template, appUrl, projectId) {
   return template.replaceAll("${env:WIBE_APP_URL}", appUrl).replaceAll("${WIBE_APP_URL}", appUrl).replaceAll("${WIBE_PROJECT_ID}", projectId);
 }
@@ -1045,8 +1151,69 @@ async function ensureClaudeImportsAgents(path) {
   await writeFile(path, next, { mode: 420 });
   return true;
 }
-function queuePath() {
-  return process.env.WIBE_QUEUE_PATH ?? join(homedir(), ".wibe", "events.json");
+function queueRoot() {
+  const override = process.env.WIBE_QUEUE_PATH?.trim();
+  if (!override) return join(homedir(), ".wibe", "queue");
+  return extname(override) ? `${override}.d` : override;
+}
+function projectQueuePath(projectId) {
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
+    projectId
+  )) {
+    throw new Error("Wibe project ID must be a UUID.");
+  }
+  return join(queueRoot(), `${projectId}.json`);
+}
+function pendingQueuePath(cwd) {
+  let canonicalRoot = resolve(cwd);
+  try {
+    canonicalRoot = realpathSync.native(canonicalRoot);
+  } catch {
+  }
+  const repositoryHash = createHash("sha256").update(canonicalRoot).digest("hex").slice(0, 24);
+  return join(queueRoot(), `pending-${repositoryHash}.json`);
+}
+function legacyQueuePaths() {
+  const override = process.env.WIBE_QUEUE_PATH?.trim();
+  if (override && extname(override)) {
+    return {
+      current: override,
+      quarantined: `${override.slice(0, -extname(override).length)}.legacy${extname(override)}`
+    };
+  }
+  const directory = override || join(homedir(), ".wibe");
+  return {
+    current: join(directory, "events.json"),
+    quarantined: join(directory, "events.legacy.json")
+  };
+}
+async function quarantineLegacyQueue() {
+  const paths = legacyQueuePaths();
+  if (await exists(paths.current)) {
+    if (!await exists(paths.quarantined)) {
+      await rename(paths.current, paths.quarantined).catch((error) => {
+        if (error.code !== "ENOENT") throw error;
+      });
+    }
+  }
+  return {
+    ...paths,
+    pending: await exists(paths.current) || await exists(paths.quarantined)
+  };
+}
+async function adoptPendingQueue(cwd, projectId) {
+  await quarantineLegacyQueue();
+  const repository = await detectRepository(cwd);
+  const pending = new JsonFileOfflineQueue(
+    pendingQueuePath(repository?.root ?? cwd)
+  );
+  const project = new JsonFileOfflineQueue(projectQueuePath(projectId));
+  while (true) {
+    const events = await pending.peek(100);
+    if (!events.length) return;
+    await project.enqueue(events);
+    await pending.remove(events.map((event) => event.id));
+  }
 }
 async function exists(path) {
   try {
@@ -1056,7 +1223,7 @@ async function exists(path) {
     return false;
   }
 }
-async function validateNativeConfigs(adapter, cwd) {
+async function validateNativeConfigs(adapter, cwd, projectId) {
   if (adapter === "codex") {
     const hooks = await validJson(
       join(cwd, ".codex", "hooks.json"),
@@ -1065,14 +1232,19 @@ async function validateNativeConfigs(adapter, cwd) {
     let mcp = false;
     try {
       const config = await readFile(join(cwd, ".codex", "config.toml"), "utf8");
-      mcp = config.includes("[mcp_servers.wibe]") && config.includes("/api/mcp");
+      mcp = config.includes("[mcp_servers.wibe]") && Boolean(
+        projectId && config.includes(`/api/mcp/projects/${projectId}`)
+      );
     } catch {
       mcp = false;
     }
     return {
       hooks,
       mcp,
-      activityRule: await validWibeActivityInstructions(join(cwd, "AGENTS.md")),
+      activityRule: await validWibeActivityInstructions(
+        join(cwd, "AGENTS.md"),
+        projectId
+      ),
       projectTrust: await codexProjectTrust(cwd)
     };
   }
@@ -1083,19 +1255,21 @@ async function validateNativeConfigs(adapter, cwd) {
     mcp: await validJson(mcpPath, (value) => {
       if (!isRecord(value.mcpServers)) return false;
       const wibe = value.mcpServers.wibe;
-      return isRecord(wibe) && typeof wibe.url === "string" && wibe.url.replace(/\/$/, "").endsWith("/api/mcp");
+      return isRecord(wibe) && typeof wibe.url === "string" && Boolean(
+        projectId && wibe.url.replace(/\/$/, "").endsWith(`/api/mcp/projects/${projectId}`)
+      );
     }),
     activityRule: adapter === "cursor" ? await validText(
       join(cwd, ".cursor", "rules", "wibe-activity.mdc"),
-      (value) => value.includes("alwaysApply: true") && value.includes("wibe_share_progress") && value.includes("wibe share-progress")
-    ) : await validWibeActivityInstructions(join(cwd, "AGENTS.md")),
+      (value) => value.includes("alwaysApply: true") && Boolean(projectId && value.includes(projectId)) && value.includes("wibe_share_progress") && value.includes("wibe share-progress")
+    ) : await validWibeActivityInstructions(join(cwd, "AGENTS.md"), projectId),
     projectTrust: void 0
   };
 }
-function validWibeActivityInstructions(path) {
+function validWibeActivityInstructions(path, projectId) {
   return validText(
     path,
-    (value) => value.includes(WIBE_ACTIVITY_BEGIN) && value.includes(WIBE_ACTIVITY_END) && value.includes("wibe_share_progress") && value.includes("wibe share-progress")
+    (value) => value.includes(WIBE_ACTIVITY_BEGIN) && value.includes(WIBE_ACTIVITY_END) && Boolean(projectId && value.includes(projectId)) && value.includes("wibe_share_progress") && value.includes("wibe share-progress")
   );
 }
 async function codexProjectTrust(cwd) {
@@ -1255,8 +1429,8 @@ async function assertExpectedRepository(cwd, expected) {
     `Repository mismatch: expected GitHub repository "${expected}", but found ${actual}. Run this command from the expected repository root or correct the origin remote, then retry.`
   );
 }
-async function sendVerificationHeartbeat(credential, adapter, reason) {
-  const repository = await detectRepository(process.cwd());
+async function sendVerificationHeartbeat(credential, adapter, reason, cwd) {
+  const repository = await detectRepository(cwd);
   const workingTree = repository ? await detectWorkingTreeMetrics(repository.root) : void 0;
   return new SignedBatchClient({
     endpoint: `${credential.appUrl}/api/events/batch`,

package/dist/cli.js

@@ -7,10 +7,10 @@ import {
   setupCommand,
   shareProgressCommand,
   statusCommand
-} from "./chunk-E2RWE6UW.js";
+} from "./chunk-YLC4TF4F.js";
 import {
   runPresenceHeartbeat
-} from "./chunk-K7TK7FHF.js";
+} from "./chunk-4WIGVKDR.js";
 
 // src/cli.ts
 var HELP = `wibe-bridge <command>

package/dist/codex-hook.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   emitCommand
-} from "./chunk-E2RWE6UW.js";
-import "./chunk-K7TK7FHF.js";
+} from "./chunk-YLC4TF4F.js";
+import "./chunk-4WIGVKDR.js";
 
 // src/codex-hook.ts
 async function main() {

package/dist/index.d.ts

@@ -228,18 +228,27 @@ declare function pollDeviceToken(input: {
 }>;
 type AgentName = "cursor" | "claude-code" | "codex";
 
+interface OfflineQueueTransaction {
+    peek(limit: number): Promise<CanonicalHookEvent[]>;
+    remove(ids: readonly string[]): Promise<void>;
+    size(): Promise<number>;
+}
 interface OfflineQueue {
     enqueue(events: readonly CanonicalHookEvent[]): Promise<void>;
     peek(limit: number): Promise<CanonicalHookEvent[]>;
     remove(ids: readonly string[]): Promise<void>;
     size(): Promise<number>;
+    withTransaction<T>(operation: (queue: OfflineQueueTransaction) => Promise<T>): Promise<T>;
 }
 declare class MemoryOfflineQueue implements OfflineQueue {
     private events;
+    private operation;
     enqueue(events: readonly CanonicalHookEvent[]): Promise<void>;
     peek(limit: number): Promise<CanonicalHookEvent[]>;
     remove(ids: readonly string[]): Promise<void>;
     size(): Promise<number>;
+    withTransaction<T>(operation: (queue: OfflineQueueTransaction) => Promise<T>): Promise<T>;
+    private serialize;
 }
 declare class JsonFileOfflineQueue implements OfflineQueue {
     private readonly filePath;
@@ -249,8 +258,11 @@ declare class JsonFileOfflineQueue implements OfflineQueue {
     peek(limit: number): Promise<CanonicalHookEvent[]>;
     remove(ids: readonly string[]): Promise<void>;
     size(): Promise<number>;
-    private read;
-    private update;
+    withTransaction<T>(operation: (queue: OfflineQueueTransaction) => Promise<T>): Promise<T>;
+    private readUnlocked;
+    private updateUnlocked;
+    private serialize;
+    private acquireLock;
 }
 
 interface SignedBatchClientOptions {
@@ -346,4 +358,4 @@ declare function sanitizeRemote(remote: string): string;
 declare function normalizeGitHubRepository(value: string): string | undefined;
 declare function matchesGitHubRepository(remote: string | undefined, expected: string): boolean;
 
-export { type AgentSource, type CanonicalHookEvent, type CredentialStore, type DeviceAuthorization, type DeviceTokenResponse, type FlushResult, type HookEventKind, JsonFileOfflineQueue, MemoryOfflineQueue, type OfflineQueue, PRESENCE_HEARTBEAT_INTERVAL_MS, type PresenceMetrics, type RedactionOptions, type RepositoryInfo, type RepositoryTransition, type SafeValue, SignedBatchClient, type SignedBatchClientOptions, type StoredCredential, SystemCredentialStore, type WorkingTreeMetrics, agentSourceSchema, canonicalHookEventSchema, classifyHeadTransition, createHookEvent, detectRepository, detectWorkingTreeMetrics, deviceAuthorizationSchema, deviceTokenResponseSchema, eventTypeForHook, hookEventKindSchema, isObservedPush, mapClaudeCodeHook, mapCodexHook, mapCursorHook, matchesGitHubRepository, normalizeGitHubRepository, observeRepositoryTransitions, pollDeviceToken, presenceStatePath, redact, requestDeviceAuthorization, resolveLatestPresenceSession, runPresenceHeartbeat, safeMetadata, safeValueSchema, sanitizeRemote, startPresenceSession, stopPresenceSession, updatePresenceSession };
+export { type AgentSource, type CanonicalHookEvent, type CredentialStore, type DeviceAuthorization, type DeviceTokenResponse, type FlushResult, type HookEventKind, JsonFileOfflineQueue, MemoryOfflineQueue, type OfflineQueue, type OfflineQueueTransaction, PRESENCE_HEARTBEAT_INTERVAL_MS, type PresenceMetrics, type RedactionOptions, type RepositoryInfo, type RepositoryTransition, type SafeValue, SignedBatchClient, type SignedBatchClientOptions, type StoredCredential, SystemCredentialStore, type WorkingTreeMetrics, agentSourceSchema, canonicalHookEventSchema, classifyHeadTransition, createHookEvent, detectRepository, detectWorkingTreeMetrics, deviceAuthorizationSchema, deviceTokenResponseSchema, eventTypeForHook, hookEventKindSchema, isObservedPush, mapClaudeCodeHook, mapCodexHook, mapCursorHook, matchesGitHubRepository, normalizeGitHubRepository, observeRepositoryTransitions, pollDeviceToken, presenceStatePath, redact, requestDeviceAuthorization, resolveLatestPresenceSession, runPresenceHeartbeat, safeMetadata, safeValueSchema, sanitizeRemote, startPresenceSession, stopPresenceSession, updatePresenceSession };

package/dist/index.js

@@ -33,7 +33,7 @@ import {
   startPresenceSession,
   stopPresenceSession,
   updatePresenceSession
-} from "./chunk-K7TK7FHF.js";
+} from "./chunk-4WIGVKDR.js";
 export {
   JsonFileOfflineQueue,
   MemoryOfflineQueue,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wibeco/bridge",
-  "version": "0.2.16",
+  "version": "0.2.17",
   "description": "Privacy-first live activity bridge for Cursor, Claude Code, and Codex.",
   "repository": {
     "type": "git",

package/templates/claude-code/README.md

@@ -13,5 +13,7 @@ stored in the operating-system keychain; hooks do not require repository secrets
 allow-list excludes prompt, content, messages, command text, tool arguments/results, and transcripts.
 
 `mcp.json.example` connects Claude Code to Wibe's remote MCP endpoint at
-`${env:WIBE_APP_URL}/api/mcp`. The MCP client completes OAuth separately from the bridge device token.
-Set `WIBE_APP_URL` to the same Wibe origin used during setup.
+`${env:WIBE_APP_URL}/api/mcp/projects/${WIBE_PROJECT_ID}`. The project-specific resource keeps this
+repository's OAuth grant isolated from other Wibe projects on the same machine. The MCP client
+completes OAuth separately from the bridge device token. Set `WIBE_APP_URL` to the same Wibe origin
+used during setup.

package/templates/claude-code/mcp.json.example

@@ -2,7 +2,7 @@
   "mcpServers": {
     "wibe": {
       "type": "http",
-      "url": "${WIBE_APP_URL}/api/mcp"
+      "url": "${WIBE_APP_URL}/api/mcp/projects/${WIBE_PROJECT_ID}"
     }
   }
 }

package/templates/codex/README.md

@@ -9,8 +9,10 @@ and transcripts are not retained.
 Run `wibe setup` to authorize a revocable, project-scoped device token stored in the operating-system
 keychain. Hooks do not require repository signing secrets.
 
-The MCP block connects Codex to Wibe's remote `/api/mcp` endpoint. Codex completes OAuth separately
-from the bridge device token. Set `WIBE_APP_URL` to the same Wibe origin used during setup.
+The MCP block connects Codex to a project-specific remote
+`/api/mcp/projects/${WIBE_PROJECT_ID}` endpoint, keeping this repository's OAuth grant isolated from
+other Wibe projects on the same machine. Codex completes OAuth separately from the bridge device
+token. Set `WIBE_APP_URL` to the same Wibe origin used during setup.
 Project-local Codex configuration loads only after the project is trusted, and command hooks must be
 reviewed in `/hooks`. Session hooks own a metadata-only 45-second heartbeat that ends cleanly with
 `SessionEnd`.

package/templates/codex/config.toml.example

@@ -1,2 +1,2 @@
 [mcp_servers.wibe]
-url = "${WIBE_APP_URL}/api/mcp"
+url = "${WIBE_APP_URL}/api/mcp/projects/${WIBE_PROJECT_ID}"

package/templates/cursor/README.md

@@ -17,5 +17,7 @@ stored in the operating-system keychain; hooks do not require repository secrets
 prompt, content, file body, command text, tool arguments/results, and transcripts.
 
 `mcp.json.example` connects Cursor to Wibe's remote MCP endpoint at
-`${env:WIBE_APP_URL}/api/mcp`. Cursor completes the endpoint's OAuth flow separately from the bridge
-device token. Set `WIBE_APP_URL` to the same Wibe origin used during setup.
+`${env:WIBE_APP_URL}/api/mcp/projects/${WIBE_PROJECT_ID}`. The project-specific resource keeps this
+repository's OAuth grant isolated from other Wibe projects on the same machine. Cursor completes
+OAuth separately from the bridge device token. Set `WIBE_APP_URL` to the same Wibe origin used
+during setup.

package/templates/cursor/mcp.json.example

@@ -1,7 +1,7 @@
 {
   "mcpServers": {
     "wibe": {
-      "url": "${env:WIBE_APP_URL}/api/mcp"
+      "url": "${env:WIBE_APP_URL}/api/mcp/projects/${WIBE_PROJECT_ID}"
     }
   }
 }