@covro/covro 0.5.1-dev.2 → 0.5.1-dev.4

package/dist/server/service.js

@@ -1,6 +1,12 @@
+import { CapacityRetries } from "./capacity-retry.js";
+import { isModelCapacityError } from "../shared/turn-errors.js";
+import { randomUUID } from "node:crypto";
 import { attentionKey, pendingAttention } from "../shared/thread-attention.js";
 import { ShellService } from "./shell.js";
+import { assertProjectInstructionsMissing, PROJECT_INIT_PROMPT } from "./project-init.js";
+import { recapInput } from "./thread-recap.js";
 import { readGithubRepository } from "./github-repository.js";
+import { readWorkspaceDiff } from "./workspace-diff.js";
 import { realpathSync } from "node:fs";
 import { cp } from "node:fs/promises";
 import { WorkspaceRegistry } from "./workspaces.js";
@@ -13,6 +19,7 @@ import {
 } from "../shared/elicitation.js";
 import { toThreadSummary } from "../shared/thread-summary.js";
 import {
+  requestDigest,
   StoreConflict
 } from "./db/operations.js";
 import { EventHub } from "./events.js";
@@ -49,11 +56,16 @@ class GatewayService {
     this.shell = new ShellService(this.codex);
     this.events = new EventHub(options.limits?.eventBytes);
     this.projection = new Projection(options.limits?.itemBytes);
+    this.capacityRetries = new CapacityRetries(
+      (job) => this.dispatchCapacityRetry(job),
+      (id) => this.publishThread(id)
+    );
     this.currentEpoch = this.codex.epoch;
     this.store.recover();
     this.removeListener = this.codex.onEvent((event) => this.consume(event));
   }
   options;
+  capacityRetries;
   projectClones;
   shell;
   events;
