@vibedeckx/darwin-arm64 0.2.18 → 0.2.19

package/dist/bin.js

@@ -186274,7 +186274,7 @@ var createSearchCacheRepos = (kdb, _h) => ({
 });
 
 // src/storage/repositories/workflow-runs.ts
-var ACTIVE = ["waiting_reviewer", "waiting_feedback", "sending_feedback"];
+var ACTIVE = ["waiting_reviewer", "waiting_feedback", "discussing", "sending_feedback"];
 var asRun = (row) => row;
 var createWorkflowRunRepos = (kdb) => ({
   workflowRuns: {
@@ -202331,7 +202331,7 @@ import { existsSync as existsSync3 } from "fs";
 // src/notification-milestones.ts
 var sessionResultReadyId = (sessionId, turnEndEntryIndex) => `session:${sessionId}:turn:${turnEndEntryIndex}:result-ready`;
 var sessionFailedId = (sessionId, turnEndEntryIndex) => `session:${sessionId}:turn:${turnEndEntryIndex}:failed`;
-var reviewReadyId = (workflowRunId) => `workflow:${workflowRunId}:review-ready`;
+var reviewReadyId = (workflowRunId, turnEndEntryIndex) => `workflow:${workflowRunId}:turn:${turnEndEntryIndex}:review-ready`;
 var workflowFailedId = (workflowRunId, stateVersion) => `workflow:${workflowRunId}:failed:${stateVersion}`;
 function findTurnOpeningUserEntry(entries, beforeIndex) {
   let opening;
@@ -225173,6 +225173,19 @@ var AgentSessionManager = class {
       console.error(`[AgentSession] Error in ${label} handler for ${session.id}:`, err);
     });
   }
+  /**
+   * Same serial chain as `enqueueSessionWork`, for a caller that needs the
+   * result back. The chain itself absorbs the outcome (success or failure) so
+   * one queued step can never break the next; the caller gets the real promise.
+   */
+  runSerialForResult(session, work) {
+    const result = session.eventChain.then(work);
+    session.eventChain = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }
   clearGraceTimer(session) {
     if (session.graceTimer) {
       clearTimeout(session.graceTimer);
@@ -226051,6 +226064,86 @@ var AgentSessionManager = class {
     }
     return "ok";
   }
+  /**
+   * Set (or clear, with null) a session's model. The model is a spawn
+   * argument, so it takes effect on the next process the session spawns —
+   * immediately for a dormant session (a branch, or one that was stopped),
+   * and after retiring the idle process for a session that has one.
+   *
+   * Refused ("busy") under exactly the rule switchAgentType uses: a turn in
+   * flight on a session that has history. Both are respawn-shaped changes, so
+   * a divergent rule here would only mean the model chip and the agent chip
+   * lock at different moments in the same header row.
+   *
+   * The name is never validated — an unknown one is passed to the CLI and
+   * fails there, same as at creation.
+   *
+   * The whole transition runs on the session's serial event chain and writes
+   * the row BEFORE touching memory, so the three places a model lives — the
+   * row, `session.model`, and the process spawned from it — can never disagree:
+   * a failed write ("error") leaves all three exactly as they were.
+   */
+  async setModel(sessionId, model) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return "not_found";
+    const normalized = model?.trim() ? model.trim() : null;
+    return this.runSerialForResult(session, async () => {
+      if (session.model === normalized) return "ok";
+      if (this.isModelChangeTooLate(session)) return "busy";
+      console.log(`[AgentSession] Setting session ${sessionId} model ${session.model ?? "default"} \u2192 ${normalized ?? "default"}`);
+      const previous = session.model;
+      if (!session.skipDb) {
+        try {
+          await this.storage.agentSessions.updateModel(sessionId, normalized);
+        } catch (err) {
+          console.error(`[AgentSession] Failed to persist model for ${sessionId}:`, err);
+          return "error";
+        }
+        if (this.isModelChangeTooLate(session)) {
+          try {
+            await this.storage.agentSessions.updateModel(sessionId, previous);
+          } catch (err) {
+            console.error(`[AgentSession] Failed to roll back model for ${sessionId}:`, err);
+          }
+          return "busy";
+        }
+      }
+      session.model = normalized;
+      if (session.process) {
+        const proc = session.process;
+        session.process = null;
+        this.killProcess(proc);
+        this.emitProcessAlive(session, false);
+        await this.finalizeStreamingEntry(session);
+        session.store.currentAssistantIndex = null;
+        session.buffer = "";
+        this.resetCompletion(session);
+        session.dormant = true;
+        if (session.status !== "stopped") {
+          session.status = "stopped";
+          if (!session.skipDb) {
+            try {
+              await this.storage.agentSessions.updateStatus(sessionId, "stopped");
+            } catch (err) {
+              console.error(`[AgentSession] Failed to persist stopped status for ${sessionId}:`, err);
+            }
+          }
+          this.broadcastPatch(sessionId, ConversationPatch.updateStatus("stopped"));
+          this.eventBus?.emit({ type: "session:status", projectId: session.projectId, branch: session.branch, sessionId: session.id, status: "stopped" });
+        }
+      }
+      return "ok";
+    });
+  }
+  /**
+   * True once the model can no longer reach the CLI: a turn is in flight on a
+   * session that has history. Same rule switchAgentType refuses on — both are
+   * respawn-shaped changes, and a divergent rule would only mean the model
+   * chip and the agent chip lock at different moments in the same header row.
+   */
+  isModelChangeTooLate(session) {
+    return session.status === "running" && session.store.entries.some(Boolean);
+  }
   /**
    * Switch permission mode for a session (preserves conversation history)
    */
@@ -226811,6 +226904,9 @@ function runUpdatedEventFromRemoteFrame(parsed, sessionId, remoteInfo) {
   const run2 = mapRemoteRun(bare, remoteInfo.remoteServerId, projectId);
   return { type: "workflow:run-updated", projectId, branch: run2.branch, run: run2 };
 }
+function runUpdatedFrameForSubscribers(evt) {
+  return JSON.stringify({ workflowRunUpdated: evt.run });
+}
 
 // src/routes/notification-outbox-routes.ts
 var import_fastify_plugin = __toESM(require_plugin2(), 1);
@@ -226871,7 +226967,8 @@ var routes = async (fastify2) => {
           events: [],
           headCursor,
           nextCursor: headCursor,
-          hasMore: false
+          hasMore: false,
+          sessionTitle: null
         });
         continue;
       }
