@covro/covro 0.0.0-stage → 0.1.0-dev.1

package/dist/server/service.js

@@ -0,0 +1,1221 @@
+import { realpathSync } from "node:fs";
+import { AppError } from "../shared/errors.js";
+import { threadNameError } from "../shared/thread-name.js";
+import {
+  validateElicitationResolution,
+  validatePermissionResolution
+} from "../shared/elicitation.js";
+import { toThreadSummary } from "../shared/thread-summary.js";
+import {
+  StoreConflict
+} from "./db/operations.js";
+import { EventHub } from "./events.js";
+import { TurnUsageStore } from "./db/turn-usage.js";
+import { Projection, isActive, isTerminal } from "./projection.js";
+import { renderThreadExport } from "./thread-export.js";
+import { readLocalImage } from "./images.js";
+import { temporaryFileRoots } from "./local-files.js";
+import { readLocalMarkdown } from "./markdown.js";
+class GatewayService {
+  constructor(options) {
+    this.options = options;
+    this.store = options.store;
+    this.turnUsage = new TurnUsageStore(this.store.database);
+    this.projects = options.projects;
+    this.codex = options.codex;
+    this.events = new EventHub(options.limits?.eventBytes);
+    this.projection = new Projection(options.limits?.itemBytes);
+    this.currentEpoch = this.codex.epoch;
+    this.store.recover();
+    this.removeListener = this.codex.onEvent((event) => this.consume(event));
+  }
+  options;
+  events;
+  projection;
+  store;
+  turnUsage;
+  projects;
+  codex;
+  removeListener;
+  fileTemporaryRoots = temporaryFileRoots();
+  accepting = true;
+  maintenance = false;
+  currentEpoch;
+  confirmedCompatibility;
+  archiveChanges = /* @__PURE__ */ new Set();
+  turnBaselines = /* @__PURE__ */ new Map();
+  renameChanges = /* @__PURE__ */ new Set();
+  reads = /* @__PURE__ */ new Map();
+  resumes = /* @__PURE__ */ new Map();
+  executionReads = /* @__PURE__ */ new Map();
+  summaries = /* @__PURE__ */ new Map();
+  // Request ordering only: title values always come from app-server.
+  titleReadSequence = 0;
+  titleReads = /* @__PURE__ */ new Map();
+  // A status/title/history update must not discard a lifecycle response's full configuration.
+  runtimeSettingsSequence = 0;
+  runtimeSettingsUpdates = /* @__PURE__ */ new Map();
+  inFlightOperations = /* @__PURE__ */ new Set();
+  pendingThreadCreations = /* @__PURE__ */ new Map();
+  listProjects() {
+    return this.projects.list();
+  }
+  isInMaintenance() {
+    return this.maintenance;
+  }
+  setMaintenance(value) {
+    this.maintenance = value;
+  }
+  prepareUpdate() {
+    if (this.inFlightOperations.size || this.resumes.size || this.pendingThreadCreations.size)
+      return { ready: false, reason: "\u7B49\u5F85\u6B63\u5728\u63D0\u4EA4\u6216\u6062\u590D\u7684\u64CD\u4F5C\u5B8C\u6210" };
+    if (this.store.activeMarkers().length || this.store.unresolvedOperations().length)
+      return { ready: false, reason: "\u7B49\u5F85\u4EFB\u52A1\u7ED3\u675F\uFF0C\u5E76\u6838\u5BF9\u7ED3\u679C\u5C1A\u672A\u786E\u8BA4\u7684\u64CD\u4F5C" };
+    if (this.projection.values().some((thread) => thread.managed && isActive(thread.status)) || [...this.projection.actions.values()].some(
+      (action) => ["pending", "responding"].includes(action.status)
+    ))
+      return { ready: false, reason: "\u7B49\u5F85\u6267\u884C\u4E2D\u7684\u4EFB\u52A1\u3001\u5BA1\u6279\u6216\u8F93\u5165\u7ED3\u675F" };
+    this.maintenance = true;
+    return { ready: true };
+  }
+  addProject(input) {
+    const project = this.projects.add(input);
+    this.events.publishProjects(this.projects.list());
+    return project;
+  }
+  renameProject(projectId, input) {
+    const project = this.projects.rename(projectId, input);
+    this.events.publishProjects(this.projects.list());
+    return project;
+  }
+  removeProject(projectId) {
+    const project = this.projects.describe(projectId);
+    const pending = this.store.pendingProjectOperations(projectId)[0];
+    const marker = this.store.activeMarkers().find((entry) => {
+      const link = this.store.getThreadLink(entry.threadId);
+      return link ? link.projectId === projectId : entry.workspaceKey === project.workspaceKey;
+    });
+    const active = this.projection.values().find(
+      (thread) => thread.projectId === projectId && (isActive(thread.status) || thread.actions.some((action) => ["pending", "responding"].includes(action.status)))
+    );
+    if (pending || marker || active)
+      throw new AppError(
+        "PROJECT_BUSY",
+        "\u9879\u76EE\u4ECD\u6709\u6D3B\u52A8\u4EFB\u52A1\u6216\u7ED3\u679C\u5F85\u6838\u5BF9\u7684\u64CD\u4F5C\uFF1B\u8BF7\u5148\u7ED3\u675F\u4EFB\u52A1\u5E76\u6838\u5BF9\u65E7\u64CD\u4F5C",
+        409,
+        {
+          projectId,
+          ...pending || marker ? { operationId: pending?.clientOperationId ?? marker?.operationId } : {},
+          ...marker || active ? { threadId: marker?.threadId ?? active?.id } : {}
+        }
+      );
+    this.projects.remove(projectId);
+    this.events.publishProjects(this.projects.list());
+    return { removed: true };
+  }
+  getSystem() {
+    const diagnostics = this.codex.diagnostics();
+    return {
+      ...diagnostics,
+      compatibilityConfirmation: this.compatibilityConfirmation(diagnostics),
+      authMode: this.options.authMode ?? "local",
+      demo: this.options.demo ?? false
+    };
+  }
+  subscribeRuntime(listener) {
+    return this.events.subscribeRuntime(listener);
+  }
+  subscribeOverview(listener) {
+    return this.events.subscribeOverview(listener);
+  }
+  async confirmCompatibility(input) {
+    return this.perform("system.compatibility.confirm", "system", input, async () => {
+      const diagnostics = this.codex.diagnostics();
+      this.ensureCompatibilityAvailable(diagnostics);
+      if (input.confirm !== true || input.codexEpoch !== diagnostics.codexEpoch || input.codexVersion !== diagnostics.codexVersion || input.verifiedVersion !== diagnostics.verifiedVersion)
+        throw new AppError(
+          "COMPATIBILITY_CHANGED",
+          "Codex \u8FD0\u884C\u7248\u672C\u6216\u9A8C\u8BC1\u57FA\u7EBF\u5DF2\u53D8\u5316\uFF0C\u8BF7\u5237\u65B0\u540E\u91CD\u65B0\u786E\u8BA4",
+          409
+        );
+      this.store.dispatch(input.clientOperationId);
+      const fingerprint = this.compatibilityFingerprint(diagnostics);
+      return {
+        result: {
+          codexEpoch: diagnostics.codexEpoch,
+          codexVersion: diagnostics.codexVersion,
+          verifiedVersion: diagnostics.verifiedVersion,
+          compatibilityConfirmation: diagnostics.compatibility === "unverified" ? "confirmed" : "not-required"
+        },
+        onAcknowledged: () => {
+          const current = this.codex.diagnostics();
+          if (this.codex.ready && current.ready && current.compatibility === "unverified" && this.compatibilityFingerprint(current) === fingerprint)
+            this.confirmedCompatibility = fingerprint;
+          this.events.publish("runtime", this.getSystem());
+        }
+      };
+    });
+  }
+  async readRuntimeSettings(projectId) {
+    const project = this.projects.get(projectId);
+    return this.codex.readRuntimeSettings(project.canonicalRoot);
+  }
+  async saveModelDefaults(projectId, input) {
+    return this.perform("config.modelDefaults", projectId, input, async () => {
+      this.projects.get(projectId);
+      this.ensureReady();
+      this.ensureCompatibilityConfirmed();
+      this.store.associateProject(input.clientOperationId, projectId);
+      this.store.dispatch(input.clientOperationId);
+      return { result: await this.codex.saveModelDefaults(input.settings) };
+    });
+  }
+  async listThreads(projectId, cursor, archived = false) {
+    const project = this.projects.get(projectId);
+    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 data = [];
+    for (const thread of page.data) {
+      try {
+        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));
+          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))
+          throw error;
+      }
+    }
+    if (!archived && cursor === void 0) {
+      const pending = this.store.activeMarkers().flatMap((marker) => {
+        const link = this.store.getThreadLink(marker.threadId);
+        if (link?.projectId !== projectId || this.projection.get(marker.threadId)) return [];
+        return [
+          {
+            id: marker.threadId,
+            projectId,
+            cwd: link.cwd,
+            source: link.source,
+            title: "\u63D0\u4EA4\u7ED3\u679C\u5F85\u6838\u5BF9",
+            status: "unknown",
+            turns: [],
+            actions: [],
+            managed: false,
+            updatedAt: marker.createdAt
+          }
+        ];
+      });
+      const managed = [...this.projection.values(), ...pending].filter(
+        (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);
+        if (!data.some((entry) => entry.id === thread.id)) data.unshift(this.threadView(thread));
+      }
+    }
+    return {
+      data: data.filter((thread) => thread.historyVisible && Boolean(thread.archived) === archived),
+      nextCursor: page.nextCursor
+    };
+  }
+  async listThreadSummaries(projectId, cursor, archived = false) {
+    const boundary = this.events.cursor();
+    const page = await this.listThreads(projectId, cursor, archived);
+    return { data: page.data.map(toThreadSummary), nextCursor: page.nextCursor, cursor: boundary };
+  }
+  async setThreadArchived(threadId, input) {
+    return this.perform("thread.archive", threadId, input, async () => {
+      const thread = await this.loadThread(threadId);
+      this.ensureReady();
+      this.ensureCompatibilityConfirmed();
+      this.ensureArchiveAvailable(thread, input.clientOperationId);
+      this.ensureRenameAvailable(thread);
+      this.store.associateProject(input.clientOperationId, thread.projectId);
+      this.archiveChanges.add(threadId);
+      try {
+        const actual = await this.codex.readThreadMetadata(threadId);
+        this.projects.assertOwnership(thread.projectId, actual.cwd);
+        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))
+        )))
+          throw new AppError("THREAD_BUSY", "\u4EFB\u52A1\u7ED3\u675F\u5E76\u5904\u7406\u5B8C\u5F85\u529E\u540E\u624D\u80FD\u5F52\u6863\u4F1A\u8BDD", 409);
+        this.ensureReady();
+        this.ensureCompatibilityConfirmed();
+        this.store.dispatch(input.clientOperationId);
+        if (Boolean(actual.archived) !== input.archived) {
+          try {
+            if (input.archived) await this.codex.archiveThread(threadId);
+            else await this.codex.unarchiveThread(threadId);
+          } catch (error) {
+            try {
+              const refreshed = await this.codex.readThreadMetadata(threadId);
+              this.updateArchiveState(threadId, Boolean(refreshed.archived));
+            } catch {
+            } finally {
+              this.releaseThreadOwnership(threadId);
+              this.publishThread(threadId);
+            }
+            throw error;
+          }
+        }
+        this.beginTitleRead(threadId);
+        this.updateArchiveState(threadId, input.archived);
+        this.publishThread(threadId);
+        return {
+          result: {
+            threadId,
+            archived: input.archived,
+            summary: toThreadSummary(this.threadView(this.projection.get(threadId))),
+            cursor: this.events.cursor()
+          }
+        };
+      } finally {
+        this.archiveChanges.delete(threadId);
+      }
+    });
+  }
+  async renameThread(threadId, input) {
+    return this.perform("thread.rename", threadId, input, async () => {
+      const problem = threadNameError(input.name);
+      if (problem) throw new AppError("VALIDATION_ERROR", problem);
+      const name = input.name.trim();
+      const thread = await this.loadThread(threadId);
+      this.ensureManaged(thread);
+      this.ensureCompatibilityConfirmed();
+      this.ensureRenameAvailable(thread, input.clientOperationId);
+      this.store.associateProject(input.clientOperationId, thread.projectId);
+      this.renameChanges.add(threadId);
+      try {
+        const epoch = this.codex.epoch;
+        this.store.dispatch(input.clientOperationId);
+        await this.codex.renameThread(threadId, name);
+        if (this.codex.epoch !== epoch || !this.codex.ready)
+          throw new Error("\u91CD\u547D\u540D\u5DF2\u53D1\u9001\uFF0C\u4F46 Codex \u5B9E\u4F8B\u5DF2\u53D8\u5316\uFF0C\u8BF7\u6838\u5BF9\u4F1A\u8BDD\u540D\u79F0");
+        const sequence = this.beginTitleRead(threadId);
+        let actual;
+        try {
+          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);
+        } 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 });
+        }
+        this.updateThreadTitle(threadId, actual.title, sequence);
+        if (actual.title !== name || this.projection.get(threadId)?.title !== name)
+          throw new Error("\u91CD\u547D\u540D\u5DF2\u53D1\u9001\uFF0C\u4F46\u5F53\u524D\u540D\u79F0\u4E0E\u8BF7\u6C42\u4E0D\u4E00\u81F4\uFF0C\u8BF7\u6838\u5BF9\u63D0\u4EA4");
+        return {
+          result: {
+            threadId,
+            name,
+            summary: toThreadSummary(this.threadView(this.projection.get(threadId))),
+            cursor: this.events.cursor()
+          }
+        };
+      } finally {
+        this.renameChanges.delete(threadId);
+      }
+    });
+  }
+  ensureRenameAvailable(thread, operationId) {
+    const pending = this.store.pendingProjectOperations(thread.projectId).some(
+      (entry) => entry.kind === "thread.rename" && entry.target === thread.id && entry.clientOperationId !== operationId && entry.state !== "accepted"
+    );
+    if (this.renameChanges.has(thread.id) || pending)
+      throw new AppError("THREAD_BUSY", "\u4F1A\u8BDD\u91CD\u547D\u540D\u6B63\u5728\u5904\u7406\u6216\u7ED3\u679C\u5F85\u6838\u5BF9\uFF0C\u8BF7\u5148\u6838\u5BF9\u63D0\u4EA4", 409);
+  }
+  ensureArchiveAvailable(thread, operationId) {
+    const pending = this.store.pendingProjectOperations(thread.projectId).find(
+      (entry) => entry.kind === "thread.archive" && entry.target === thread.id && entry.clientOperationId !== operationId
+    );
+    if (this.archiveChanges.has(thread.id) || pending)
+      throw new AppError("THREAD_BUSY", "\u4F1A\u8BDD\u5F52\u6863\u64CD\u4F5C\u6B63\u5728\u5904\u7406\u6216\u7ED3\u679C\u5F85\u6838\u5BF9\uFF0C\u8BF7\u5237\u65B0\u72B6\u6001", 409);
+  }
+  releaseThreadOwnership(threadId) {
+    const link = this.store.getThreadLink(threadId);
+    if (link) this.store.linkThread({ ...link, managedEpoch: null });
+    const thread = this.projection.get(threadId);
+    if (thread) {
+      thread.managed = false;
+      delete thread.resumeError;
+      this.projection.touch(threadId);
+    }
+  }
+  updateArchiveState(threadId, archived) {
+    const thread = this.projection.get(threadId);
+    if (!thread || Boolean(thread.archived) === archived) return;
+    thread.archived = archived;
+    if (archived) this.releaseThreadOwnership(threadId);
+    this.projection.touch(threadId);
+    if (!this.archiveChanges.has(threadId)) this.publishThread(threadId);
+  }
+  async getThreadMetadata(threadId) {
+    const cached = this.projection.get(threadId);
+    if (cached) {
+      this.projects.assertOwnership(cached.projectId, cached.cwd);
+      if (this.codex.ready) await this.refreshThreadMetadata(threadId);
+      this.projects.assertOwnership(cached.projectId, cached.cwd);
+      return { ...this.threadView(cached), turns: [], actions: [] };
+    }
+    const metadata = this.threadView(this.normalize(await this.codex.readThreadMetadata(threadId)));
+    return { ...metadata, turns: [], actions: [] };
+  }
+  async getThread(threadId) {
+    const cached = this.projection.get(threadId);
+    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);
+    return this.threadView(thread);
+  }
+  async exportThread(threadId) {
+    this.ensureReady();
+    const epoch = this.codex.epoch;
+    const revision = this.projection.revision(threadId);
+    const thread = await this.codex.readThread(threadId);
+    const latest = await this.codex.readThreadMetadata(threadId);
+    this.ensureReady();
+    if (this.codex.epoch !== epoch)
+      throw new AppError("EXPORT_RUNTIME_CHANGED", "\u8BFB\u53D6\u671F\u95F4 Codex \u5DF2\u91CD\u542F\uFF0C\u8BF7\u91CD\u65B0\u5BFC\u51FA\u3002", 409);
+    if (thread.id !== threadId || latest.id !== threadId || thread.historyTruncated)
+      throw new AppError(
+        "EXPORT_HISTORY_INCOMPLETE",
+        "\u672A\u80FD\u53D6\u5F97\u5B8C\u6574\u4F1A\u8BDD\u5386\u53F2\uFF0C\u672A\u751F\u6210\u5BFC\u51FA\u6587\u4EF6\u3002",
+        409
+      );
+    const link = this.store.getThreadLink(threadId);
+    if (link) this.projects.assertOwnership(link.projectId, thread.cwd);
+    else this.projects.findOwner(thread.cwd);
+    return renderThreadExport(thread, {
+      executionUncertain: Boolean(this.store.activeForThread(threadId)),
+      historyChanged: revision !== this.projection.revision(threadId) || thread.updatedAt !== latest.updatedAt || thread.status !== latest.status
+    });
+  }
+  getThreadImage(threadId, path) {
+    return this.readThreadFile(threadId, path, readLocalImage);
+  }
+  getThreadMarkdown(threadId, path) {
+    return this.readThreadFile(threadId, path, readLocalMarkdown);
+  }
+  async readThreadFile(threadId, path, read) {
+    let link = this.store.getThreadLink(threadId);
+    if (!link) {
+      this.normalize(await this.codex.readThreadMetadata(threadId));
+      link = this.store.getThreadLink(threadId);
+    }
+    const { project, cwd } = this.projects.assertOwnership(link.projectId, link.cwd);
+    const file = await read(path, {
+      cwd,
+      roots: [
+        { canonicalRoot: project.canonicalRoot, aliases: [project.rootPath] },
+        ...this.fileTemporaryRoots
+      ]
+    });
+    this.projects.assertOwnership(link.projectId, link.cwd);
+    return file;
+  }
+  async loadThread(threadId) {
+    const cached = this.projection.get(threadId);
+    if (cached) {
+      this.projects.assertOwnership(cached.projectId, cached.cwd);
+      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);
+    }
+    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 current = this.projection.get(threadId);
+      const preserveCurrent = current && (cached === void 0 || this.projection.revision(threadId) !== revision);
+      const result = preserveCurrent ? current : this.projection.thread(thread);
+      this.applyRecoveredMarker(result);
+      if (!preserveCurrent) {
+        for (const turn of result.turns)
+          if (isTerminal(turn.status)) this.projection.expireTurn(threadId, turn.id);
+      }
+      if (cached !== void 0 && !preserveCurrent) this.publishThread(threadId);
+      return result;
+    })();
+    this.reads.set(threadId, loading);
+    try {
+      return this.threadView(await loading);
+    } finally {
+      this.reads.delete(threadId);
+    }
+  }
+  async createThread(projectId, input) {
+    return this.perform("thread.create", projectId, input, async () => {
+      const project = this.projects.get(projectId);
+      this.ensureReady();
+      this.ensureCompatibilityConfirmed();
+      this.store.associateProject(input.clientOperationId, projectId);
+      this.store.dispatch(input.clientOperationId);
+      this.pendingThreadCreations.set(input.clientOperationId, project.canonicalRoot);
+      const epoch = this.codex.epoch;
+      const settingsSequence = this.runtimeSettingsSequence;
+      const thread = await this.codex.createThread(project.canonicalRoot, 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");
+      const normalized = this.normalize(thread, projectId, true);
+      this.projection.thread(
+        normalized,
+        this.projection.get(thread.id) !== void 0,
+        (this.runtimeSettingsUpdates.get(thread.id) ?? 0) > settingsSequence
+      );
+      this.publishThread(thread.id);
+      return { result: { threadId: thread.id } };
+    });
+  }
+  async resumeThread(threadId, input) {
+    return this.perform("thread.resume", threadId, input, async () => {
+      const thread = await this.loadThread(threadId);
+      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.store.associateProject(input.clientOperationId, thread.projectId);
+      const link = this.store.getThreadLink(threadId);
+      if (link?.managedEpoch === this.codex.epoch) {
+        this.ensureCompatibilityConfirmed();
+        this.store.dispatch(input.clientOperationId);
+        return { result: { threadId } };
+      }
+      const marker = this.store.activeForThread(threadId);
+      if (marker)
+        throw new AppError("RESULT_UNKNOWN", "\u65E7\u6267\u884C\u4ECD\u5F85\u6838\u5BF9\uFF0C\u8BF7\u5148\u68C0\u67E5\u5386\u53F2\u5E76\u6838\u5BF9\u65E7\u64CD\u4F5C", 409, {
+          operationId: marker.operationId,
+          threadId
+        });
+      const ownership = this.projects.assertOwnership(thread.projectId, thread.cwd);
+      this.ensureCompatibilityConfirmed();
+      this.store.dispatch(input.clientOperationId);
+      let pending = this.resumes.get(threadId);
+      if (!pending) {
+        const epoch = this.codex.epoch;
+        const revision = this.projection.revision(threadId);
+        const settingsSequence = this.runtimeSettingsSequence;
+        const current = this.projection.get(threadId);
+        delete current.resumeError;
+        pending = (async () => {
+          try {
+            const resumed = await this.codex.resumeThread(threadId, ownership.cwd, input.settings);
+            if (this.codex.epoch !== epoch || !this.codex.ready)
+              throw new Error("\u6062\u590D\u8BF7\u6C42\u5DF2\u53D1\u9001\uFF0C\u4F46 Codex \u5B9E\u4F8B\u5DF2\u53D8\u5316\uFF0C\u8BF7\u6838\u5BF9\u63D0\u4EA4");
+            this.projection.thread(
+              this.normalize(resumed, thread.projectId, true),
+              this.projection.revision(threadId) !== revision,
+              (this.runtimeSettingsUpdates.get(threadId) ?? 0) > settingsSequence
+            );
+            this.publishThread(threadId);
+          } catch (error) {
+            if (this.codex.epoch === epoch && this.codex.ready && error instanceof AppError && !("uncertain" in error && error.uncertain)) {
+              current.resumeError = error.toJSON();
+              this.projection.touch(threadId);
+              this.publishThread(threadId);
+            }
+            throw error;
+          }
+        })();
+        this.resumes.set(threadId, pending);
+      }
+      try {
+        await pending;
+      } finally {
+        if (this.resumes.get(threadId) === pending) this.resumes.delete(threadId);
+      }
+      return { result: { threadId } };
+    });
+  }
+  async forkThread(threadId, input) {
+    return this.perform("thread.fork", threadId, input, async () => {
+      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);
+      this.ensureCompatibilityConfirmed();
+      const epoch = this.codex.epoch;
+      this.store.associateProject(input.clientOperationId, ownership.project.id);
+      this.store.dispatch(input.clientOperationId);
+      this.pendingThreadCreations.set(input.clientOperationId, ownership.cwd);
+      const settingsSequence = this.runtimeSettingsSequence;
+      const forked = await this.codex.forkThread(threadId, ownership.cwd, 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 {
+        normalized = this.normalize(
+          { ...forked, forkedFromId: threadId },
+          ownership.project.id,
+          true
+        );
+      } catch (error) {
+        throw new Error("\u5206\u53C9\u8BF7\u6C42\u5DF2\u53D1\u9001\uFF0C\u4F46\u8FD4\u56DE\u7684\u4F1A\u8BDD\u76EE\u5F55\u65E0\u6CD5\u786E\u8BA4\uFF0C\u8BF7\u6838\u5BF9\u5386\u53F2", { cause: error });
+      }
+      this.projection.thread(
+        normalized,
+        this.projection.get(forked.id) !== void 0,
+        (this.runtimeSettingsUpdates.get(forked.id) ?? 0) > settingsSequence
+      );
+      this.publishThread(forked.id);
+      return { result: { threadId: forked.id, forkedFromId: threadId } };
+    });
+  }
+  async startTurn(threadId, input) {
+    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);
+      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();
+      this.store.dispatch(input.clientOperationId, {
+        threadId,
+        workspaceKey: ownership.workspaceKey,
+        codexEpoch: this.codex.epoch
+      });
+      this.turnBaselines.set(input.clientOperationId, new Set(thread.turns.map((turn2) => turn2.id)));
+      this.publishThread(threadId);
+      const revision = this.projection.revision(threadId);
+      const turn = await this.codex.startTurn(
+        threadId,
+        ownership.cwd,
+        input.text,
+        input.settings,
+        input.images
+      );
+      this.store.attachTurn(input.clientOperationId, turn.id);
+      this.turnBaselines.delete(input.clientOperationId);
+      this.projection.turn(threadId, turn, this.projection.revision(threadId) !== revision);
+      const projectedTurn = this.projection.get(threadId)?.turns.find((entry) => entry.id === turn.id);
+      if (projectedTurn && isTerminal(projectedTurn.status))
+        this.store.finishTurn(threadId, turn.id, this.codex.epoch);
+      this.publishThread(threadId);
+      return { result: { threadId, turnId: turn.id }, turnId: turn.id };
+    });
+  }
+  async compactThread(threadId, input) {
+    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);
+      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)
+        throw new AppError("EMPTY_THREAD", "\u5F53\u524D\u4F1A\u8BDD\u4E3A\u7A7A\uFF0C\u65E0\u9700\u538B\u7F29\u4E0A\u4E0B\u6587", 409);
+      if (thread.status === "unknown")
+        throw new AppError("RESULT_UNKNOWN", "\u8BF7\u5148\u6838\u5BF9\u5F53\u524D\u4F1A\u8BDD\u7684\u6267\u884C\u72B6\u6001", 409);
+      this.ensureCompatibilityConfirmed();
+      this.store.dispatch(input.clientOperationId, {
+        threadId,
+        workspaceKey: ownership.workspaceKey,
+        codexEpoch: this.codex.epoch
+      });
+      this.turnBaselines.set(input.clientOperationId, new Set(thread.turns.map((turn) => turn.id)));
+      this.publishThread(threadId);
+      await this.codex.compactThread(threadId);
+      this.publishThread(threadId);
+      return { result: { threadId } };
+    });
+  }
+  async startReview(threadId, input) {
+    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);
+      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
+        });
+      if (thread.status === "unknown")
+        throw new AppError("RESULT_UNKNOWN", "\u4F1A\u8BDD\u72B6\u6001\u5C1A\u672A\u786E\u8BA4\uFF0C\u8BF7\u5148\u6838\u5BF9\u63D0\u4EA4", 409, { threadId });
+      this.ensureCompatibilityConfirmed();
+      this.store.dispatch(input.clientOperationId, {
+        threadId,
+        workspaceKey: ownership.workspaceKey,
+        codexEpoch: this.codex.epoch
+      });
+      const revision = this.projection.revision(threadId);
+      this.turnBaselines.set(input.clientOperationId, new Set(thread.turns.map((turn2) => turn2.id)));
+      const turn = await this.codex.startReview(threadId);
+      this.store.attachTurn(input.clientOperationId, turn.id);
+      this.turnBaselines.delete(input.clientOperationId);
+      this.projection.turn(threadId, turn, this.projection.revision(threadId) !== revision);
+      const projectedTurn = this.projection.get(threadId)?.turns.find((entry) => entry.id === turn.id);
+      if (projectedTurn && isTerminal(projectedTurn.status))
+        this.store.finishTurn(threadId, turn.id, this.codex.epoch);
+      this.publishThread(threadId);
+      return { result: { threadId, turnId: turn.id }, turnId: turn.id };
+    });
+  }
+  async steer(threadId, input) {
+    return this.perform("turn.steer", threadId, input, async () => {
+      await this.requireActiveTurn(threadId, input.expectedTurnId);
+      this.ensureCompatibilityConfirmed();
+      this.store.dispatch(input.clientOperationId);
+      const result = await this.codex.steerTurn(
+        threadId,
+        input.expectedTurnId,
+        input.text,
+        input.images
+      );
+      return { result: { threadId, turnId: result.turnId } };
+    });
+  }
+  async interrupt(threadId, input) {
+    return this.perform("turn.interrupt", threadId, input, async () => {
+      await this.requireActiveTurn(threadId, input.expectedTurnId);
+      this.store.dispatch(input.clientOperationId);
+      await this.codex.interruptTurn(threadId, input.expectedTurnId);
+      return { result: { threadId, turnId: input.expectedTurnId } };
+    });
+  }
+  async resolveAction(actionId, input) {
+    return this.perform("action.resolve", actionId, input, async () => {
+      this.ensureReady();
+      let action = this.projection.actions.get(actionId);
+      if (!action || action.codexEpoch !== this.codex.epoch || action.status === "expired")
+        throw new AppError("ACTION_EXPIRED", "\u8BE5\u4EBA\u5DE5\u8BF7\u6C42\u5DF2\u5931\u6548", 409);
+      if (action.status !== "pending")
+        throw new AppError("ACTION_CONFLICT", "\u8BE5\u4EBA\u5DE5\u8BF7\u6C42\u5DF2\u7531\u53E6\u4E00\u6B21\u63D0\u4EA4\u5904\u7406", 409);
+      if (action.threadId) await this.loadThread(action.threadId);
+      action = this.projection.actions.get(actionId);
+      if (!action || action.status === "expired" || action.codexEpoch !== this.codex.epoch)
+        throw new AppError("ACTION_EXPIRED", "\u8BE5\u4EBA\u5DE5\u8BF7\u6C42\u5DF2\u5931\u6548", 409);
+      if (action.status !== "pending")
+        throw new AppError("ACTION_CONFLICT", "\u8BE5\u4EBA\u5DE5\u8BF7\u6C42\u5DF2\u88AB\u5904\u7406", 409);
+      this.validateResolution(action, input);
+      this.ensureCompatibilityConfirmed();
+      this.store.dispatch(input.clientOperationId);
+      this.projection.resolveAction(actionId, "responding");
+      if (action.threadId) this.publishThread(action.threadId);
+      await this.codex.respond(actionId, input.resolution);
+      return { result: { actionId } };
+    });
+  }
+  getOperation(id) {
+    const row = this.store.get(id);
+    if (!row) throw new AppError("OPERATION_NOT_FOUND", "\u672A\u627E\u5230\u8BE5\u64CD\u4F5C", 404);
+    return this.operation(row);
+  }
+  async reconcileOperation(targetOperationId, input) {
+    return this.perform("operation.reconcile", targetOperationId, input, async () => {
+      if (!input.confirmEnded)
+        throw new AppError("CONFIRMATION_REQUIRED", "\u5FC5\u987B\u786E\u8BA4\u5BF9\u5E94\u65E7\u8FD0\u884C\u5DF2\u7ECF\u7ED3\u675F", 400);
+      const target = this.store.get(targetOperationId);
+      if (!target) throw new AppError("OPERATION_NOT_FOUND", "\u5F85\u6838\u5BF9\u64CD\u4F5C\u4E0D\u5B58\u5728", 404);
+      if (this.inFlightOperations.has(targetOperationId))
+        throw new AppError("OPERATION_BUSY", "\u64CD\u4F5C\u4ECD\u5728\u5904\u7406\u4E2D\uFF0C\u8BF7\u7B49\u5F85\u8FD4\u56DE\u540E\u518D\u6838\u5BF9", 409);
+      const marker = this.store.marker(targetOperationId);
+      if (!marker || marker.endedAt !== null) {
+        this.store.dispatch(input.clientOperationId);
+        this.store.reconcile(targetOperationId, input.clientOperationId);
+        return { result: this.store.get(input.clientOperationId)?.result };
+      }
+      const cached = this.projection.get(marker.threadId);
+      if (marker.codexEpoch === this.codex.epoch && cached && this.markerIsActive(cached, marker.turnId))
+        throw new AppError("THREAD_BUSY", "\u53D7\u7BA1\u4EFB\u52A1\u4ECD\u5728\u6267\u884C\uFF0C\u8BF7\u5148\u6B63\u5E38\u4E2D\u65AD", 409, {
+          threadId: marker.threadId
+        });
+      if (this.codex.ready) {
+        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 (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
+            });
+        } catch (error) {
+          if (error instanceof AppError && ["THREAD_BUSY", "PROJECT_OWNERSHIP"].includes(error.code))
+            throw error;
+        }
+      }
+      const latest = this.projection.get(marker.threadId);
+      if (marker.codexEpoch === this.codex.epoch && latest && this.markerIsActive(latest, marker.turnId))
+        throw new AppError("THREAD_BUSY", "\u53D7\u7BA1\u4EFB\u52A1\u4ECD\u5728\u6267\u884C\uFF0C\u8BF7\u5148\u6B63\u5E38\u4E2D\u65AD", 409);
+      this.store.dispatch(input.clientOperationId);
+      this.store.reconcile(targetOperationId, input.clientOperationId);
+      const thread = this.projection.get(marker.threadId);
+      if (thread?.status === "unknown") {
+        thread.status = "idle";
+        this.publishThread(thread.id);
+      }
+      this.events.publish("operation", this.getOperation(targetOperationId), marker.threadId);
+      return { result: this.store.get(input.clientOperationId)?.result };
+    });
+  }
+  async subscribe(threadId, after, listener) {
+    await this.getThread(threadId);
+    return this.events.subscribe(
+      threadId,
+      () => this.threadView(this.projection.get(threadId)),
+      after,
+      listener
+    );
+  }
+  async shutdown() {
+    this.accepting = false;
+    this.store.recover();
+    this.projection.runtimeReset();
+    this.removeListener();
+    await this.codex.stop();
+  }
+  async perform(kind, target, input, work) {
+    if (!this.accepting) throw new AppError("CODEX_UNAVAILABLE", "\u670D\u52A1\u6B63\u5728\u5173\u95ED", 503);
+    if (this.maintenance)
+      throw new AppError("UPDATE_MAINTENANCE", "\u6B63\u5728\u5347\u7EA7\uFF0C\u8BF7\u7B49\u5F85\u670D\u52A1\u91CD\u65B0\u8FDE\u63A5", 503);
+    let accepted;
+    try {
+      accepted = this.store.accept(input.clientOperationId, kind, target, input);
+    } catch (error) {
+      throw this.asAppError(error);
+    }
+    if (!accepted.inserted) return this.operation(accepted.operation);
+    this.inFlightOperations.add(input.clientOperationId);
+    try {
+      const { result, turnId, onAcknowledged } = await work();
+      const operation = this.operation(
+        this.store.acknowledge(input.clientOperationId, result, turnId)
+      );
+      if (operation.status === "acknowledged") onAcknowledged?.();
+      this.events.publish("operation", operation);
+      return operation;
+    } catch (error) {
+      const appError = this.asAppError(error);
+      const state = this.store.get(input.clientOperationId)?.state;
+      const dispatched = state === "dispatching";
+      const uncertain = state === "unknown" || dispatched && (typeof error === "object" && error !== null && "uncertain" in error ? Boolean(error.uncertain) : !(error instanceof AppError));
+      const operation = this.operation(
+        this.store.fail(
+          input.clientOperationId,
+          { ...appError.toJSON(), code: uncertain ? "RESULT_UNKNOWN" : appError.code },
+          uncertain
+        )
+      );
+      if (dispatched && !uncertain && kind === "action.resolve" && this.projection.actions.get(target)?.status === "responding") {
+        const action = this.projection.resolveAction(target, "pending");
+        if (action?.threadId) this.publishThread(action.threadId);
+      }
+      if (dispatched && kind === "turn.start") this.publishThread(target);
+      this.events.publish("operation", operation);
+      if (uncertain)
+        throw new AppError(
+          "RESULT_UNKNOWN",
+          "\u8BF7\u6C42\u53EF\u80FD\u5DF2\u7ECF\u6267\u884C\uFF0C\u7ED3\u679C\u5F85\u6838\u5BF9\uFF1B\u8BF7\u52FF\u81EA\u52A8\u91CD\u65B0\u63D0\u4EA4",
+          409,
+          { clientOperationId: input.clientOperationId }
+        );
+      throw appError;
+    } finally {
+      this.inFlightOperations.delete(input.clientOperationId);
+      this.pendingThreadCreations.delete(input.clientOperationId);
+      if (!this.store.activeForThread(target)) this.turnBaselines.delete(input.clientOperationId);
+      if (kind === "thread.compact") this.publishThread(target);
+    }
+  }
+  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)
+      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,
+      cwd: ownership.cwd,
+      managed: managedEpoch === this.codex.epoch,
+      resumeError: managed ? void 0 : this.projection.get(thread.id)?.resumeError,
+      actions: [...this.projection.actions.values()].filter(
+        (action) => action.threadId === thread.id
+      )
+    };
+    this.store.linkThread({
+      threadId: thread.id,
+      projectId: ownership.project.id,
+      cwd: ownership.cwd,
+      source: thread.source,
+      managedEpoch
+    });
+    this.applyRecoveredMarker(result);
+    return result;
+  }
+  applyRecoveredMarker(thread) {
+    const marker = this.store.activeForThread(thread.id);
+    if (marker?.state === "unknown") {
+      const confirmed = thread.turns.find((entry) => entry.id === marker.turnId);
+      if (confirmed && isTerminal(confirmed.status) && !isActive(thread.status) && !thread.turns.some((entry) => isActive(entry.status))) {
+        this.store.finishTurn(thread.id, confirmed.id, marker.codexEpoch);
+        return;
+      }
+      thread.status = "unknown";
+      const turn = thread.turns.find((entry) => entry.id === marker.turnId);
+      if (turn && !isTerminal(turn.status)) turn.status = "unknown";
+    }
+  }
+  /** Refresh only this thread; missing completion events must not block its next turn. */
+  async refreshExecution(marker) {
+    if (!marker.turnId || !this.codex.ready) return;
+    const existing = this.executionReads.get(marker.operationId);
+    if (existing) return existing;
+    const epoch = this.codex.epoch;
+    const revision = this.projection.revision(marker.threadId);
+    const reading = (async () => {
+      try {
+        const actual = await this.codex.readThread(marker.threadId);
+        const latest = this.store.activeForThread(marker.threadId);
+        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);
+        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") {
+          this.projection.thread(this.normalize(actual));
+          this.publishThread(marker.threadId);
+          return;
+        }
+        if (!turn || !isTerminal(turn.status) || isActive(actual.status) || actual.turns.some((entry) => isActive(entry.status)))
+          return;
+        this.store.finishTurn(marker.threadId, turn.id, marker.codexEpoch);
+        this.projection.thread(this.normalize(actual));
+        this.projection.expireTurn(marker.threadId, turn.id);
+        this.publishThread(marker.threadId);
+        this.events.publish("operation", this.getOperation(marker.operationId), marker.threadId);
+      } catch {
+      }
+    })();
+    this.executionReads.set(marker.operationId, reading);
+    try {
+      return await reading;
+    } finally {
+      this.executionReads.delete(marker.operationId);
+    }
+  }
+  ensureReady() {
+    if (!this.codex.ready)
+      throw new AppError("CODEX_UNAVAILABLE", "Codex \u5C1A\u672A\u5C31\u7EEA\uFF0C\u8BF7\u67E5\u770B\u8FD0\u884C\u72B6\u6001", 503);
+  }
+  compatibilityFingerprint(diagnostics) {
+    return JSON.stringify([
+      diagnostics.codexEpoch,
+      diagnostics.codexVersion,
+      diagnostics.verifiedVersion
+    ]);
+  }
+  compatibilityConfirmation(diagnostics) {
+    const fingerprint = this.compatibilityFingerprint(diagnostics);
+    if (!this.codex.ready || !diagnostics.ready || diagnostics.compatibility !== "unverified" || !diagnostics.codexVersion || this.confirmedCompatibility !== fingerprint)
+      this.confirmedCompatibility = void 0;
+    if (diagnostics.compatibility !== "unverified") return "not-required";
+    return this.confirmedCompatibility === fingerprint ? "confirmed" : "required";
+  }
+  ensureCompatibilityAvailable(diagnostics) {
+    this.compatibilityConfirmation(diagnostics);
+    this.ensureReady();
+    if (!diagnostics.ready || diagnostics.compatibility === "unavailable" || !diagnostics.codexVersion)
+      throw new AppError("CODEX_UNAVAILABLE", "Codex \u4E0D\u53EF\u7528\u6216\u65E0\u6CD5\u8BC6\u522B\u8FD0\u884C\u7248\u672C\uFF0C\u8BF7\u5148\u68C0\u67E5\u8BCA\u65AD", 503);
+  }
+  ensureCompatibilityConfirmed() {
+    const diagnostics = this.codex.diagnostics();
+    this.ensureCompatibilityAvailable(diagnostics);
+    if (this.compatibilityConfirmation(diagnostics) === "required")
+      throw new AppError(
+        "COMPATIBILITY_CONFIRMATION_REQUIRED",
+        "\u5F53\u524D Codex \u7248\u672C\u5C1A\u672A\u9A8C\u8BC1\uFF0C\u8BF7\u5148\u786E\u8BA4\u7EE7\u7EED\u4F7F\u7528\u6B64\u7248\u672C",
+        409
+      );
+  }
+  ensureManaged(thread) {
+    this.ensureReady();
+    this.ensureArchiveAvailable(thread);
+    if (thread.archived) throw new AppError("THREAD_ARCHIVED", "\u8BF7\u5148\u53D6\u6D88\u5F52\u6863\u540E\u518D\u7EE7\u7EED\u5BF9\u8BDD", 409);
+    if (!thread.managed || this.store.getThreadLink(thread.id)?.managedEpoch !== this.codex.epoch)
+      throw new AppError("THREAD_NOT_RESUMED", "\u4F1A\u8BDD\u5C1A\u672A\u6062\u590D\uFF0C\u8BF7\u91CD\u8BD5\u6062\u590D\u540E\u7EE7\u7EED", 409);
+  }
+  async requireActiveTurn(threadId, expectedTurnId) {
+    const thread = await this.loadThread(threadId);
+    this.ensureManaged(thread);
+    const turn = thread.turns.find((entry) => entry.id === expectedTurnId);
+    const marker = this.store.activeForThread(threadId);
+    if (!turn || !isActive(turn.status) || !marker || marker.turnId !== expectedTurnId || marker.codexEpoch !== this.codex.epoch)
+      throw new AppError("TURN_CONFLICT", "\u76EE\u6807\u4EFB\u52A1\u5DF2\u6539\u53D8\u6216\u4E0D\u518D\u6D3B\u52A8\uFF0C\u8BF7\u5237\u65B0\u72B6\u6001", 409);
+  }
+  markerIsActive(thread, turnId) {
+    if (turnId) return thread.turns.some((turn) => turn.id === turnId && isActive(turn.status));
+    return isActive(thread.status) || thread.turns.some((turn) => isActive(turn.status));
+  }
+  validateResolution(action, input) {
+    const resolution = input.resolution;
+    if (action.kind === "permissions") {
+      validatePermissionResolution(resolution);
+    } else if (action.kind === "elicitation") {
+      validateElicitationResolution(action.elicitation, resolution);
+    } else if (action.kind === "questions") {
+      if (!("answers" in resolution)) throw new AppError("VALIDATION_ERROR", "\u8BF7\u6309\u95EE\u9898\u63D0\u4EA4\u7B54\u6848");
+      const questions = action.questions ?? [];
+      if (Object.keys(resolution.answers).some(
+        (id) => !questions.some((question) => question.id === id)
+      ))
+        throw new AppError("VALIDATION_ERROR", "\u56DE\u7B54\u5305\u542B\u672A\u77E5\u95EE\u9898");
+      for (const question of questions) {
+        const answers = resolution.answers[question.id];
+        if (!answers?.length || answers.some(
+          (answer) => !answer.trim() || !question.isOther && question.options.length > 0 && !question.options.some((option) => option.label === answer)
+        ))
+          throw new AppError("VALIDATION_ERROR", `\u95EE\u9898 ${question.header} \u7684\u56DE\u7B54\u4E0D\u7B26\u5408\u9009\u9879\u8981\u6C42`);
+      }
+    } else if (!("decision" in resolution) || "content" in resolution || "persist" in resolution || !action.options.some((option) => option.id === resolution.decision))
+      throw new AppError("VALIDATION_ERROR", "\u8BF7\u9009\u62E9\u4E0A\u6E38\u63D0\u4F9B\u7684\u5408\u6CD5\u9009\u9879");
+  }
+  operation(row) {
+    const marker = this.store.marker(row.clientOperationId);
+    return {
+      clientOperationId: row.clientOperationId,
+      kind: row.kind,
+      target: row.target,
+      status: row.state,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+      ...row.result === null ? {} : { result: row.result },
+      ...row.error === null ? {} : { error: { ...row.error, clientOperationId: row.clientOperationId } },
+      ...marker ? {
+        execution: {
+          operationId: marker.operationId,
+          threadId: marker.threadId,
+          ...marker.turnId === null ? {} : { turnId: marker.turnId },
+          workspaceKey: marker.workspaceKey,
+          codexEpoch: marker.codexEpoch,
+          ended: marker.endedAt !== null
+        }
+      } : {},
+      ...row.reconciledAt ? {
+        reconciliation: {
+          at: row.reconciledAt,
+          decision: row.reconciliationDecision ?? "confirmed-ended"
+        }
+      } : {}
+    };
+  }
+  asAppError(error) {
+    if (error instanceof AppError) return error;
+    if (error instanceof StoreConflict)
+      return new AppError(
+        error.code,
+        error.message,
+        409,
+        error.threadId ? { threadId: error.threadId } : void 0
+      );
+    return new AppError("INTERNAL_ERROR", error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF", 500);
+  }
+  publishThread(threadId) {
+    const thread = this.projection.get(threadId);
+    if (!thread) return;
+    const view = this.threadView(thread);
+    this.events.publish("thread", view, threadId);
+    const summary = toThreadSummary(view);
+    const encoded = JSON.stringify(summary);
+    if (this.summaries.get(threadId) === encoded) return;
+    try {
+      this.projects.assertOwnership(thread.projectId, thread.cwd);
+    } catch {
+      return;
+    }
+    this.summaries.set(threadId, encoded);
+    this.events.publishSummary(summary);
+  }
+  historyVisible(thread) {
+    return Boolean(
+      thread.hasMessages || thread.archived || thread.turns.length || this.store.activeForThread(thread.id) || isActive(thread.status) || thread.actions.some((action) => ["pending", "responding"].includes(action.status))
+    );
+  }
+  threadView(thread) {
+    const result = structuredClone(thread);
+    result.archived = thread.archived ?? false;
+    result.historyVisible = this.historyVisible(thread);
+    const marker = this.store.activeForThread(thread.id);
+    delete result.execution;
+    if (marker)
+      result.execution = {
+        operationId: marker.operationId,
+        threadId: marker.threadId,
+        ...marker.turnId === null ? {} : { turnId: marker.turnId },
+        workspaceKey: marker.workspaceKey,
+        codexEpoch: marker.codexEpoch,
+        ended: false
+      };
+    return result;
+  }
+  beginTitleRead(threadId) {
+    const sequence = ++this.titleReadSequence;
+    this.titleReads.set(threadId, sequence);
+    return sequence;
+  }
+  updateThreadTitle(threadId, title, sequence) {
+    const thread = this.projection.get(threadId);
+    if (!thread || this.titleReads.get(threadId) !== sequence || thread.title === title) return;
+    thread.title = title;
+    this.projection.touch(threadId);
+    this.publishThread(threadId);
+  }
+  async refreshThreadMetadata(threadId) {
+    const sequence = this.beginTitleRead(threadId);
+    const revision = this.projection.revision(threadId);
+    try {
+      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);
+      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;
+        this.projection.touch(threadId);
+        this.publishThread(threadId);
+      }
+      if (this.titleReads.get(threadId) === sequence)
+        this.updateArchiveState(threadId, Boolean(thread.archived));
+      this.updateThreadTitle(threadId, thread.title, sequence);
+    } catch {
+    }
+  }
+  consume(event) {
+    if (event.type === "runtime") {
+      this.compatibilityConfirmation(event.diagnostics);
+      if (!event.diagnostics.ready || event.diagnostics.codexEpoch !== this.currentEpoch) {
+        this.currentEpoch = event.diagnostics.codexEpoch;
+        this.titleReads.clear();
+        this.runtimeSettingsUpdates.clear();
+        this.turnBaselines.clear();
+        this.resumes.clear();
+        this.store.recover();
+        this.projection.runtimeReset();
+        for (const thread2 of this.projection.values()) this.publishThread(thread2.id);
+      }
+      this.events.publish("runtime", this.getSystem());
+      return;
+    }
+    if (event.type === "thread") {
+      try {
+        if (!this.store.getThreadLink(event.thread.id) && [...this.pendingThreadCreations.values()].includes(realpathSync(event.thread.cwd)))
+          return;
+        this.projection.thread(this.normalize(event.thread), true);
+        this.publishThread(event.thread.id);
+      } catch {
+      }
+      return;
+    }
+    if (event.type === "threadArchive") {
+      this.beginTitleRead(event.threadId);
+      this.updateArchiveState(event.threadId, event.archived);
+      return;
+    }
+    if (event.type === "action") {
+      const action = event.action;
+      if (action.codexEpoch !== this.codex.epoch) return;
+      this.projection.action(action);
+      if (action.threadId) this.publishThread(action.threadId);
+      return;
+    }
+    if (event.type === "actionResolved") {
+      const action = this.projection.resolveAction(event.actionId, "responded");
+      if (action?.threadId) this.publishThread(action.threadId);
+      return;
+    }
+    if (event.type === "autoReview") {
+      if (this.projection.autoReview(event.threadId, event.turnId, event.review))
+        this.publishThread(event.threadId);
+      return;
+    }
+    const thread = this.projection.get(event.threadId);
+    if (!thread) return;
+    if (event.type === "compactionCompleted") {
+      if (this.projection.compactionCompleted(thread.id, event.turnId))
+        this.publishThread(thread.id);
+      return;
+    }
+    if (event.type === "turnError" || event.type === "turnProgress") {
+      const changed = event.type === "turnError" ? this.projection.turnError(thread.id, event.turnId, event.message, event.willRetry) : this.projection.turnProgress(thread.id, event.turnId);
+      if (changed) this.publishThread(thread.id);
+      return;
+    }
+    if (event.type === "threadName") {
+      this.projection.touch(thread.id);
+      if (event.name) this.updateThreadTitle(thread.id, event.name, this.beginTitleRead(thread.id));
+      else void this.refreshThreadMetadata(thread.id);
+      return;
+    }
+    if (event.type === "threadSettings") {
+      this.runtimeSettingsUpdates.set(thread.id, ++this.runtimeSettingsSequence);
+      thread.runtimeSettings = event.settings;
+      this.projection.touch(thread.id);
+    } else if (event.type === "threadStatus") {
+      if (!isActive(event.status)) this.projection.endThreadCompactions(thread.id);
+      if (this.store.activeForThread(thread.id)?.state !== "unknown") thread.status = event.status;
+      this.projection.touch(thread.id);
+    } else if (event.type === "turn") {
+      const previous = thread.turns.find((turn) => turn.id === event.turn.id);
+      const newCompletion = !previous || !isTerminal(previous.status);
+      if (isTerminal(event.turn.status)) this.turnUsage.save(thread.id, event.turn);
+      this.projection.turn(thread.id, event.turn);
+      void this.refreshThreadMetadata(thread.id);
+      const marker = this.store.activeForThread(thread.id);
+      if (marker?.codexEpoch === this.codex.epoch && marker.turnId === null && // A cancellation event from an existing turn cannot identify newly
+      // dispatched work, even when its first notification/receipt is delayed.
+      this.turnBaselines.get(marker.operationId)?.has(event.turn.id) === false) {
+        this.store.attachTurn(marker.operationId, event.turn.id);
+        this.turnBaselines.delete(marker.operationId);
+      }
+      if (isTerminal(event.turn.status)) {
+        this.store.finishTurn(thread.id, event.turn.id, this.codex.epoch);
+        this.projection.expireTurn(thread.id, event.turn.id);
+        if (newCompletion) {
+          try {
+            this.projects.assertOwnership(thread.projectId, thread.cwd);
+            this.events.publishCompletion({
+              threadId: thread.id,
+              turnId: event.turn.id,
+              projectId: thread.projectId,
+              title: thread.title,
+              status: event.turn.status
+            });
+          } catch {
+          }
+        }
+      }
+    } else if (event.type === "item") this.projection.item(thread.id, event.turnId, event.item);
+    else if (event.type === "delta")
+      this.projection.delta(
+        thread.id,
+        event.turnId,
+        event.itemId,
+        event.field,
+        event.delta,
+        event.itemType
+      );
+    else if (event.type === "diff") {
+      this.projection.diff(thread.id, event.turnId, event.diff);
+    }
+    this.publishThread(thread.id);
+  }
+}
+export {
+  GatewayService
+};
+//# sourceMappingURL=service.js.map