@covro/covro 0.2.0-beta.1 → 0.2.1-beta.1

package/dist/server/service.js

@@ -1,5 +1,8 @@
 import { ShellService } from "./shell.js";
 import { realpathSync } from "node:fs";
+import { cp } from "node:fs/promises";
+import { WorkspaceRegistry } from "./workspaces.js";
+import { UNASSIGNED_SCOPE } from "../shared/workspace-scope.js";
 import { AppError } from "../shared/errors.js";
 import { threadNameError } from "../shared/thread-name.js";
 import {
@@ -24,6 +27,11 @@ class GatewayService {
     this.store = options.store;
     this.turnUsage = new TurnUsageStore(this.store.database);
     this.projects = options.projects;
+    this.workspaces = new WorkspaceRegistry(
+      this.store.database,
+      this.projects,
+      options.workspacesRoot
+    );
     this.codex = options.codex;
     this.shell = new ShellService(this.codex);
     this.events = new EventHub(options.limits?.eventBytes);
@@ -39,6 +47,7 @@ class GatewayService {
   store;
   turnUsage;
   projects;
+  workspaces;
   codex;
   removeListener;
   fileTemporaryRoots = temporaryFileRoots();
@@ -47,6 +56,7 @@ class GatewayService {
   currentEpoch;
   confirmedCompatibility;
   archiveChanges = /* @__PURE__ */ new Set();
+  archiveRevisions = /* @__PURE__ */ new Map();
   turnBaselines = /* @__PURE__ */ new Map();
   renameChanges = /* @__PURE__ */ new Set();
   reads = /* @__PURE__ */ new Map();
@@ -99,6 +109,7 @@ class GatewayService {
     return { ready: true };
   }
   addProject(input) {
+    this.workspaces.assertProjectDirectory(input.path);
     const project = this.projects.add(input);
     this.events.publishProjects(this.projects.list());
     return project;
@@ -177,12 +188,12 @@ class GatewayService {
     });
   }
   async readRuntimeSettings(projectId) {
-    const project = this.projects.get(projectId);
-    return this.codex.readRuntimeSettings(project.canonicalRoot);
+    const cwd = projectId === null ? this.workspaces.defaultsDirectory() : this.projects.get(projectId).canonicalRoot;
+    return this.codex.readRuntimeSettings(cwd);
   }
   async saveModelDefaults(projectId, input) {
-    return this.perform("config.modelDefaults", projectId, input, async () => {
-      this.projects.get(projectId);
+    return this.perform("config.modelDefaults", projectId ?? UNASSIGNED_SCOPE, input, async () => {
+      if (projectId !== null) this.projects.get(projectId);
       this.ensureReady();
       this.ensureCompatibilityConfirmed();
       this.store.associateProject(input.clientOperationId, projectId);
@@ -191,28 +202,43 @@ class GatewayService {
     });
   }
   async listThreads(projectId, cursor, archived = false) {
-    const project = this.projects.get(projectId);
+    const project = projectId === null ? void 0 : this.projects.get(projectId);
+    const directories = project ? project.canonicalRoot : this.workspaces.allocations().map((row) => row.canonicalRoot);
     const titleReads = new Map(
       this.projection.values().filter((thread) => thread.projectId === projectId).map((thread) => [thread.id, this.beginTitleRead(thread.id)])
     );
-    const page = await this.codex.listThreads(project.canonicalRoot, cursor, archived);
-    this.projects.get(projectId);
+    const archiveReads = new Map(
+      this.projection.values().filter((thread) => thread.projectId === projectId).map((thread) => [thread.id, this.archiveRevisions.get(thread.id) ?? 0])
+    );
+    const page = Array.isArray(directories) && !directories.length ? { data: [], nextCursor: null } : await this.codex.listThreads(directories, cursor, archived);
+    if (projectId !== null) this.projects.get(projectId);
     const data = [];
     for (const thread of page.data) {
       try {
+        if (projectId === null && thread.source === "appServer" && page.data.filter((entry) => entry.cwd === thread.cwd).length === 1) {
+          const operationId = this.workspaces.recoverCreation(thread.id, thread.cwd);
+          if (operationId && !this.inFlightOperations.has(operationId)) {
+            const recovered = this.store.confirmWorkspaceCreation(operationId, thread.id);
+            this.events.publish("operation", this.operation(recovered));
+          }
+        }
         const normalized = this.normalize(thread, projectId);
         normalized.hasMessages ??= true;
         const cached = this.projection.get(thread.id);
         if (cached && normalized.hasMessages) cached.hasMessages = true;
         const titleRead = titleReads.get(thread.id);
-        if (cached && titleRead !== void 0) {
-          if (this.titleReads.get(thread.id) === titleRead)
-            this.updateArchiveState(thread.id, Boolean(normalized.archived));
+        if (cached && archiveReads.get(thread.id) === (this.archiveRevisions.get(thread.id) ?? 0))
+          this.updateArchiveState(thread.id, Boolean(normalized.archived));
+        if (cached && titleRead !== void 0)
           this.updateThreadTitle(thread.id, normalized.title, titleRead);
-        }
         data.push(this.threadView(cached ?? normalized));
       } catch (error) {
-        if (!(error instanceof AppError) || !["PROJECT_OWNERSHIP", "PROJECT_UNAVAILABLE", "PROJECT_NOT_FOUND"].includes(error.code))
+        if (!(error instanceof AppError) || ![
+          "PROJECT_OWNERSHIP",
+          "PROJECT_UNAVAILABLE",
+          "PROJECT_NOT_FOUND",
+          "WORKSPACE_UNAVAILABLE"
+        ].includes(error.code))
           throw error;
       }
     }
@@ -239,7 +265,7 @@ class GatewayService {
         (thread) => (thread.managed || this.store.activeForThread(thread.id)) && thread.projectId === projectId && this.historyVisible(thread)
       ).sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0)).slice(0, 30);
       for (const thread of managed) {
-        this.projects.assertOwnership(projectId, thread.cwd);
+        this.workspaces.assertOwnership(projectId, thread.cwd, thread.id);
         if (!data.some((entry) => entry.id === thread.id)) data.unshift(this.threadView(thread));
       }
     }
@@ -264,7 +290,7 @@ class GatewayService {
       this.archiveChanges.add(threadId);
       try {
         const actual = await this.codex.readThreadMetadata(threadId);
-        this.projects.assertOwnership(thread.projectId, actual.cwd);
+        this.workspaces.assertOwnership(thread.projectId, actual.cwd, thread.id);
         const current = this.projection.get(threadId);
         if (input.archived && (this.resumes.has(threadId) || this.store.activeForThread(threadId) || current.managed && current.status === "unknown" || [actual, current].some(
           (entry) => isActive(entry.status) || entry.turns.some((turn) => isActive(turn.status) || turn.status === "unknown") || entry.actions.some((action) => ["pending", "responding"].includes(action.status))
@@ -328,7 +354,7 @@ class GatewayService {
           actual = await this.codex.readThreadMetadata(threadId);
           if (actual.id !== threadId || this.codex.epoch !== epoch || !this.codex.ready)
             throw new Error("\u4F1A\u8BDD\u6216 Codex \u5B9E\u4F8B\u5DF2\u53D8\u5316");
-          this.projects.assertOwnership(thread.projectId, actual.cwd);
+          this.workspaces.assertOwnership(thread.projectId, actual.cwd, thread.id);
         } catch (cause) {
           throw new Error("\u91CD\u547D\u540D\u5DF2\u53D1\u9001\uFF0C\u4F46\u65E0\u6CD5\u786E\u8BA4\u4F1A\u8BDD\u540D\u79F0\uFF0C\u8BF7\u6838\u5BF9\u63D0\u4EA4", { cause });
         }
@@ -376,6 +402,7 @@ class GatewayService {
     const thread = this.projection.get(threadId);
     if (!thread || Boolean(thread.archived) === archived) return;
     thread.archived = archived;
+    this.archiveRevisions.set(threadId, (this.archiveRevisions.get(threadId) ?? 0) + 1);
     if (archived) this.releaseThreadOwnership(threadId);
     this.projection.touch(threadId);
     if (!this.archiveChanges.has(threadId)) this.publishThread(threadId);
@@ -383,9 +410,9 @@ class GatewayService {
   async getThreadMetadata(threadId) {
     const cached = this.projection.get(threadId);
     if (cached) {
-      this.projects.assertOwnership(cached.projectId, cached.cwd);
+      this.workspaces.assertOwnership(cached.projectId, cached.cwd, cached.id);
       if (this.codex.ready) await this.refreshThreadMetadata(threadId);
-      this.projects.assertOwnership(cached.projectId, cached.cwd);
+      this.workspaces.assertOwnership(cached.projectId, cached.cwd, cached.id);
       return { ...this.threadView(cached), turns: [], actions: [] };
     }
     const metadata = this.threadView(this.normalize(await this.codex.readThreadMetadata(threadId)));
@@ -396,9 +423,21 @@ class GatewayService {
     await this.loadThread(threadId);
     if (cached && this.codex.ready) await this.refreshThreadMetadata(threadId);
     const thread = this.projection.get(threadId);
-    this.projects.assertOwnership(thread.projectId, thread.cwd);
+    this.workspaces.assertOwnership(thread.projectId, thread.cwd, thread.id);
     return this.threadView(thread);
   }
+  async getThreadHistory(threadId, cursor) {
+    if (!cursor || cursor.length > 8192)
+      throw new AppError("VALIDATION_FAILED", "Missing or invalid history cursor", 400);
+    this.ensureReady();
+    const metadata = this.normalize(await this.codex.readThreadMetadata(threadId));
+    this.workspaces.assertOwnership(metadata.projectId, metadata.cwd, metadata.id);
+    if (!this.codex.readThreadPage)
+      throw new AppError("HISTORY_UNAVAILABLE", "\u5F53\u524D Codex \u4E0D\u652F\u6301\u5386\u53F2\u5206\u9875", 409);
+    const page = this.normalize(await this.codex.readThreadPage(threadId, cursor));
+    this.workspaces.assertOwnership(page.projectId, page.cwd, page.id);
+    return page;
+  }
   async exportThread(threadId) {
     this.ensureReady();
     const epoch = this.codex.epoch;
@@ -415,8 +454,8 @@ class GatewayService {
         409
       );
     const link = this.store.getThreadLink(threadId);
-    if (link) this.projects.assertOwnership(link.projectId, thread.cwd);
-    else this.projects.findOwner(thread.cwd);
+    if (link) this.workspaces.assertOwnership(link.projectId, thread.cwd, thread.id);
+    else this.workspaces.findOwner(thread.cwd, thread.id);
     return renderThreadExport(thread, {
       executionUncertain: Boolean(this.store.activeForThread(threadId)),
       historyChanged: revision !== this.projection.revision(threadId) || thread.updatedAt !== latest.updatedAt || thread.status !== latest.status
@@ -437,33 +476,38 @@ class GatewayService {
       this.normalize(await this.codex.readThreadMetadata(threadId));
       link = this.store.getThreadLink(threadId);
     }
-    const { project, cwd } = this.projects.assertOwnership(link.projectId, link.cwd);
+    const ownership = this.workspaces.assertOwnership(link.projectId, link.cwd, threadId);
+    const { cwd } = ownership;
     const file = await read(path, {
       cwd,
+      excludedRoots: this.workspaces.allocations().filter((row) => row.threadId !== threadId).map((row) => row.canonicalRoot),
       roots: [
-        { canonicalRoot: project.canonicalRoot, aliases: [project.rootPath] },
-        ...this.fileTemporaryRoots
+        { canonicalRoot: ownership.canonicalRoot, aliases: [ownership.rootPath] },
+        ...link.projectId === null ? [] : this.fileTemporaryRoots
       ]
     });
-    this.projects.assertOwnership(link.projectId, link.cwd);
+    this.workspaces.assertOwnership(link.projectId, link.cwd, threadId);
     return file;
   }
   async loadThread(threadId) {
     const cached = this.projection.get(threadId);
     if (cached) {
-      this.projects.assertOwnership(cached.projectId, cached.cwd);
+      this.workspaces.assertOwnership(cached.projectId, cached.cwd, cached.id);
       const marker = this.store.activeForThread(threadId);
       if (marker?.turnId && this.codex.ready) {
         await this.refreshExecution(marker);
         return this.threadView(cached);
       }
-      if (cached.status !== "unknown" || !this.codex.ready) return this.threadView(cached);
+      if ((cached.managed || isActive(cached.status)) && cached.status !== "unknown" || !this.codex.ready)
+        return this.threadView(cached);
     }
     const existing = this.reads.get(threadId);
     if (existing) return this.threadView(await existing);
     const revision = this.projection.revision(threadId);
     const loading = (async () => {
-      const thread = this.normalize(await this.codex.readThread(threadId));
+      const thread = this.normalize(
+        await (this.codex.readThreadPage?.(threadId) ?? this.codex.readThread(threadId))
+      );
       const current = this.projection.get(threadId);
       const preserveCurrent = current && (cached === void 0 || this.projection.revision(threadId) !== revision);
       const result = preserveCurrent ? current : this.projection.thread(thread);
@@ -483,18 +527,26 @@ class GatewayService {
     }
   }
   async createThread(projectId, input) {
-    return this.perform("thread.create", projectId, input, async () => {
-      const project = this.projects.get(projectId);
+    return this.perform("thread.create", projectId ?? UNASSIGNED_SCOPE, input, async () => {
       this.ensureReady();
       this.ensureCompatibilityConfirmed();
+      const cwd = projectId === null ? this.workspaces.allocate(input.clientOperationId).cwd : this.projects.get(projectId).canonicalRoot;
+      if (projectId !== null) this.workspaces.assertProjectDirectory(cwd);
       this.store.associateProject(input.clientOperationId, projectId);
       this.store.dispatch(input.clientOperationId);
-      this.pendingThreadCreations.set(input.clientOperationId, project.canonicalRoot);
+      this.pendingThreadCreations.set(input.clientOperationId, cwd);
       const epoch = this.codex.epoch;
       const settingsSequence = this.runtimeSettingsSequence;
-      const thread = await this.codex.createThread(project.canonicalRoot, input.settings);
+      const thread = await this.codex.createThread(cwd, input.settings);
       if (this.codex.epoch !== epoch || !this.codex.ready)
         throw new Error("\u521B\u5EFA\u8BF7\u6C42\u5DF2\u53D1\u9001\uFF0C\u4F46 Codex \u5B9E\u4F8B\u5DF2\u53D8\u5316\uFF0C\u8BF7\u6838\u5BF9\u5386\u53F2");
+      if (projectId === null) {
+        try {
+          this.workspaces.bind(input.clientOperationId, thread.id, thread.cwd);
+        } catch (cause) {
+          throw new Error("\u521B\u5EFA\u8BF7\u6C42\u5DF2\u53D1\u9001\uFF0C\u4F46\u8FD4\u56DE\u7684\u5DE5\u4F5C\u76EE\u5F55\u65E0\u6CD5\u786E\u8BA4\uFF0C\u8BF7\u6838\u5BF9\u5386\u53F2", { cause });
+        }
+      }
       const normalized = this.normalize(thread, projectId, true);
       this.projection.thread(
         normalized,
@@ -511,7 +563,7 @@ class GatewayService {
       this.ensureReady();
       this.ensureArchiveAvailable(thread);
       if (thread.archived) throw new AppError("THREAD_ARCHIVED", "\u8BF7\u5148\u53D6\u6D88\u5F52\u6863\u540E\u518D\u6062\u590D\u4F1A\u8BDD", 409);
-      this.projects.assertOwnership(thread.projectId, thread.cwd);
+      this.workspaces.assertOwnership(thread.projectId, thread.cwd, thread.id);
       this.store.associateProject(input.clientOperationId, thread.projectId);
       const link = this.store.getThreadLink(threadId);
       if (link?.managedEpoch === this.codex.epoch) {
@@ -525,7 +577,7 @@ class GatewayService {
           operationId: marker.operationId,
           threadId
         });
-      const ownership = this.projects.assertOwnership(thread.projectId, thread.cwd);
+      const ownership = this.workspaces.assertOwnership(thread.projectId, thread.cwd, thread.id);
       this.ensureCompatibilityConfirmed();
       this.store.dispatch(input.clientOperationId);
       let pending = this.resumes.get(threadId);
@@ -570,21 +622,29 @@ class GatewayService {
       this.ensureReady();
       const source = this.projection.get(threadId) ?? await this.codex.readThread(threadId);
       const link = this.store.getThreadLink(threadId);
-      const ownership = link ? this.projects.assertOwnership(link.projectId, source.cwd) : this.projects.findOwner(source.cwd);
+      const ownership = link ? this.workspaces.assertOwnership(link.projectId, source.cwd, threadId) : this.workspaces.findOwner(source.cwd, source.id);
       this.ensureCompatibilityConfirmed();
       const epoch = this.codex.epoch;
-      this.store.associateProject(input.clientOperationId, ownership.project.id);
+      let forkCwd = ownership.cwd;
+      if (ownership.projectId === null) {
+        forkCwd = this.workspaces.allocate(input.clientOperationId).cwd;
+        await cp(ownership.cwd, forkCwd, { recursive: true, verbatimSymlinks: true });
+        this.workspaces.assertOwnership(null, source.cwd, source.id);
+      }
+      this.store.associateProject(input.clientOperationId, ownership.projectId);
       this.store.dispatch(input.clientOperationId);
-      this.pendingThreadCreations.set(input.clientOperationId, ownership.cwd);
+      this.pendingThreadCreations.set(input.clientOperationId, forkCwd);
       const settingsSequence = this.runtimeSettingsSequence;
-      const forked = await this.codex.forkThread(threadId, ownership.cwd, input.settings);
+      const forked = await this.codex.forkThread(threadId, forkCwd, input.settings);
       if (forked.id === threadId || this.codex.epoch !== epoch || !this.codex.ready)
         throw new Error("\u5206\u53C9\u8BF7\u6C42\u5DF2\u53D1\u9001\uFF0C\u4F46\u8FD4\u56DE\u7684\u65B0\u4F1A\u8BDD\u65E0\u6CD5\u786E\u8BA4\uFF0C\u8BF7\u6838\u5BF9\u5386\u53F2");
       let normalized;
       try {
+        if (ownership.projectId === null)
+          this.workspaces.bind(input.clientOperationId, forked.id, forked.cwd);
         normalized = this.normalize(
           { ...forked, forkedFromId: threadId },
-          ownership.project.id,
+          ownership.projectId,
           true
         );
       } catch (error) {
@@ -603,7 +663,7 @@ class GatewayService {
     return this.perform("turn.start", threadId, input, async () => {
       const thread = await this.loadThread(threadId);
       this.ensureManaged(thread);
-      const ownership = this.projects.assertOwnership(thread.projectId, thread.cwd);
+      const ownership = this.workspaces.assertOwnership(thread.projectId, thread.cwd, thread.id);
       if (isActive(thread.status))
         throw new AppError("THREAD_BUSY", "\u4F1A\u8BDD\u5DF2\u6709\u6D3B\u52A8\u4EFB\u52A1\uFF0C\u8BF7\u8FFD\u52A0\u8981\u6C42\u6216\u4E2D\u65AD", 409, { threadId });
       this.ensureCompatibilityConfirmed();
@@ -636,7 +696,7 @@ class GatewayService {
     return this.perform("thread.compact", threadId, input, async () => {
       const thread = await this.loadThread(threadId);
       this.ensureManaged(thread);
-      const ownership = this.projects.assertOwnership(thread.projectId, thread.cwd);
+      const ownership = this.workspaces.assertOwnership(thread.projectId, thread.cwd, thread.id);
       if (isActive(thread.status) || thread.turns.some((turn) => isActive(turn.status)))
         throw new AppError("THREAD_BUSY", "\u8BF7\u7B49\u5F85\u5F53\u524D\u4EFB\u52A1\u7ED3\u675F\u540E\u518D\u538B\u7F29\u4E0A\u4E0B\u6587", 409);
       if (!thread.turns.length)
@@ -660,7 +720,7 @@ class GatewayService {
     return this.perform("review.start", threadId, input, async () => {
       const thread = await this.loadThread(threadId);
       this.ensureManaged(thread);
-      const ownership = this.projects.assertOwnership(thread.projectId, thread.cwd);
+      const ownership = this.workspaces.assertOwnership(thread.projectId, thread.cwd, thread.id);
       if (isActive(thread.status) || thread.turns.some((turn2) => isActive(turn2.status)))
         throw new AppError("THREAD_BUSY", "\u4F1A\u8BDD\u5DF2\u6709\u6D3B\u52A8\u4EFB\u52A1\uFF0C\u7ED3\u675F\u540E\u624D\u80FD\u5F00\u59CB\u4EE3\u7801\u5BA1\u67E5", 409, {
           threadId
@@ -759,8 +819,8 @@ class GatewayService {
         try {
           const actual = await this.codex.readThread(marker.threadId);
           const link = this.store.getThreadLink(marker.threadId);
-          if (link) this.projects.assertOwnership(link.projectId, actual.cwd);
-          else this.projects.findOwner(actual.cwd);
+          if (link) this.workspaces.assertOwnership(link.projectId, actual.cwd, actual.id);
+          else this.workspaces.findOwner(actual.cwd, actual.id);
           if (this.markerIsActive(actual, marker.turnId))
             throw new AppError("THREAD_BUSY", "\u4E0A\u6E38\u4ECD\u62A5\u544A\u8BE5\u4EFB\u52A1\u6D3B\u52A8\uFF0C\u4E0D\u80FD\u89E3\u9664\u5360\u7528", 409, {
               threadId: marker.threadId
@@ -855,14 +915,14 @@ class GatewayService {
   }
   normalize(thread, projectId, managed = false) {
     const link = this.store.getThreadLink(thread.id);
-    const ownership = link ? this.projects.assertOwnership(link.projectId, thread.cwd) : managed && projectId ? this.projects.assertOwnership(projectId, thread.cwd) : this.projects.findOwner(thread.cwd);
-    if (projectId && ownership.project.id !== projectId)
+    const ownership = link ? this.workspaces.assertOwnership(link.projectId, thread.cwd, thread.id) : managed && projectId !== void 0 ? this.workspaces.assertOwnership(projectId, thread.cwd, thread.id) : this.workspaces.findOwner(thread.cwd, thread.id);
+    if (projectId !== void 0 && ownership.projectId !== projectId)
       throw new AppError("PROJECT_OWNERSHIP", "\u4F1A\u8BDD\u5C5E\u4E8E\u5176\u4ED6\u9879\u76EE\uFF0C\u4E0D\u80FD\u6539\u53D8\u9879\u76EE\u5F52\u5C5E", 403);
     const managedEpoch = thread.archived ? null : managed ? this.codex.epoch : link?.managedEpoch ?? null;
     const result = {
       ...thread,
       turns: this.turnUsage.restore(thread.id, thread.turns),
-      projectId: ownership.project.id,
+      projectId: ownership.projectId,
       cwd: ownership.cwd,
       managed: managedEpoch === this.codex.epoch,
       resumeError: managed ? void 0 : this.projection.get(thread.id)?.resumeError,
@@ -872,7 +932,7 @@ class GatewayService {
     };
     this.store.linkThread({
       threadId: thread.id,
-      projectId: ownership.project.id,
+      projectId: ownership.projectId,
       cwd: ownership.cwd,
       source: thread.source,
       managedEpoch
@@ -907,7 +967,7 @@ class GatewayService {
         if (!this.codex.ready || this.codex.epoch !== epoch || actual.id !== marker.threadId || latest?.operationId !== marker.operationId || latest.turnId !== marker.turnId || latest.codexEpoch !== marker.codexEpoch || this.projection.revision(marker.threadId) !== revision)
           return;
         const link = this.store.getThreadLink(marker.threadId);
-        const ownership = link ? this.projects.assertOwnership(link.projectId, actual.cwd) : this.projects.findOwner(actual.cwd);
+        const ownership = link ? this.workspaces.assertOwnership(link.projectId, actual.cwd, actual.id) : this.workspaces.findOwner(actual.cwd, actual.id);
         if (ownership.workspaceKey !== marker.workspaceKey) return;
         const turn = actual.turns.find((entry) => entry.id === marker.turnId);
         if (turn && isActive(turn.status) && latest.state === "active" && this.projection.get(marker.threadId)?.status === "unknown") {
@@ -1057,7 +1117,7 @@ class GatewayService {
     const encoded = JSON.stringify(summary);
     if (this.summaries.get(threadId) === encoded) return;
     try {
-      this.projects.assertOwnership(thread.projectId, thread.cwd);
+      this.workspaces.assertOwnership(thread.projectId, thread.cwd, thread.id);
     } catch {
       return;
     }
@@ -1105,7 +1165,7 @@ class GatewayService {
       const thread = await this.codex.readThreadMetadata(threadId);
       const current = this.projection.get(threadId);
       if (!current || thread.id !== threadId) return;
-      this.projects.assertOwnership(current.projectId, thread.cwd);
+      this.workspaces.assertOwnership(current.projectId, thread.cwd, thread.id);
       const settings = thread.runtimeSettings ? { ...current.runtimeSettings, ...thread.runtimeSettings } : void 0;
       if (this.titleReads.get(threadId) === sequence && this.projection.revision(threadId) === revision && settings && JSON.stringify(current.runtimeSettings) !== JSON.stringify(settings)) {
         current.runtimeSettings = settings;
@@ -1210,7 +1270,7 @@ class GatewayService {
         this.projection.expireTurn(thread.id, event.turn.id);
         if (newCompletion) {
           try {
-            this.projects.assertOwnership(thread.projectId, thread.cwd);
+            this.workspaces.assertOwnership(thread.projectId, thread.cwd, thread.id);
             this.events.publishCompletion({
               threadId: thread.id,
               turnId: event.turn.id,