@@ -226881,12 +226978,14 @@ var routes = async (fastify2) => {
         validated.limit
       );
       const nextCursor = events.length > 0 ? events[events.length - 1].seq : request.after;
+      const session = events.length > 0 ? await fastify2.storage.agentSessions.getById(request.sessionId) : void 0;
       sessions.push({
         sessionId: request.sessionId,
         events,
         headCursor,
         nextCursor,
-        hasMore: nextCursor < headCursor
+        hasMore: nextCursor < headCursor,
+        sessionTitle: session?.title ?? null
       });
     }
     return reply.code(200).send({ sessions });
@@ -226904,6 +227003,7 @@ var SYNC_INTERVAL_MS = 6e4;
 var COMPLETION_NUDGE_DEBOUNCE_MS = 250;
 var MAX_CONCURRENT_SERVERS = 4;
 var MAX_PAGES_PER_SYNC = 50;
+var MAX_SESSION_TITLE_LENGTH = 200;
 function localWorkflowRunId(remoteServerId, projectId, remoteRunId) {
   return `remote-${remoteServerId}-${projectId}-${remoteRunId}`;
 }
@@ -227225,6 +227325,7 @@ var RemoteNotificationSync = class {
       console.warn(`[RemoteNotifications] project ${mapping.project_id} not found; skipping ${mapping.local_session_id}`);
       return false;
     }
