@vibedeckx/linux-x64 0.3.29 → 0.3.31

package/dist/bin.js

@@ -186767,6 +186767,7 @@ function getWorkspaceBindingReadMetrics() {
 
 // src/storage/workflow-run-status.ts
 var WORKFLOW_ACTIVE_STATUSES = [
+  "preparing",
   "waiting_reviewer",
   "waiting_feedback",
   "discussing",
@@ -188476,7 +188477,7 @@ var createWorkflowRunRepos = (kdb) => ({
         ...opts,
         reviewer_session_id: opts.reviewer_session_id ?? null,
         review_span: opts.review_span ?? "this_turn",
-        status: "waiting_reviewer"
+        status: opts.status ?? "waiting_reviewer"
       }).execute();
       const row = await kdb.selectFrom("workflow_runs").selectAll().where("id", "=", opts.id).executeTakeFirstOrThrow();
       return asRun(row);
@@ -188504,6 +188505,10 @@ var createWorkflowRunRepos = (kdb) => ({
       const row = await kdb.selectFrom("workflow_runs").selectAll().where("source_session_id", "=", sourceSessionId).where("status", "=", "completed").where("reviewer_session_id", "is not", null).orderBy("created_at", "desc").orderBy(sql`rowid`, "desc").executeTakeFirst();
       return row ? asRun(row) : void 0;
     },
+    listReviewedSourceSessions: async (projectId, branch) => {
+      const rows = await kdb.selectFrom("workflow_runs").select("source_session_id").distinct().where("project_id", "=", projectId).where("branch", "is", branch).where("status", "=", "completed").where("reviewer_session_id", "is not", null).execute();
+      return rows.map((r) => r.source_session_id);
+    },
     update: async (id, patch) => {
       if (Object.keys(patch).length > 0) {
         await kdb.updateTable("workflow_runs").set({ ...patch, updated_at: sql`datetime('now')` }).where("id", "=", id).execute();
@@ -205223,6 +205228,12 @@ var initializeSchema = (db) => {
       FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
     );
 
+    -- getActive (panel poll, every 5s per open workspace) and
+    -- listReviewedSourceSessions (same request) both scope by project+branch
+    -- and differ only in the status filter.
+    CREATE INDEX IF NOT EXISTS idx_workflow_runs_project_branch_status
+      ON workflow_runs(project_id, branch, status);
+
     CREATE TABLE IF NOT EXISTS turn_snapshots (
       session_id TEXT NOT NULL,
       turn_end_index INTEGER NOT NULL,
@@ -233410,22 +233421,32 @@ async function createRemoteWorkflowReviewer(deps, params) {
   });
   let registeredLocalSessionId = null;
   try {
-    const result = await proxyToRemoteAuto(
+    const sharedBody = {
+      sourceSessionId: params.sourceRemoteSessionId,
+      reviewFocus: params.reviewFocus,
+      sourceTurnEndIndex: params.sourceTurnEndIndex,
+      reviewSpan: params.reviewSpan,
+      reviewerAgentType: params.reviewerAgentType,
+      runId: remoteRunId,
+      newReviewerSessionId: remoteReviewerSessionId
+    };
+    const proxyOpts = { reverseConnectManager: deps.reverseConnectManager ?? void 0 };
+    const result = params.phase === "prepare" ? await proxyToRemoteAuto(
+      params.agentMode,
+      "POST",
+      "/api/path/workflow-runs/prepare",
+      sharedBody,
+      proxyOpts
+    ) : await proxyToRemoteAuto(
       params.agentMode,
       "POST",
       "/api/path/workflow-runs",
       {
-        sourceSessionId: params.sourceRemoteSessionId,
-        reviewFocus: params.reviewFocus,
-        sourceTurnEndIndex: params.sourceTurnEndIndex,
-        reviewSpan: params.reviewSpan,
+        ...sharedBody,
         reviewContextMode: params.reviewContextMode,
-        reviewerAgentType: params.reviewerAgentType,
-        intentBrief: params.intentBrief,
-        runId: remoteRunId,
-        newReviewerSessionId: remoteReviewerSessionId
+        intentBrief: params.intentBrief
       },
-      { reverseConnectManager: deps.reverseConnectManager ?? void 0 }
+      proxyOpts
     );
     if (!result.ok) {
       const uncertain = result.errorCode === "network_error" || result.errorCode === "timeout";
@@ -239802,6 +239823,7 @@ var FINAL_VERDICT_PROMPT = [
   ...VERDICT_INSTRUCTIONS
 ].join("\n");
 var REVIEWER_AGENT_TYPES = /* @__PURE__ */ new Set(["claude-code", "codex"]);
+var PREPARE_TIMEOUT_MS = 10 * 6e4;
 var WorkflowEngine = class {
   constructor(storage2, agentOps) {
     this.storage = storage2;
@@ -239812,6 +239834,12 @@ var WorkflowEngine = class {
   eventBus;
   /** sessionId → participation in an active run (rebuilt on boot). */
   participants = /* @__PURE__ */ new Map();
+  /** runId → prompt inputs captured at prepare time (see PendingActivation). */
+  pendingActivations = /* @__PURE__ */ new Map();
+  /** runId → armed preparation-timeout timer. */
+  prepareTimers = /* @__PURE__ */ new Map();
+  /** runId → in-flight activation, so concurrent calls join instead of double-sending. */
+  activationFlights = /* @__PURE__ */ new Map();
   setEventBus(bus) {
     this.eventBus = bus;
     bus.subscribe((event) => {
@@ -239836,6 +239864,12 @@ var WorkflowEngine = class {
         await this.storage.workflowRuns.update(run2.id, {
           error: "\u670D\u52A1\u91CD\u542F\uFF0C\u53EF\u80FD\u9519\u8FC7 reviewer \u5B8C\u6210\u4E8B\u4EF6\u3002\u82E5 reviewer \u5DF2\u5B8C\u6210\uFF0C\u8BF7\u6253\u5F00\u5176\u7A97\u53E3\u67E5\u770B\uFF0C\u6216\u7ED3\u675F\u672C\u6B21 review\u3002"
         });
+      } else if (run2.status === "preparing") {
+        const createdAt = Date.parse(
+          run2.created_at.includes("T") ? run2.created_at : run2.created_at.replace(" ", "T") + "Z"
+        );
+        const elapsed = Number.isFinite(createdAt) ? Date.now() - createdAt : PREPARE_TIMEOUT_MS;
+        this.armPrepareTimeout(run2.id, PREPARE_TIMEOUT_MS - elapsed);
       }
       this.trackParticipants(run2);
     }
@@ -239850,6 +239884,37 @@ var WorkflowEngine = class {
     for (const [sid, p2] of this.participants) {
       if (p2.runId === run2.id) this.participants.delete(sid);
     }
+    this.clearPendingActivation(run2.id);
+  }
+  clearPendingActivation(runId) {
+    this.pendingActivations.delete(runId);
+    const timer = this.prepareTimers.get(runId);
+    if (timer) {
+      clearTimeout(timer);
+      this.prepareTimers.delete(runId);
+    }
+  }
+  /**
+   * Backstop for a run stuck in `preparing` (see PREPARE_TIMEOUT_MS). A timed
+   * out preparation becomes a normal failed run — visible in the UI and as a
+   * workflow_failed milestone — instead of a placeholder that spins forever.
+   * `unref` so an armed timer never holds the process open.
+   */
+  armPrepareTimeout(runId, delayMs) {
+    const existing = this.prepareTimers.get(runId);
+    if (existing) clearTimeout(existing);
+    const timer = setTimeout(() => {
+      this.prepareTimers.delete(runId);
+      void (async () => {
+        const run2 = await this.storage.workflowRuns.getById(runId);
+        if (run2?.status === "preparing") {
+          await this.failRun(run2, "review \u51C6\u5907\u8D85\u65F6\uFF1Aintent brief \u7684\u751F\u6210\u65B9\u6CA1\u6709\u56DE\u6765\u6FC0\u6D3B reviewer\u3002\u53EF\u7ED3\u675F\u540E\u91CD\u65B0\u53D1\u8D77\u3002");
+        }
+        this.pendingActivations.delete(runId);
+      })().catch((err) => console.error("[WorkflowEngine] prepare-timeout sweep failed:", err));
+    }, Math.max(0, delayMs));
+    timer.unref?.();
+    this.prepareTimers.set(runId, timer);
   }
   releaseReservations(runId) {
     for (const [sid, participant] of this.participants) {
@@ -239890,7 +239955,10 @@ var WorkflowEngine = class {
     );
     if (!ok) return;
     const failed = await this.storage.workflowRuns.getById(run2.id);
-    if (failed) this.untrackRun(failed);
+    if (failed) {
+      this.untrackRun(failed);
+      this.emitRunUpdated(failed);
+    }
     this.onMilestoneCreated?.();
   }
   /** Test seam for the failure path (see failRun). */
@@ -239959,7 +240027,29 @@ var WorkflowEngine = class {
       reason: null
     };
   }
+  /**
+   * Single-shot start, preserved for old callers and durable-intent replays:
+   * prepare + activate back to back. The reuse-reviewer path delivers its
+   * prompt inside prepare (no preparing state — nothing distills for a
+   * re-review); a fresh reviewer comes back `preparing` and is activated
+   * inline, which also completes a replayed run that a previous caller
+   * prepared but never activated.
+   */
   async startAdhocReview(opts) {
+    const run2 = await this.prepareAdhocReview(opts);
+    if (opts.reviewerSessionId || run2.status !== "preparing") return run2;
+    return this.activateAdhocReview(run2.id, { intentBrief: opts.intentBrief, blind: opts.blind });
+  }
+  /**
+   * Phase 1 of the two-phase adhoc review: validate, reserve participants,
+   * create the run row and (for a fresh review) the reviewer session — titled
+   * and visible in the sidebar — WITHOUT sending the reviewer prompt. Fast
+   * (no model calls), so the route can respond immediately and let the
+   * intent-brief distillation happen after the user has moved on. The run
+   * stays `preparing` until activateAdhocReview delivers the first message,
+   * bounded by PREPARE_TIMEOUT_MS.
+   */
+  async prepareAdhocReview(opts) {
     if (opts.reviewerSessionId === opts.sourceSessionId) {
       throw new WorkflowError("reviewer-unavailable", "reviewer session \u4E0D\u80FD\u4E0E source session \u76F8\u540C");
     }
@@ -239982,7 +240072,7 @@ var WorkflowEngine = class {
         }
         return existingRun;
       }
-      if (existingRun.status !== "waiting_reviewer") {
+      if (existingRun.status !== "waiting_reviewer" && existingRun.status !== "preparing") {
         throw new WorkflowError("bad-state", "workflow run \u5DF2\u7EC8\u6B62\uFF0C\u4E0D\u80FD\u4F5C\u4E3A\u672A\u77E5\u521B\u5EFA\u7ED3\u679C\u91CD\u653E");
       }
     }
@@ -240060,9 +240150,17 @@ var WorkflowEngine = class {
         review_focus: opts.reviewFocus ?? null,
         review_target: JSON.stringify(target),
         reviewer_session_id: opts.reviewerSessionId ?? null,
-        review_span: opts.reviewSpan ?? "this_turn"
+        review_span: opts.reviewSpan ?? "this_turn",
+        // Reuse skips the preparing state entirely: its prompt is delivered
+        // below, before this method returns.
+        status: opts.reviewerSessionId ? "waiting_reviewer" : "preparing"
       });
       this.trackParticipants(run2);
+      if (existingRun && !existingRun.reviewer_session_id && !opts.reviewerSessionId && run2.status === "waiting_reviewer") {
+        const flipped = await this.storage.workflowRuns.transition(run2.id, "waiting_reviewer", "preparing");
+        if (!flipped) throw new WorkflowError("bad-state", "run \u5728\u91CD\u653E\u671F\u95F4\u5DF2\u88AB\u53D6\u6D88\u6216\u5931\u8D25");
+        run2.status = "preparing";
+      }
       if (opts.reviewerSessionId && reviewerSession) {
         if (reviewerSession.permission_mode !== "plan") {
           let switched = false;
@@ -240113,7 +240211,13 @@ var WorkflowEngine = class {
           false,
           "plan",
           opts.reviewerAgentType ?? "claude-code",
-          true,
+          // announceRunning=false — deliberate change from the single-shot
+          // start: the preparing reviewer must appear in the sidebar (the
+          // spawn's unconditional session:process emit covers that) WITHOUT
+          // the session:status "running" emit that auto-surfaces it into the
+          // open agent window. The user stays on the source session and opens
+          // the reviewer from the sidebar when they choose to.
+          false,
           false,
           {
             startSnapshot: endSnap,
@@ -240125,27 +240229,25 @@ var WorkflowEngine = class {
           reviewerId,
           `Review - ${sourceSession?.title || (taskContext ? snippetTitle(taskContext) : null) || "Conversation"}`
         ).catch((err) => console.warn(`[WorkflowEngine] failed to set reviewer title for ${reviewerId}:`, err));
-        const prompt = buildReviewerPrompt({
+        this.pendingActivations.set(run2.id, {
+          scope,
           taskContext,
           originalIntent: extractFirstUserMessage(entries),
-          authorSelfReport: extractAuthorSelfReport(entries, turnEndIndex),
-          intentBrief: opts.intentBrief ?? null,
-          blind: opts.blind,
-          reviewFocus: opts.reviewFocus ?? null,
-          target,
-          scope
+          authorSelfReport: extractAuthorSelfReport(entries, turnEndIndex)
+        });
+        const updated = await this.storage.workflowRuns.update(run2.id, {
+          reviewer_session_id: reviewerId,
+          // Legacy replay backfill: a durable run interrupted before reviewer
+          // binding may carry no stored target. Activation builds the prompt
+          // from the stored one, so persist the target just captured (same
+          // worktree, cutoff verified above to match the stored run).
+          ...run2.review_target ? {} : { review_target: JSON.stringify(target) }
         });
-        const sent = await this.agentOps.sendUserMessage(reviewerId, prompt, opts.project.path, void 0, REVIEWER_TURN);
-        if (!sent) {
-          await this.failRun({ ...run2, reviewer_session_id: reviewerId }, "\u5411 reviewer \u6295\u9012\u4EFB\u52A1\u5931\u8D25");
-          throw new WorkflowError("spawn-failed", "\u5411 reviewer \u6295\u9012\u4EFB\u52A1\u5931\u8D25");
-        }
-        const updated = await this.storage.workflowRuns.update(run2.id, { reviewer_session_id: reviewerId });
         this.trackParticipants(updated);
+        this.armPrepareTimeout(run2.id, PREPARE_TIMEOUT_MS);
         this.emitRunUpdated(updated);
         return updated;
       } catch (err) {
-        if (err instanceof WorkflowError && err.code === "spawn-failed") throw err;
         await this.failRun(run2, `\u521B\u5EFA reviewer \u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}`);
         throw new WorkflowError("spawn-failed", "\u521B\u5EFA reviewer session \u5931\u8D25");
       }
@@ -240154,6 +240256,73 @@ var WorkflowEngine = class {
       throw err;
     }
   }
+  /**
+   * Phase 2 of the two-phase adhoc review: build the reviewer prompt and send
+   * the first message. Called after the intent brief finished distilling —
+   * inline for single-shot starts, in the background (or over the tunnel, for
+   * remote reviews) after the route already responded. Idempotent: replaying
+   * an already-activated run returns it unchanged, which the durable-intent
+   * replay path relies on.
+   */
+  async activateAdhocReview(runId, opts = {}) {
+    const existing = this.activationFlights.get(runId);
+    if (existing) return existing;
+    const flight = this.runActivation(runId, opts);
+    this.activationFlights.set(runId, flight);
+    const clear = () => {
+      if (this.activationFlights.get(runId) === flight) this.activationFlights.delete(runId);
+    };
+    flight.then(clear, clear);
+    return flight;
+  }
+  async runActivation(runId, opts) {
+    const run2 = await this.storage.workflowRuns.getById(runId);
+    if (!run2) throw new WorkflowError("bad-state", "run \u4E0D\u5B58\u5728\uFF0C\u65E0\u6CD5\u6FC0\u6D3B");
+    if (run2.status !== "preparing") {
+      if (TERMINAL_STATUSES.has(run2.status)) {
+        throw new WorkflowError("bad-state", "run \u5DF2\u7ED3\u675F\uFF0C\u65E0\u6CD5\u6FC0\u6D3B");
+      }
+      return run2;
+    }
+    if (!run2.reviewer_session_id) {
+      throw new WorkflowError("bad-state", "run \u8FD8\u6CA1\u6709 reviewer session\uFF0C\u65E0\u6CD5\u6FC0\u6D3B");
+    }
+    if (!run2.review_target) {
+      throw new WorkflowError("bad-state", "run \u7F3A\u5C11 review target\uFF0C\u65E0\u6CD5\u6FC0\u6D3B");
+    }
+    const pending = this.pendingActivations.get(runId);
+    try {
+      const entries = pending ? null : this.agentOps.getRawMessages(run2.source_session_id);
+      const prompt = buildReviewerPrompt({
+        taskContext: pending ? pending.taskContext : extractTaskContextBefore(entries, run2.source_turn_end_index),
+        originalIntent: pending ? pending.originalIntent : extractFirstUserMessage(entries),
+        authorSelfReport: pending ? pending.authorSelfReport : extractAuthorSelfReport(entries, run2.source_turn_end_index),
+        intentBrief: opts.intentBrief ?? null,
+        blind: opts.blind,
+        reviewFocus: run2.review_focus,
+        target: JSON.parse(run2.review_target),
+        scope: pending?.scope ?? null
+      });
+      const project = await this.storage.projects.getById(run2.project_id);
+      const sent = await this.agentOps.sendUserMessage(run2.reviewer_session_id, prompt, project?.path ?? void 0, void 0, REVIEWER_TURN).catch(() => false);
+      if (!sent) {
+        await this.failRun(run2, "\u5411 reviewer \u6295\u9012\u4EFB\u52A1\u5931\u8D25");
+        throw new WorkflowError("spawn-failed", "\u5411 reviewer \u6295\u9012\u4EFB\u52A1\u5931\u8D25");
+      }
+    } catch (err) {
+      if (err instanceof WorkflowError && err.code === "spawn-failed") throw err;
+      await this.failRun(run2, `\u6FC0\u6D3B reviewer \u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}`);
+      throw new WorkflowError("spawn-failed", "\u6FC0\u6D3B reviewer session \u5931\u8D25");
+    }
+    const claimed = await this.storage.workflowRuns.transition(runId, "preparing", "waiting_reviewer");
+    if (!claimed) {
+      throw new WorkflowError("bad-state", "run \u5728\u51C6\u5907\u671F\u95F4\u5DF2\u88AB\u53D6\u6D88\u6216\u5931\u8D25");
+    }
+    this.clearPendingActivation(runId);
+    const updated = await this.storage.workflowRuns.getById(runId);
+    this.emitRunUpdated(updated);
+    return updated;
+  }
   async handleTaskCompleted(event) {
     const p2 = this.participants.get(event.sessionId);
     if (!p2 || p2.role !== "reviewer") return;
@@ -240271,7 +240440,7 @@ var WorkflowEngine = class {
     if (!run2) return void 0;
     if (TERMINAL_STATUSES.has(run2.status)) return run2;
     const patch = reason ? { error: reason } : void 0;
-    const cancelled = await this.storage.workflowRuns.transition(runId, "waiting_reviewer", "cancelled", patch) || await this.storage.workflowRuns.transition(runId, "waiting_feedback", "cancelled", patch) || await this.storage.workflowRuns.transition(runId, "discussing", "cancelled", patch);
+    const cancelled = await this.storage.workflowRuns.transition(runId, "preparing", "cancelled", patch) || await this.storage.workflowRuns.transition(runId, "waiting_reviewer", "cancelled", patch) || await this.storage.workflowRuns.transition(runId, "waiting_feedback", "cancelled", patch) || await this.storage.workflowRuns.transition(runId, "discussing", "cancelled", patch);
     if (!cancelled) {
       const current = await this.storage.workflowRuns.getById(runId);
       if (current?.status === "sending_feedback") {
@@ -250685,6 +250854,34 @@ async function routes20(fastify2) {
   const proxyAuto = (info, method, apiPath, body) => proxyToRemoteAuto(info.remoteServerId, method, apiPath, body, {
     reverseConnectManager: fastify2.reverseConnectManager
   });
+  const TWO_PHASE_REVIEW_CAPABILITIES = [
+    "http:POST /api/path/workflow-runs/prepare",
+    "http:POST /api/path/workflow-runs/:param/activate"
+  ];
+  const activateRemoteReview = async (opts) => {
+    const blind = opts.reviewContextMode === "blind";
+    let intentBrief = opts.clientBrief;
+    if (!opts.clientProvidedBrief && !blind) {
+      intentBrief = await distillIntentBrief(opts.userId, opts.sourceSessionId);
+    }
+    const body = { intentBrief, reviewContextMode: opts.reviewContextMode };
+    for (let attempt = 1; ; attempt++) {
+      const result = await proxyAuto(
+        opts,
+        "POST",
+        `/api/path/workflow-runs/${opts.bareRunId}/activate`,
+        body
+      );
+      if (result.ok) return;
+      if (result.status !== 0 || attempt >= 3) {
+        console.warn(
+          `[WorkflowRuns] remote activation failed for run ${opts.bareRunId}: status=${result.status} code=${result.errorCode ?? "n/a"}`
+        );
+        return;
+      }
+      await new Promise((resolve3) => setTimeout(resolve3, attempt * 5e3));
+    }
+  };
   const sendProxyFailure = (reply, result) => reply.code(proxyStatus(result)).send(
     result.status === 0 ? { error: `Remote proxy failed: ${result.errorCode || "unknown"}` } : result.data
   );
@@ -250767,10 +250964,6 @@ async function routes20(fastify2) {
         }
         bareReviewerSessionId = reviewerInfo.remoteSessionId;
       }
-      let intentBrief2 = clientBrief;
-      if (!clientProvidedBrief && !bareReviewerSessionId && !blind) {
-        intentBrief2 = await distillIntentBrief(userId, sourceSessionId);
-      }
       if (reviewerSessionId && !await fastify2.remoteNotificationSync.prepareForNewTurn(reviewerSessionId)) {
         return reply.code(502).send({
           error: "Could not reach the remote server to prepare notification delivery",
@@ -250779,6 +250972,7 @@ async function routes20(fastify2) {
       }
       const reviewerActivityAt = Date.now();
       let bareRun;
+      let twoPhase = false;
       if (bareReviewerSessionId) {
         const result = await proxyAuto(remoteInfo, "POST", "/api/path/workflow-runs", {
           sourceSessionId: remoteInfo.remoteSessionId,
@@ -250786,7 +250980,7 @@ async function routes20(fastify2) {
           sourceTurnEndIndex,
           reviewSpan,
           reviewerSessionId: bareReviewerSessionId,
-          intentBrief: intentBrief2
+          intentBrief: clientBrief
         });
         if (!result.ok) return sendProxyFailure(reply, result);
         bareRun = result.data.run;
@@ -250796,6 +250990,14 @@ async function routes20(fastify2) {
           remoteInfo.remoteServerId
         );
         if (!remoteConfig) return reply.code(404).send({ error: "Remote project configuration not found" });
+        const server = await fastify2.storage.remoteServers.getById(remoteInfo.remoteServerId);
+        twoPhase = TWO_PHASE_REVIEW_CAPABILITIES.every(
+          (capability) => server?.worker_capabilities?.includes(capability)
+        );
+        let intentBrief = clientBrief;
+        if (!twoPhase && !clientProvidedBrief && !blind) {
+          intentBrief = await distillIntentBrief(userId, sourceSessionId);
+        }
         const result = await createRemoteWorkflowReviewer({
           remoteSessionMap: fastify2.remoteSessionMap,
           remoteSessionMappings: fastify2.storage.remoteSessionMappings,
@@ -250817,8 +251019,9 @@ async function routes20(fastify2) {
           // trailing "(review context: …)" line records what actually ran.
           reviewContextMode,
           reviewerAgentType: reviewerAgentType ?? "claude-code",
-          intentBrief: intentBrief2,
-          userId
+          intentBrief,
+          userId,
+          ...twoPhase ? { phase: "prepare" } : {}
         });
         if (!result.ok) return reply.code(proxyStatus(result)).send(result.data);
         bareRun = result.remoteRun;
@@ -250889,18 +251092,34 @@ async function routes20(fastify2) {
             sessionId: localRun.reviewer_session_id,
             alive: true
           });
-          fastify2.eventBus.emit({
-            type: "session:status",
-            projectId,
-            branch: bareRun.branch,
-            sessionId: localRun.reviewer_session_id,
-            status: "running"
-          });
+          if (!twoPhase) {
+            fastify2.eventBus.emit({
+              type: "session:status",
+              projectId,
+              branch: bareRun.branch,
+              sessionId: localRun.reviewer_session_id,
+              status: "running"
+            });
+          }
         }
         fastify2.agentSessionManager.markTitleResolved(localRun.reviewer_session_id);
         await fastify2.storage.remoteSessionMappings.markTitleResolved(localRun.reviewer_session_id);
       }
       fastify2.eventBus.emit({ type: "workflow:run-updated", projectId, branch: bareRun.branch, run: localRun });
+      if (twoPhase) {
+        const bareRunId = bareRun.id;
+        void activateRemoteReview({
+          remoteServerId: remoteInfo.remoteServerId,
+          bareRunId,
+          sourceSessionId,
+          userId,
+          reviewContextMode,
+          clientBrief,
+          clientProvidedBrief
+        }).catch((err) => {
+          console.warn(`[WorkflowRuns] remote activation task failed for run ${bareRunId}:`, err);
+        });
+      }
       return reply.code(201).send({ run: localRun });
     }
     const project = await fastify2.storage.projects.getById(projectId, userId);
@@ -250915,9 +251134,33 @@ async function routes20(fastify2) {
     if (branch !== void 0 && (branch || null) !== runBranch) {
       return reply.code(400).send({ error: "branch does not match source session" });
     }
-    let intentBrief = clientBrief;
-    if (!clientProvidedBrief && !reviewerSessionId && !blind) {
-      intentBrief = await distillIntentBrief(userId, sourceSessionId);
+    if (!reviewerSessionId) {
+      let run2;
+      try {
+        run2 = await fastify2.workflowEngine.prepareAdhocReview({
+          project: { id: project.id, path: project.path },
+          branch: runBranch,
+          sourceSessionId,
+          reviewFocus,
+          sourceTurnEndIndex,
+          reviewSpan,
+          reviewerAgentType
+        });
+      } catch (err) {
+        const status = errStatus(err);
+        if (status) return reply.code(status).send({ error: err.message });
+        throw err;
+      }
+      void (async () => {
+        let intentBrief = clientBrief;
+        if (!clientProvidedBrief && !blind) {
+          intentBrief = await distillIntentBrief(userId, sourceSessionId);
+        }
+        await fastify2.workflowEngine.activateAdhocReview(run2.id, { intentBrief, blind });
+      })().catch((err) => {
+        console.warn(`[WorkflowRuns] background activation failed for run ${run2.id}:`, err);
+      });
+      return reply.code(201).send({ run: run2 });
     }
     try {
       const run2 = await fastify2.workflowEngine.startAdhocReview({
@@ -250927,9 +251170,8 @@ async function routes20(fastify2) {
         reviewFocus,
         sourceTurnEndIndex,
         reviewSpan,
-        reviewerAgentType,
         reviewerSessionId,
-        intentBrief,
+        intentBrief: clientBrief,
         blind
       });
       return reply.code(201).send({ run: run2 });
@@ -251040,19 +251282,27 @@ async function routes20(fastify2) {
           };
           const result = await proxyAuto(info, "GET", `/api/path/workflow-runs?${q}`);
           if (!result.ok) return sendProxyFailure(reply, result);
-          const bareRuns = result.data.runs ?? [];
+          const data = result.data;
+          const bareRuns = data.runs ?? [];
           const runs2 = bareRuns.map((r) => {
             const mapped = mapRemoteRun(r, info.remoteServerId, projectId);
             trackRemoteRun(mapped, { ...info, bareRunId: r.id, projectId });
             return mapped;
           });
           logRead(runs2.length, `remote:${info.remoteServerId}`);
-          return reply.send({ runs: runs2 });
+          const prefix = `remote-${info.remoteServerId}-${projectId}-`;
+          return reply.send({
+            runs: runs2,
+            ...data.reviewedSessionIds ? { reviewedSessionIds: data.reviewedSessionIds.map((id) => prefix + id) } : {}
+          });
         }
       }
-      const runs = await fastify2.storage.workflowRuns.getActive(projectId, branch ?? null);
+      const [runs, reviewedSessionIds] = await Promise.all([
+        fastify2.storage.workflowRuns.getActive(projectId, branch ?? null),
+        fastify2.storage.workflowRuns.listReviewedSourceSessions(projectId, branch ?? null)
+      ]);
       logRead(runs.length, "local");
-      return reply.send({ runs });
+      return reply.send({ runs, reviewedSessionIds });
     }
   );
   fastify2.get("/api/workflow-runs/:id", async (req, reply) => {
@@ -251215,6 +251465,76 @@ async function routes20(fastify2) {
       throw err;
     }
   });
+  fastify2.post("/api/path/workflow-runs/prepare", async (req, reply) => {
+    const userId = requireAuth(req, reply);
+    if (userId === null) return;
+    const { sourceSessionId, reviewFocus, sourceTurnEndIndex } = req.body ?? {};
+    if (!sourceSessionId) return reply.code(400).send({ error: "sourceSessionId is required" });
+    const reviewSpan = parseReviewSpan(req.body?.reviewSpan);
+    if (reviewSpan === null) return reply.code(400).send({ error: "reviewSpan must be one of: this_turn, session_start" });
+    const reviewerAgentType = parseReviewerAgentType(req.body?.reviewerAgentType);
+    if (reviewerAgentType === null) return reply.code(400).send({ error: "reviewerAgentType must be one of: claude-code, codex" });
+    const runId = typeof req.body?.runId === "string" ? req.body.runId.trim() : "";
+    const newReviewerSessionId = typeof req.body?.newReviewerSessionId === "string" ? req.body.newReviewerSessionId.trim() : "";
+    if (!runId || !newReviewerSessionId) {
+      return reply.code(400).send({ error: "runId and newReviewerSessionId are required" });
+    }
+    const sourceSession = await fastify2.storage.agentSessions.getById(sourceSessionId);
+    if (!sourceSession) return reply.code(404).send({ error: "Session not found" });
+    const sourceProjection = await projectLocalSession(sourceSession);
+    if (!sourceProjection) return reply.code(409).send({ error: "Session workspace binding is unavailable" });
+    const project = await fastify2.storage.projects.getById(sourceProjection.projectId);
+    if (!project) return reply.code(404).send({ error: "Session not found" });
+    if (!project.path) return reply.code(400).send({ error: "Project has no local path" });
+    const projectPath = project.path;
+    try {
+      let flight = durableReviewFlights.get(runId);
+      if (!flight) {
+        flight = fastify2.workflowEngine.prepareAdhocReview({
+          project: { id: project.id, path: projectPath },
+          branch: sourceProjection.branch,
+          sourceSessionId,
+          reviewFocus,
+          sourceTurnEndIndex,
+          reviewSpan,
+          reviewerAgentType,
+          runId,
+          newReviewerSessionId
+        });
+        durableReviewFlights.set(runId, flight);
+        const clear = () => {
+          if (durableReviewFlights.get(runId) === flight) durableReviewFlights.delete(runId);
+        };
+        void flight.then(clear, clear);
+      }
+      const run2 = await flight;
+      return reply.code(201).send({ run: run2 });
+    } catch (err) {
+      const status = errStatus(err);
+      if (status) return reply.code(status).send({ error: err.message });
+      throw err;
+    }
+  });
+  fastify2.post("/api/path/workflow-runs/:id/activate", async (req, reply) => {
+    const userId = requireAuth(req, reply);
+    if (userId === null) return;
+    const reviewContextMode = parseReviewContextMode(req.body?.reviewContextMode);
+    if (reviewContextMode === null) return reply.code(400).send({ error: "reviewContextMode must be one of: briefed, blind" });
+    const blind = reviewContextMode === "blind";
+    const intentBriefRaw = req.body?.intentBrief;
+    if (intentBriefRaw !== void 0 && typeof intentBriefRaw !== "string") {
+      return reply.code(400).send({ error: "intentBrief must be a string" });
+    }
+    const intentBrief = blind ? void 0 : normalizeIntentBrief(intentBriefRaw);
+    try {
+      const run2 = await fastify2.workflowEngine.activateAdhocReview(req.params.id, { intentBrief, blind });
+      return reply.send({ run: run2 });
+    } catch (err) {
+      const status = errStatus(err);
+      if (status) return reply.code(status).send({ error: err.message });
+      throw err;
+    }
+  });
   fastify2.get("/api/path/workflow-runs/reviewer-candidate", async (req, reply) => {
     const userId = requireAuth(req, reply);
     if (userId === null) return;
@@ -251234,9 +251554,12 @@ async function routes20(fastify2) {
     const { path: projectPath, branch } = req.query;
     if (!projectPath) return reply.code(400).send({ error: "path is required" });
     const project = await fastify2.storage.projects.getByPath(projectPath) ?? await fastify2.storage.projects.getById(`path:${projectPath}`);
-    if (!project) return reply.send({ runs: [] });
-    const runs = await fastify2.storage.workflowRuns.getActive(project.id, branch || null);
-    return reply.send({ runs });
+    if (!project) return reply.send({ runs: [], reviewedSessionIds: [] });
+    const [runs, reviewedSessionIds] = await Promise.all([
+      fastify2.storage.workflowRuns.getActive(project.id, branch || null),
+      fastify2.storage.workflowRuns.listReviewedSourceSessions(project.id, branch || null)
+    ]);
+    return reply.send({ runs, reviewedSessionIds });
   });
 }
 var workflow_run_routes_default = (0, import_fastify_plugin21.default)(routes20, { name: "workflow-run-routes" });
@@ -252137,6 +252460,16 @@ var routes23 = async (fastify2) => {
         const stopHeartbeat = attachWsHeartbeat(socket, { label: "ExecutorMux" });
         const subs = /* @__PURE__ */ new Map();
         const handleInputMap = /* @__PURE__ */ new Map();
+        const wanted = /* @__PURE__ */ new Set();
+        const dropSubscription = (processId) => {
+          const sub = subs.get(processId);
+          if (sub) {
+            sub.detach();
+            sub.cleanup();
+            subs.delete(processId);
+          }
+          handleInputMap.delete(processId);
+        };
         const subscribeProcess = async (processId) => {
           if (subs.has(processId)) return;
           const ownerUserId = processOwnerScope(principal);
@@ -252149,25 +252482,31 @@ var routes23 = async (fastify2) => {
             return;
           }
           if (subs.has(processId)) return;
+          if (!wanted.has(processId)) return;
+          let detached = false;
           const send = (msg) => {
+            if (detached) return;
             try {
               socket.send(JSON.stringify({ processId, ...msg }));
             } catch {
             }
           };
           let terminated = false;
+          let self2 = null;
           const onTerminal = () => {
             terminated = true;
-            const c = subs.get(processId);
-            if (c) {
-              c();
+            if (self2 && subs.get(processId) === self2) {
               subs.delete(processId);
+              handleInputMap.delete(processId);
             }
-            handleInputMap.delete(processId);
+            self2?.cleanup();
           };
           const handle = processId.startsWith("remote-") ? attachRemoteProcessStream(fastify2, processId, send, onTerminal) : attachLocalProcessStream(fastify2, processId, send, onTerminal);
           if (!terminated) {
-            subs.set(processId, handle.cleanup);
+            self2 = { cleanup: handle.cleanup, detach: () => {
+              detached = true;
+            } };
+            subs.set(processId, self2);
             handleInputMap.set(processId, handle.handleInput);
           }
         };
@@ -252175,13 +252514,13 @@ var routes23 = async (fastify2) => {
           try {
             const msg = JSON.parse(data.toString());
             if (msg.type === "subscribe") {
+              wanted.add(msg.processId);
               subscribeProcess(msg.processId).catch((err) => {
                 console.error(`[ExecutorMux] Failed to subscribe to ${msg.processId}:`, err);
               });
             } else if (msg.type === "unsubscribe") {
-              subs.get(msg.processId)?.();
-              subs.delete(msg.processId);
-              handleInputMap.delete(msg.processId);
+              wanted.delete(msg.processId);
+              dropSubscription(msg.processId);
             } else if (msg.type === "input") {
               handleInputMap.get(msg.processId)?.({ type: "input", data: msg.data });
             } else if (msg.type === "resize") {
@@ -252197,7 +252536,11 @@ var routes23 = async (fastify2) => {
         socket.on("close", () => {
           console.log(`[ExecutorMux] Client disconnected; cleaning ${subs.size} subscriptions`);
           stopHeartbeat();
-          for (const cleanup of subs.values()) cleanup();
+          wanted.clear();
+          for (const sub of subs.values()) {
+            sub.detach();
+            sub.cleanup();
+          }
           subs.clear();
           handleInputMap.clear();
         });
@@ -260900,6 +261243,12 @@ var WORKER_CAPABILITIES = {
   // --- Workflow runs ---
   // Empirically bisected via cross-version e2e: 0.2.4 → 404, 0.2.5 → serves.
   "http:POST /api/path/workflow-runs": { since: "0.2.5", summary: "\u521B\u5EFA workflow run" },
+  // Both additive, checked as a pair (TWO_PHASE_REVIEW_CAPABILITIES in
+  // workflow-run-routes.ts): a worker missing either gets the original
+  // single-shot create — the hub distills inline and the submit blocks on it,
+  // exactly the pre-two-phase behavior.
+  "http:POST /api/path/workflow-runs/prepare": { since: "0.3.30", summary: "\u4E24\u6BB5\u5F0F review:\u51C6\u5907(\u5360\u4F4D run + reviewer session)" },
+  "http:POST /api/path/workflow-runs/:param/activate": { since: "0.3.30", summary: "\u4E24\u6BB5\u5F0F review:\u6FC0\u6D3B(\u6295\u9012 reviewer \u9996\u6761\u6D88\u606F)" },
   "http:GET /api/path/workflow-runs": { since: "0.2.5", summary: "workflow run \u5217\u8868" },
   "http:GET /api/path/workflow-runs/reviewer-candidate": { since: "0.2.5", summary: "reviewer \u5019\u9009\u67E5\u8BE2" },
   "http:GET /api/workflow-runs/:param": { since: "0.2.5", summary: "\u8BFB workflow run" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibedeckx/linux-x64",
-  "version": "0.3.29",
+  "version": "0.3.31",
   "description": "Vibedeckx platform binaries for Linux x64",
   "os": [
     "linux"