@@ -74,6 +86,7 @@ class GatewayService {
   archiveRevisions = /* @__PURE__ */ new Map();
   turnBaselines = /* @__PURE__ */ new Map();
   renameChanges = /* @__PURE__ */ new Set();
+  goalWrites = /* @__PURE__ */ new Set();
   reads = /* @__PURE__ */ new Map();
   resumes = /* @__PURE__ */ new Map();
   executionReads = /* @__PURE__ */ new Map();
@@ -86,6 +99,7 @@ class GatewayService {
   runtimeSettingsUpdates = /* @__PURE__ */ new Map();
   inFlightOperations = /* @__PURE__ */ new Set();
   pendingThreadCreations = /* @__PURE__ */ new Map();
+  capacityLinks = /* @__PURE__ */ new Map();
   listProjects() {
     return this.projects.list();
   }
@@ -95,6 +109,29 @@ class GatewayService {
     this.projects.get(projectId);
     return { url };
   }
+  async getProjectDiff(projectId) {
+    const project = this.projects.get(projectId);
+    const result = await readWorkspaceDiff(
+      project.canonicalRoot,
+      this.workspaces.allocations().map((row) => row.canonicalRoot)
+    );
+    this.projects.get(projectId);
+    return result;
+  }
+  async getThreadDiff(threadId) {
+    let link = this.store.getThreadLink(threadId);
+    if (!link) {
+      this.normalize(await this.codex.readThreadMetadata(threadId));
+      link = this.store.getThreadLink(threadId);
+    }
+    const { cwd } = this.workspaces.assertOwnership(link.projectId, link.cwd, threadId);
+    const result = await readWorkspaceDiff(
+      cwd,
+      this.workspaces.allocations().filter((row) => row.threadId !== threadId).map((row) => row.canonicalRoot)
+    );
+    this.workspaces.assertOwnership(link.projectId, link.cwd, threadId);
+    return result;
+  }
   async getThreadGithubRepository(threadId) {
     let link = this.store.getThreadLink(threadId);
     if (!link) {
@@ -132,6 +169,8 @@ class GatewayService {
     return this.maintenanceReason === "backup" ? new AppError("BACKUP_MAINTENANCE", "\u6B63\u5728\u5907\u4EFD\uFF0C\u8BF7\u5B8C\u6210\u540E\u91CD\u8BD5\u3002", 503) : new AppError("UPDATE_MAINTENANCE", "\u6B63\u5728\u5347\u7EA7\uFF0C\u8BF7\u7B49\u5F85\u670D\u52A1\u91CD\u65B0\u8FDE\u63A5", 503);
   }
   prepareUpdate(reason = "update") {
+    if (this.capacityRetries.active())
+      return { ready: false, reason: "\u7B49\u5F85\u6A21\u578B\u5BB9\u91CF\u91CD\u8BD5\u7ED3\u675F\u6216\u53D6\u6D88" };
     if (this.projectClones.hasActive) return { ready: false, reason: "\u7B49\u5F85\u9879\u76EE\u514B\u9686\u5B8C\u6210\u6216\u53D6\u6D88" };
     if (this.shell.active()) return { ready: false, reason: "\u7B49\u5F85 Shell \u547D\u4EE4\u7ED3\u675F" };
     if (this.inFlightOperations.size || this.resumes.size || this.pendingThreadCreations.size)
@@ -179,7 +218,7 @@ class GatewayService {
       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)))
+      (thread) => thread.projectId === projectId && (isActive(thread.status) || this.capacityRetries.pending(thread.id) || thread.actions.some((action) => ["pending", "responding"].includes(action.status)))
     );
     if (pending || marker || active || this.shell.active(projectId))
       throw new AppError(
@@ -453,21 +492,34 @@ class GatewayService {
   updateArchiveState(threadId, archived) {
     const thread = this.projection.get(threadId);
     if (!thread || Boolean(thread.archived) === archived) return;
+    if (archived) this.capacityRetries.clear(threadId);
     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);
   }
+  async refreshGoal(thread) {
+    if (thread.goal !== void 0 || !this.codex.ready || !this.codex.getGoal) return;
+    try {
+      const goal = await this.codex.getGoal(thread.id);
+      this.workspaces.assertOwnership(thread.projectId, thread.cwd, thread.id);
+      if (thread.goal === void 0) thread.goal = goal;
+    } catch {
+    }
+  }
   async getThreadMetadata(threadId) {
     const cached = this.projection.get(threadId);
     if (cached) {
       this.workspaces.assertOwnership(cached.projectId, cached.cwd, cached.id);
       if (this.codex.ready) await this.refreshThreadMetadata(threadId);
       this.workspaces.assertOwnership(cached.projectId, cached.cwd, cached.id);
+      await this.refreshGoal(cached);
       return { ...this.threadView(cached), turns: [], actions: [] };
     }
     const metadata = this.threadView(this.normalize(await this.codex.readThreadMetadata(threadId)));
+    await this.refreshGoal(metadata);
+    metadata.historyVisible = this.historyVisible(metadata);
     return { ...metadata, turns: [], actions: [] };
   }
   async getThread(threadId) {
@@ -476,6 +528,7 @@ class GatewayService {
     if (cached && this.codex.ready) await this.refreshThreadMetadata(threadId);
     const thread = this.projection.get(threadId);
     this.workspaces.assertOwnership(thread.projectId, thread.cwd, thread.id);
+    await this.refreshGoal(thread);
     return this.threadView(thread);
   }
   getThreadAttention(threadId) {
@@ -494,6 +547,11 @@ class GatewayService {
       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);
+    const links = this.retryLinks(threadId);
+    for (const turn of page.turns) {
+      const root = links.get(turn.id);
+      if (root) turn.retryOf = root;
+    }
     return page;
   }
   async exportThread(threadId) {
@@ -620,6 +678,7 @@ class GatewayService {
   }
   async resumeThread(threadId, input) {
     return this.perform("thread.resume", threadId, input, async () => {
+      this.capacityRetries.clear(threadId);
       const thread = await this.loadThread(threadId);
       this.ensureReady();
       this.ensureArchiveAvailable(thread);
@@ -721,40 +780,218 @@ class GatewayService {
     });
   }
   async startTurn(threadId, input) {
+    return this.dispatchTurn(threadId, input);
+  }
+  async dispatchTurn(threadId, input, retry, expectedTurnId) {
     return this.perform("turn.start", threadId, input, async () => {
+      if (!retry && !expectedTurnId && this.capacityRetries.view(threadId)?.status === "waiting")
+        this.capacityRetries.clear(threadId);
       const thread = await this.loadThread(threadId);
       this.ensureManaged(thread);
       const ownership = this.workspaces.assertOwnership(thread.projectId, thread.cwd, thread.id);
-      if (isActive(thread.status))
+      if (expectedTurnId) {
+        const last = thread.turns.at(-1);
+        if (last?.id !== expectedTurnId || last.status !== "failed" || !isModelCapacityError(last.error ?? "", last.errorCode))
+          throw new AppError("TURN_CONFLICT", "\u76EE\u6807\u5BB9\u91CF\u5931\u8D25\u5DF2\u6539\u53D8\uFF0C\u8BF7\u5237\u65B0\u540E\u7EE7\u7EED", 409);
+      }
+      if (isActive(this.projection.get(threadId)?.status ?? 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();
+      if (input.taskKind === "init") await assertProjectInstructionsMissing(ownership.cwd);
       this.store.dispatch(input.clientOperationId, {
         threadId,
         workspaceKey: ownership.workspaceKey,
         codexEpoch: this.codex.epoch
       });
+      if (retry && !this.capacityRetries.owns(retry))
+        throw new AppError("TURN_CONFLICT", "\u5BB9\u91CF\u91CD\u8BD5\u5DF2\u53D6\u6D88\u6216\u88AB\u66FF\u4EE3", 409);
+      const candidate = retry ?? this.capacityRetries.begin(
+        threadId,
+        input.clientOperationId,
+        this.retrySettings(thread.runtimeSettings, input.settings),
+        this.codex.epoch
+      );
+      const retryOf = retry?.rootTurnId ?? (expectedTurnId ? this.retryLinks(threadId).get(expectedTurnId) ?? expectedTurnId : void 0);
       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.taskKind === "init" ? PROJECT_INIT_PROMPT : 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);
+      this.capacityRetries.observe({ type: "turn", threadId, turn }, input.clientOperationId);
+      if (retryOf) this.retryLinks(threadId).set(turn.id, retryOf);
+      if (candidate.cancelled && retry) await this.interruptCancelledCapacity(candidate, turn.id);
       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 };
+      return {
+        result: { threadId, turnId: turn.id, ...retryOf ? { retryOf } : {} },
+        turnId: turn.id
+      };
+    });
+  }
+  retrySettings(runtime, input = {}) {
+    return {
+      ...runtime?.model ? { model: runtime.model } : {},
+      ...runtime?.reasoningEffort ? { reasoningEffort: runtime.reasoningEffort } : {},
+      ...runtime?.serviceTier === "fast" || runtime?.serviceTier === null ? { serviceTier: runtime.serviceTier } : {},
+      ...input
+    };
+  }
+  async dispatchCapacityRetry(job) {
+    if (!this.capacityRetries.owns(job) || !this.accepting || this.maintenance || !this.codex.ready || this.codex.epoch !== job.epoch)
+      throw new AppError("TURN_CONFLICT", "\u5BB9\u91CF\u91CD\u8BD5\u7684\u8FD0\u884C\u73AF\u5883\u5DF2\u6539\u53D8", 409);
+    const thread = this.projection.get(job.threadId);
+    const last = thread?.turns.at(-1);
+    if (!thread || !last || last.id !== job.turnId || last.status !== "failed" || this.store.activeForThread(job.threadId) || !job.previousOperationId || this.store.get(job.previousOperationId)?.state !== "acknowledged" || this.inFlightOperations.has(job.previousOperationId))
+      throw new AppError("TURN_CONFLICT", "\u539F\u4EFB\u52A1\u72B6\u6001\u5DF2\u6539\u53D8\uFF0C\u8BF7\u68C0\u67E5\u540E\u7EE7\u7EED", 409);
+    await this.dispatchTurn(
+      job.threadId,
+      {
+        clientOperationId: job.operationId,
+        text: "",
+        settings: job.settings
+      },
+      job
+    );
+  }
+  async cancelCapacityRetry(threadId, input) {
+    return this.perform("turn.retry.cancel", threadId, input, async () => {
+      const thread = await this.loadThread(threadId);
+      this.ensureManaged(thread);
+      const job = this.capacityRetries.current(threadId);
+      if (!job?.view || job.rootTurnId !== input.expectedTurnId)
+        throw new AppError("TURN_CONFLICT", "\u5BB9\u91CF\u91CD\u8BD5\u5DF2\u7ED3\u675F\u6216\u88AB\u66FF\u4EE3", 409);
+      this.store.dispatch(input.clientOperationId);
+      this.capacityRetries.cancel(job);
+      if (job.attempt > 0 && job.turnId) await this.interruptCancelledCapacity(job, job.turnId);
+      return { result: { threadId, cancelled: true } };
+    });
+  }
+  async interruptCancelledCapacity(job, turnId) {
+    const turn = this.projection.get(job.threadId)?.turns.find((entry) => entry.id === turnId);
+    if (!job.cancelled || job.interruptSent || !turn || !isActive(turn.status) || this.codex.epoch !== job.epoch || !this.codex.ready)
+      return;
+    job.interruptSent = true;
+    await this.codex.interruptTurn(job.threadId, turnId);
+  }
+  async retryTurn(threadId, input) {
+    return this.dispatchTurn(threadId, { ...input, text: "" }, void 0, input.expectedTurnId);
+  }
+  async getGoal(threadId) {
+    const thread = await this.loadThread(threadId);
+    this.workspaces.assertOwnership(thread.projectId, thread.cwd, thread.id);
+    this.ensureReady();
+    if (!this.codex.getGoal) throw new AppError("GOAL_UNAVAILABLE", "\u5F53\u524D Codex \u4E0D\u652F\u6301\u76EE\u6807", 409);
+    const goal = await this.codex.getGoal(threadId);
+    this.workspaces.assertOwnership(thread.projectId, thread.cwd, thread.id);
+    const current = this.projection.get(threadId);
+    if (current) {
+      current.goal = goal;
+      this.projection.touch(threadId);
+      this.publishThread(threadId);
+    }
+    return { goal, version: requestDigest(goal) };
+  }
+  async mutateGoal(threadId, input) {
+    return this.perform("goal.update", threadId, input, async () => {
+      if (this.goalWrites.has(threadId))
+        throw new AppError("GOAL_BUSY", "\u76EE\u6807\u66F4\u65B0\u6B63\u5728\u8FDB\u884C\uFF0C\u8BF7\u7B49\u5F85\u56DE\u6267", 409);
+      this.goalWrites.add(threadId);
+      try {
+        const thread = await this.loadThread(threadId);
+        this.ensureManaged(thread);
+        this.workspaces.assertOwnership(thread.projectId, thread.cwd, thread.id);
+        const stopping = input.action === "clear" || input.action === "set" && input.status !== "active" && input.status !== void 0 && input.objective === void 0 && input.tokenBudget === void 0;
+        if (!stopping && (thread.status === "unknown" || isActive(thread.status) || thread.turns.some((turn) => isActive(turn.status)) || this.store.activeForThread(threadId)))
+          throw new AppError("THREAD_BUSY", "\u8BF7\u7B49\u5F85\u5F53\u524D\u4EFB\u52A1\u7ED3\u675F\u5E76\u6838\u5BF9\u72B6\u6001\u540E\u518D\u4FEE\u6539\u6216\u6062\u590D\u76EE\u6807", 409);
+        this.ensureCompatibilityConfirmed();
+        if (!this.codex.getGoal || !this.codex.mutateGoal)
+          throw new AppError("GOAL_UNAVAILABLE", "\u5F53\u524D Codex \u4E0D\u652F\u6301\u76EE\u6807", 409);
+        const before = await this.getGoal(threadId);
+        if (before.version !== input.expectedVersion)
+          throw new AppError("GOAL_CONFLICT", "\u76EE\u6807\u5DF2\u53D1\u751F\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u8BFB\u53D6\u540E\u64CD\u4F5C", 409);
+        this.store.dispatch(input.clientOperationId);
+        const mutation = input.action === "clear" ? { action: "clear" } : {
+          action: "set",
+          ...input.objective === void 0 ? {} : { objective: input.objective },
+          ...input.status === void 0 ? {} : { status: input.status },
+          ...input.tokenBudget === void 0 ? {} : { tokenBudget: input.tokenBudget }
+        };
+        const previousGoal = this.projection.get(threadId)?.goal;
+        const goal = await this.codex.mutateGoal(threadId, mutation);
+        const current = this.projection.get(threadId);
+        if (current && current.goal === previousGoal) {
+          current.goal = goal;
+          this.projection.touch(threadId);
+          this.publishThread(threadId);
+        }
+        return { result: { goal } };
+      } finally {
+        this.goalWrites.delete(threadId);
+      }
+    });
+  }
+  async recapThread(threadId, input) {
+    return this.perform("thread.recap", threadId, input, async () => {
+      const thread = await this.loadThread(threadId);
+      this.ensureManaged(thread);
+      this.workspaces.assertOwnership(thread.projectId, thread.cwd, thread.id);
+      if (thread.status === "unknown" || isActive(thread.status) || thread.turns.some((turn) => isActive(turn.status)))
+        throw new AppError("THREAD_BUSY", "\u8BF7\u7B49\u5F85\u4EFB\u52A1\u7ED3\u675F\u5E76\u6838\u5BF9\u72B6\u6001\u540E\u518D\u751F\u6210\u6458\u8981", 409);
+      this.ensureCompatibilityConfirmed();
+      if (!this.codex.recapThread)
+        throw new AppError("METHOD_UNAVAILABLE", "Codex \u4E0D\u652F\u6301\u4F1A\u8BDD\u6458\u8981", 409);
+      const history = await (this.codex.readThreadPage?.(threadId) ?? this.codex.readThread(threadId));
+      this.workspaces.assertOwnership(thread.projectId, history.cwd, history.id);
+      const { prompt, partial } = recapInput(history, input.language);
+      if (!history.turns.some(
+        (turn) => turn.items.some(
+          (item) => (item.type === "userMessage" || item.type === "agentMessage") && item.text?.trim()
+        )
+      ))
+        throw new AppError("EMPTY_THREAD", "\u5F53\u524D\u4F1A\u8BDD\u6CA1\u6709\u53EF\u751F\u6210\u6458\u8981\u7684\u6D88\u606F", 409);
+      this.store.dispatch(input.clientOperationId);
+      const summary = await this.codex.recapThread(threadId, prompt);
+      this.workspaces.assertOwnership(thread.projectId, thread.cwd, thread.id);
+      return { result: { summary, partial, readAt: Date.now() } };
+    });
+  }
+  async getGuardianDenials(threadId) {
+    const thread = await this.loadThread(threadId);
+    this.ensureManaged(thread);
+    this.workspaces.assertOwnership(thread.projectId, thread.cwd, thread.id);
+    if (!this.codex.listGuardianDenials)
+      throw new AppError("METHOD_UNAVAILABLE", "Codex \u4E0D\u652F\u6301\u62D2\u7EDD\u8BB0\u5F55\u8BFB\u53D6", 409);
+    return { data: this.codex.listGuardianDenials(threadId) };
+  }
+  async approveGuardianDenial(threadId, input) {
+    return this.perform("guardian.approve", threadId, input, async () => {
+      const thread = await this.loadThread(threadId);
+      this.ensureManaged(thread);
+      this.workspaces.assertOwnership(thread.projectId, thread.cwd, thread.id);
+      if (thread.status === "unknown" || isActive(thread.status) || thread.turns.some((turn) => isActive(turn.status)))
+        throw new AppError("THREAD_BUSY", "\u8BF7\u7B49\u5F85\u5F53\u524D\u4EFB\u52A1\u7ED3\u675F\u5E76\u786E\u8BA4\u72B6\u6001\u540E\u518D\u6388\u6743\u91CD\u8BD5", 409);
+      this.ensureCompatibilityConfirmed();
+      if (!this.codex.approveGuardianDenial || !this.codex.listGuardianDenials?.(threadId).some((entry) => entry.id === input.denialId))
+        throw new AppError("DENIAL_EXPIRED", "\u62D2\u7EDD\u8BB0\u5F55\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u67E5\u770B\u5F53\u524D\u4F1A\u8BDD", 409);
+      this.store.dispatch(input.clientOperationId);
+      await this.codex.approveGuardianDenial(threadId, input.denialId);
+      this.publishThread(threadId);
+      return { result: { threadId } };
     });
   }
   async compactThread(threadId, input) {
     return this.perform("thread.compact", threadId, input, async () => {
+      this.capacityRetries.clear(threadId);
       const thread = await this.loadThread(threadId);
       this.ensureManaged(thread);
       const ownership = this.workspaces.assertOwnership(thread.projectId, thread.cwd, thread.id);
@@ -779,6 +1016,7 @@ class GatewayService {
   }
   async startReview(threadId, input) {
     return this.perform("review.start", threadId, input, async () => {
+      this.capacityRetries.clear(threadId);
       const thread = await this.loadThread(threadId);
       this.ensureManaged(thread);
       const ownership = this.workspaces.assertOwnership(thread.projectId, thread.cwd, thread.id);
@@ -796,7 +1034,7 @@ class GatewayService {
       });
       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);
+      const turn = await this.codex.startReview(threadId, input.target);
       this.store.attachTurn(input.clientOperationId, turn.id);
       this.turnBaselines.delete(input.clientOperationId);
       this.projection.turn(threadId, turn, this.projection.revision(threadId) !== revision);
@@ -916,6 +1154,7 @@ class GatewayService {
   }
   async shutdown() {
     this.accepting = false;
+    this.capacityRetries.clearAll();
     await this.projectClones.close();
     this.store.recover();
     this.projection.runtimeReset();
@@ -957,6 +1196,8 @@ class GatewayService {
         const action = this.projection.resolveAction(target, "pending");
         if (action?.threadId) this.publishThread(action.threadId);
       }
+      if (kind === "turn.start")
+        this.capacityRetries.dispatchFailed(target, input.clientOperationId);
       if (dispatched && kind === "turn.start") this.publishThread(target);
       this.events.publish("operation", operation);
       if (uncertain)
@@ -1187,11 +1428,28 @@ class GatewayService {
   }
   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))
+      thread.hasMessages || thread.archived || thread.goal || thread.turns.length || this.store.activeForThread(thread.id) || isActive(thread.status) || thread.actions.some((action) => ["pending", "responding"].includes(action.status))
     );
   }
+  retryLinks(threadId) {
+    let links = this.capacityLinks.get(threadId);
+    if (!links) {
+      links = this.store.capacityRetryTurns(threadId);
+      this.capacityLinks.set(threadId, links);
+    }
+    return links;
+  }
   threadView(thread) {
     const result = structuredClone(thread);
+    const links = this.capacityLinks.get(thread.id) ?? (thread.turns.some((turn) => !turn.items.some((item) => item.type === "userMessage")) ? this.retryLinks(thread.id) : void 0);
+    for (const turn of result.turns) {
+      const root = links?.get(turn.id);
+      if (root) turn.retryOf = root;
+    }
+    const retry = this.capacityRetries.view(thread.id);
+    if (retry) result.capacityRetry = structuredClone(retry);
+    else delete result.capacityRetry;
+    if (this.capacityRetries.pending(thread.id)) result.status = "running";
     result.archived = thread.archived ?? false;
     result.historyVisible = this.historyVisible(thread);
     const marker = this.store.activeForThread(thread.id);
@@ -1240,6 +1498,17 @@ class GatewayService {
     }
   }
   consume(event) {
+    if (event.type === "runtime" && (!event.diagnostics.ready || event.diagnostics.codexEpoch !== this.currentEpoch))
+      this.capacityRetries.clearAll();
+    const eventThread = event.type === "action" ? event.action.threadId : "threadId" in event ? event.threadId : void 0;
+    const eventMarker = eventThread ? this.store.activeForThread(eventThread) : void 0;
+    const matchesDispatch = event.type !== "turn" || eventMarker?.turnId === event.turn.id || eventMarker?.turnId === null && this.turnBaselines.get(eventMarker.operationId)?.has(event.turn.id) === false;
+    this.capacityRetries.observe(event, matchesDispatch ? eventMarker?.operationId : void 0);
+    if (event.type === "turn") {
+      const job = this.capacityRetries.current(event.threadId);
+      if (job?.attempt && job.turnId === event.turn.id && job.rootTurnId)
+        this.retryLinks(event.threadId).set(event.turn.id, job.rootTurnId);
+    }
     if (event.type === "runtime") {
       this.compatibilityConfirmation(event.diagnostics);
       if (!event.diagnostics.ready || event.diagnostics.codexEpoch !== this.currentEpoch) {
@@ -1295,6 +1564,12 @@ class GatewayService {
     }
     const thread = this.projection.get(event.threadId);
     if (!thread) return;
+    if (event.type === "goal") {
+      thread.goal = event.goal;
+      this.projection.touch(thread.id);
+      this.publishThread(thread.id);
+      return;
+    }
     const previousAttention = new Set(
       event.type === "item" || event.type === "turn" ? pendingAttention(thread).map(attentionKey) : []
     );
@@ -1304,7 +1579,13 @@ class GatewayService {
       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);
+      const changed = event.type === "turnError" ? this.projection.turnError(
+        thread.id,
+        event.turnId,
+        event.message,
+        event.willRetry,
+        event
+      ) : this.projection.turnProgress(thread.id, event.turnId);
       if (changed) this.publishThread(thread.id);
       return;
     }
@@ -1324,6 +1605,32 @@ class GatewayService {
       this.projection.touch(thread.id);
     } else if (event.type === "turn") {
       const previous = thread.turns.find((turn) => turn.id === event.turn.id);
+      if (thread.goal && !isTerminal(event.turn.status) && (!previous || !isTerminal(previous.status)) && !this.store.activeForThread(thread.id) && this.store.getThreadLink(thread.id)?.managedEpoch === this.codex.epoch) {
+        try {
+          const ownership = this.workspaces.assertOwnership(
+            thread.projectId,
+            thread.cwd,
+            thread.id
+          );
+          const operationId = randomUUID();
+          this.store.accept(operationId, "goal.continue", thread.id, {
+            turnId: event.turn.id,
+            codexEpoch: this.codex.epoch
+          });
+          this.store.dispatch(operationId, {
+            threadId: thread.id,
+            workspaceKey: ownership.workspaceKey,
+            codexEpoch: this.codex.epoch
+          });
+          this.store.attachTurn(operationId, event.turn.id);
+          this.store.acknowledge(
+            operationId,
+            { threadId: thread.id, turnId: event.turn.id },
+            event.turn.id
+          );
+        } catch {
+        }
+      }
       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);
@@ -1338,7 +1645,7 @@ class GatewayService {
       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) {
+        if (newCompletion && !this.capacityRetries.pending(thread.id)) {
           try {
             this.workspaces.assertOwnership(thread.projectId, thread.cwd, thread.id);
             this.events.publishCompletion({