+    const sessionTitle = typeof session.sessionTitle === "string" ? session.sessionTitle.slice(0, MAX_SESSION_TITLE_LENGTH) : null;
     for (const event of session.events) {
       const notification = await this.notificationService.buildNotification(event, {
         id: localNotificationId(remoteServerId, event.id),
@@ -227232,7 +227333,7 @@ var RemoteNotificationSync = class {
         projectId: mapping.project_id,
         sessionId: mapping.local_session_id,
         workflowRunId: event.workflow_run_id ? localWorkflowRunId(remoteServerId, mapping.project_id, event.workflow_run_id) : null
-      });
+      }, { sessionTitle });
       const { inserted } = await this.storage.notifications.importRemote({
         notification,
         remoteServerId,
@@ -227450,9 +227551,10 @@ function connectPersistentRemoteWs(sessionId, remoteInfo, cache2, wsOptions, rev
         }
       }
     } else if ("workflowRunUpdated" in parsed) {
-      if (eventBus) {
-        const evt = runUpdatedEventFromRemoteFrame(parsed, sessionId, remoteInfo);
-        if (evt) eventBus.emit(evt);
+      const evt = runUpdatedEventFromRemoteFrame(parsed, sessionId, remoteInfo);
+      if (evt) {
+        eventBus?.emit(evt);
+        cache2.broadcast(sessionId, runUpdatedFrameForSubscribers(evt));
       }
     } else if ("processAlive" in parsed) {
       cache2.broadcast(sessionId, raw);
@@ -230126,11 +230228,24 @@ ${opts.reviewFocus}` : null,
 function buildFeedbackMessage(feedback) {
   return [
     "[Review Feedback]",
-    "A reviewer agent examined your last completed work. Please address the following feedback:",
+    "A reviewer agent examined your last completed work. It was in read-only mode and saw only this turn's diff plus a distilled brief of the conversation, so it may be working from wrong premises. Treat its findings as input to verify, not as conclusions.",
+    "",
+    "- Verify each item against the code before changing anything.",
+    "- Push back when you have grounds: say what the item gets wrong and leave the code as it is. Do not change code to be agreeable.",
+    "- Address blocking findings first; non-blocking notes need not be done this turn.",
+    "- Do not widen the scope: no fixes the reviewer did not raise, no abstractions for hypothetical cases.",
+    "- Close with a per-item account: fixed, or not fixed and why.",
     "",
     feedback
   ].join("\n");
 }
+var FINAL_VERDICT_PROMPT = [
+  "[Final verdict request]",
+  "\u8BF7\u628A\u8BA8\u8BBA\u540E\u7684\u6700\u7EC8 review \u610F\u89C1\u5B8C\u6574\u8F93\u51FA\u4E3A\u9762\u5411\u4F5C\u8005\u7684\u5B9A\u7A3F\u3002\u8FD9\u6BB5\u8F93\u51FA\u5C06\u539F\u6837\u53D1\u9001\u7ED9\u4F5C\u8005\u2014\u2014\u4E0D\u8981\u5305\u542B\u5BF9\u8BDD\u6027\u5185\u5BB9\uFF1A\u4E0D\u8981\u5F15\u7528\u8BA8\u8BBA\u8FC7\u7A0B\u672C\u8EAB\uFF0C\u4E0D\u8981\u5411\u6211\u63D0\u95EE\u3002",
+  "- \u5438\u6536\u8BA8\u8BBA\u4E2D\u8FBE\u6210\u4E00\u81F4\u7684\u4FEE\u6B63\uFF1A\u64A4\u56DE\u7684\u6761\u76EE\u4E0D\u518D\u51FA\u73B0\uFF0C\u4FEE\u8BA2\u8FC7\u7684\u6761\u76EE\u4EE5\u4FEE\u8BA2\u540E\u7684\u5F62\u5F0F\u7ED9\u51FA\u3002",
+  "- \u4FDD\u6301\u5177\u4F53\uFF1A\u6BCF\u6761\u6307\u660E\u6587\u4EF6/\u4F4D\u7F6E\u4E0E\u95EE\u9898\uFF0C\u4EE5\u53CA\u671F\u671B\u7684\u4FEE\u590D\u65B9\u5411\u3002",
+  ...VERDICT_INSTRUCTIONS
+].join("\n");
 var REVIEWER_AGENT_TYPES = /* @__PURE__ */ new Set(["claude-code", "codex"]);
 var WorkflowEngine = class {
   constructor(storage, agentOps) {
@@ -230452,7 +230567,7 @@ var WorkflowEngine = class {
         ...driftNote ? { error: driftNote } : {}
       },
       {
-        id: reviewReadyId(run2.id),
+        id: reviewReadyId(run2.id, boundary),
         kind: "review_ready",
         project_id: run2.project_id,
         branch: run2.branch,
@@ -230499,12 +230614,49 @@ var WorkflowEngine = class {
     this.emitRunUpdated(done);
     return done;
   }
+  /**
+   * Discussion → verdict: CAS the run back onto the reviewer track and inject
+   * the final-verdict prompt. From waiting_reviewer the existing
+   * handleTaskCompleted path reopens the gate with the new turn's output.
+   * Send failure rolls the claim back so the finalize button stays actionable —
+   * mirror of approveFeedback's no-auto-retry contract.
+   */
+  async requestFinalVerdict(runId) {
+    const run2 = await this.storage.workflowRuns.getById(runId);
+    if (!run2 || run2.status !== "discussing" || !run2.reviewer_session_id) {
+      throw new WorkflowError("bad-state", "run \u4E0D\u5728\u8BA8\u8BBA\u72B6\u6001");
+    }
+    const reviewerSession = await this.storage.agentSessions.getById(run2.reviewer_session_id);
+    if (reviewerSession && reviewerSession.status === "running") {
+      throw new WorkflowError("session-busy", "reviewer \u6B63\u5728\u56DE\u590D\u4E2D\uFF0C\u8BF7\u7B49\u5F85\u5176\u5B8C\u6210\u540E\u518D\u751F\u6210\u7EC8\u7A3F");
+    }
+    const claimed = await this.storage.workflowRuns.transition(runId, "discussing", "waiting_reviewer", { error: null });
+    if (!claimed) throw new WorkflowError("bad-state", "run \u72B6\u6001\u5DF2\u53D8\u5316\uFF08\u53EF\u80FD\u5DF2\u88AB\u5904\u7406\uFF09");
+    const project = await this.storage.projects.getById(run2.project_id);
+    const sent = await this.agentOps.sendUserMessage(run2.reviewer_session_id, FINAL_VERDICT_PROMPT, project?.path ?? void 0, void 0, REVIEWER_TURN).catch(() => false);
+    if (!sent) {
+      const rolledBack = await this.storage.workflowRuns.transition(runId, "waiting_reviewer", "discussing", {
+        error: "\u53D1\u9001\u5931\u8D25\uFF1Areviewer session \u53EF\u80FD\u672A\u8FD0\u884C\u3002\u8BF7\u5728\u5176\u7A97\u53E3\u4E2D\u5524\u9192\u540E\u91CD\u8BD5\uFF0C\u6216\u7ED3\u675F\u672C\u6B21 review\u3002"
+      });
+      if (!rolledBack) {
+        console.warn(
+          `requestFinalVerdict: rollback CAS lost for run ${runId} \u2014 run moved concurrently (e.g. cancelled) while the send was in flight; rollback skipped`
+        );
+      }
+      const rolled = await this.storage.workflowRuns.getById(runId);
+      if (rolled) this.emitRunUpdated(rolled);
+      throw new WorkflowError("send-failed", "\u5411 reviewer \u53D1\u9001\u7EC8\u7A3F\u8BF7\u6C42\u5931\u8D25");
+    }
+    const updated = await this.storage.workflowRuns.getById(runId);
+    this.emitRunUpdated(updated);
+    return updated;
+  }
   async cancelRun(runId, reason) {
     const run2 = await this.storage.workflowRuns.getById(runId);
     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);
+    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);
     if (!cancelled) {
       const current = await this.storage.workflowRuns.getById(runId);
       if (current?.status === "sending_feedback") {
@@ -230522,6 +230674,10 @@ var WorkflowEngine = class {
   /**
    * Human takeover (spec §3.4): user sent a message directly to a run session.
    *
+   * Reviewer 分流:向 reviewer 发消息不再是接管——它开启一轮讨论,把 run
+   * 移入 `discussing`(gate 收起),等待显式的 requestFinalVerdict 重新出稿。
+   * 只有向 source session 发消息才算接管,结束 run。
+   *
    * Never-throws contract: this is called inline from the agent-session
    * `/message` route BEFORE the user's message is delivered
    * (agentOps.sendUserMessage). A throw here would abort delivery of that
@@ -230536,8 +230692,23 @@ var WorkflowEngine = class {
   async handleExternalUserMessage(sessionId) {
     const p2 = this.participants.get(sessionId);
     if (!p2) return;
+    if (p2.role === "reviewer") {
+      try {
+        const moved = await this.storage.workflowRuns.transition(p2.runId, "waiting_feedback", "discussing", { error: null }) || await this.storage.workflowRuns.transition(p2.runId, "waiting_reviewer", "discussing", { error: null });
+        if (moved) {
+          const updated = await this.storage.workflowRuns.getById(p2.runId);
+          if (updated) this.emitRunUpdated(updated);
+        }
+      } catch (err) {
+        console.error(
+          `[WorkflowEngine] handleExternalUserMessage: failed moving run ${p2.runId} to discussing; swallowed to honor never-throws contract`,
+          err
+        );
+      }
+      return;
+    }
     try {
-      await this.cancelRun(p2.runId, "\u7528\u6237\u63A5\u7BA1\uFF1A\u76F4\u63A5\u5411 run \u5185\u7684 session \u53D1\u9001\u4E86\u6D88\u606F\uFF0Creview \u5DF2\u7ED3\u675F\u3002");
+      await this.cancelRun(p2.runId, "\u7528\u6237\u63A5\u7BA1\uFF1A\u76F4\u63A5\u5411 source session \u53D1\u9001\u4E86\u6D88\u606F\uFF0Creview \u5DF2\u7ED3\u675F\u3002");
     } catch (err) {
       if (err instanceof WorkflowError && err.code === "bad-state") {
         console.warn(
@@ -232422,8 +232593,12 @@ var NotificationService = class {
    * Assemble the persisted row. `ids` is separate from the event because remote
    * imports substitute front-local identities (see RemoteNotificationSync) while
    * reusing this exact copy generation.
+   *
+   * `opts.sessionTitle` covers the remote-import case: the front has a mapping
+   * but no local session row, so the worker's query-time title is the only way
+   * to label the notification with the session's name.
    */
-  async buildNotification(event, ids) {
+  async buildNotification(event, ids, opts) {
     const session = ids.sessionId ? await this.storage.agentSessions.getById(ids.sessionId) : void 0;
     const project = await this.storage.projects.getById(ids.projectId);
     return {
@@ -232436,7 +232611,7 @@ var NotificationService = class {
       workflow_run_id: ids.workflowRunId,
       title: notificationTitle(event.kind),
       body: notificationBody({
-        sessionTitle: session?.title,
+        sessionTitle: session?.title ?? opts?.sessionTitle,
         branch: event.branch,
         projectName: project?.name
       }),
@@ -236551,6 +236726,54 @@ var routes12 = async (fastify2) => {
       return reply.code(200).send({ success: true, agentType });
     }
   );
+  fastify2.post(
+    "/api/agent-sessions/:sessionId/model",
+    async (req, reply) => {
+      const body = req.body || {};
+      if (body.model === void 0) {
+        return reply.code(400).send({ error: "model is required (null for the CLI default)" });
+      }
+      const { model } = body;
+      if (model !== null && typeof model !== "string") {
+        return reply.code(400).send({ error: "model must be a string or null" });
+      }
+      const userId = requireAuth(req, reply);
+      if (userId === null) return;
+      if (req.params.sessionId.startsWith("remote-")) {
+        const remoteInfo = await getAuthorizedRemoteSessionInfo(req.params.sessionId, userId);
+        if (!remoteInfo) {
+          return reply.code(404).send({ error: "Remote session not found" });
+        }
+        const result = await proxyAuto(
+          remoteInfo.remoteServerId,
+          remoteInfo.remoteUrl,
+          remoteInfo.remoteApiKey,
+          "POST",
+          `/api/agent-sessions/${remoteInfo.remoteSessionId}/model`,
+          { model }
+        );
+        return reply.code(proxyStatus(result)).send(result.data);
+      }
+      const row = await fastify2.storage.agentSessions.getById(req.params.sessionId);
+      if (!row || !await fastify2.storage.projects.getById(row.project_id, userId)) {
+        return reply.code(404).send({ error: "Session not found" });
+      }
+      const outcome = await fastify2.agentSessionManager.setModel(req.params.sessionId, model);
+      if (outcome === "not_found") {
+        return reply.code(404).send({ error: "Session not found" });
+      }
+      if (outcome === "busy") {
+        return reply.code(409).send({ error: "Agent is currently running \u2014 stop it before changing the model" });
+      }
+      if (outcome === "error") {
+        return reply.code(500).send({ error: "Couldn't save the model \u2014 the session kept its current one" });
+      }
+      return reply.code(200).send({
+        success: true,
+        model: fastify2.agentSessionManager.getSession(req.params.sessionId)?.model ?? null
+      });
+    }
+  );
   fastify2.post(
     "/api/agent-sessions/:sessionId/branch",
     async (req, reply) => {
@@ -238358,7 +238581,11 @@ async function routes19(fastify2) {
           const run2 = await fastify2.workflowEngine.cancelRun(req.params.id);
           return reply.send({ run: run2 });
         }
-        return reply.code(400).send({ error: "action must be approve or cancel" });
+        if (action === "finalize") {
+          const run2 = await fastify2.workflowEngine.requestFinalVerdict(req.params.id);
+          return reply.send({ run: run2 });
+        }
+        return reply.code(400).send({ error: "action must be approve, cancel or finalize" });
       } catch (err) {
         const status = errStatus(err);
         if (status) return reply.code(status).send({ error: err.message });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibedeckx/darwin-arm64",
-  "version": "0.2.18",
+  "version": "0.2.19",
   "description": "Vibedeckx platform binaries for macOS ARM64",
   "os": [
     "darwin"