usebeeline 0.0.122 → 0.0.123

package/dist/usebeeline.mjs

@@ -16005,39 +16005,28 @@ function modelSelectionTargets(selection) {
     }
   ];
 }
-function assertModelSelectionAdvertised(advertisedOptions, selection) {
-  for (const target of modelSelectionTargets(selection)) {
-    if (!target.value)
-      continue;
-    const axis = advertisedOptions.find((option) => target.categories.includes(option.category));
-    if (!axis) {
-      continue;
-    }
-    assertModelConfigAxisAllowed(axis.id, advertisedOptions);
-    if (!axis.options.some((choice) => choice.id === target.value)) {
-      throw new ModelSelectionUnavailableError({
-        label: target.label,
-        value: target.value,
-        reason: "not-advertised"
-      });
-    }
-  }
-}
 function assertModelConfigAxisAllowed(configId, advertisedOptions) {
   const axis = advertisedOptions.find((option) => option.id === configId);
   if (!axis || !isAllowedAgentModelConfigCategory(axis.category)) {
     throw new DisallowedModelConfigOptionError(configId);
   }
 }
-async function applyAgentModelSelection(client, sessionId, advertisedOptions, selection) {
-  assertModelSelectionAdvertised(advertisedOptions, selection);
+async function applyAgentModelSelectionWithUpdatedCatalog(client, sessionId, advertisedOptions, selection) {
+  let currentOptions = advertisedOptions;
   for (const target of modelSelectionTargets(selection)) {
     if (!target.value)
       continue;
-    const axis = advertisedOptions.find((option) => target.categories.includes(option.category));
+    const axis = currentOptions.find((option) => target.categories.includes(option.category));
     if (!axis)
       continue;
-    assertModelConfigAxisAllowed(axis.id, advertisedOptions);
+    assertModelConfigAxisAllowed(axis.id, currentOptions);
+    if (!axis.options.some((choice) => choice.id === target.value)) {
+      throw new ModelSelectionUnavailableError({
+        label: target.label,
+        value: target.value,
+        reason: "not-advertised"
+      });
+    }
     try {
       if (axis.id === GROK_SESSION_MODEL_AXIS_ID) {
         if (!client.setModel)
@@ -16048,7 +16037,10 @@ async function applyAgentModelSelection(client, sessionId, advertisedOptions, se
           throw new Error(`Grok started with reasoning effort "${axis.currentValue ?? "unknown"}", not "${target.value}"`);
         }
       } else {
-        await client.setConfigOption(sessionId, axis.id, target.value);
+        const updated = await client.setConfigOption(sessionId, axis.id, target.value);
+        const refreshed = filterAllowedModelConfigOptions(parseAdvertisedConfigOptions(updated, selection.model));
+        if (refreshed.length > 0)
+          currentOptions = refreshed;
       }
     } catch (error) {
       throw new ModelSelectionUnavailableError({
@@ -16059,6 +16051,10 @@ async function applyAgentModelSelection(client, sessionId, advertisedOptions, se
       });
     }
   }
+  return currentOptions;
+}
+async function applyAgentModelSelection(client, sessionId, advertisedOptions, selection) {
+  await applyAgentModelSelectionWithUpdatedCatalog(client, sessionId, advertisedOptions, selection);
 }
 
 // apps/body/dist/model-catalog.js
@@ -16109,27 +16105,34 @@ async function withAgentModelCatalog(agent, agentEnv, selection, inspect, limits
 async function fetchAgentModelCatalog(agent, agentEnv, selection, limits = {}) {
   return withAgentModelCatalog(agent, agentEnv, selection, async ({ client, sessionId, raw, catalog }) => ({
     raw,
-    catalog: await filterModelChoicesByLiveValidation(client, sessionId, catalog)
+    catalog: await filterModelChoicesByLiveValidation(client, sessionId, catalog, selection?.model)
   }), limits);
 }
-async function filterModelChoicesByLiveValidation(client, sessionId, catalog) {
+async function filterModelChoicesByLiveValidation(client, sessionId, catalog, preferredModelId) {
   const modelAxis = catalog.find((axis) => axis.category === "model");
   if (!modelAxis)
     return catalog;
   const available = [];
+  const preferred = preferredModelId ?? modelAxis.currentValue;
+  let preferredCatalog;
   for (const choice of modelAxis.options) {
     try {
-      await applyAgentModelSelection(client, sessionId, catalog, { model: choice.id });
+      const updated = await applyAgentModelSelectionWithUpdatedCatalog(client, sessionId, catalog, {
+        model: choice.id
+      });
       available.push(choice);
+      if (choice.id === preferred)
+        preferredCatalog = updated;
     } catch {
     }
   }
-  return catalog.map((axis) => axis === modelAxis ? { ...axis, options: available } : axis);
+  const effective = preferredCatalog ?? catalog;
+  return effective.map((axis) => axis.category === "model" ? { ...axis, options: available } : axis);
 }
 async function validateAgentModelSelection(agent, agentEnv, selection) {
   return withAgentModelCatalog(agent, agentEnv, selection, async ({ client, sessionId, raw, catalog }) => {
-    await applyAgentModelSelection(client, sessionId, catalog, selection);
-    return { raw, catalog };
+    const applied = await applyAgentModelSelectionWithUpdatedCatalog(client, sessionId, catalog, selection);
+    return { raw, catalog: applied };
   });
 }
 
@@ -16215,7 +16218,7 @@ async function syncAgentModelCatalog(input) {
     const effectiveCatalog = input.startupUnavailable ? catalog : withEffectiveCurrentValues(catalog, selection);
     const hash = modelCatalogHash(effectiveCatalog, selection, input.startupUnavailable);
     const previous = await readFile(hashPath, "utf8").catch(() => "");
-    if (previous.trim() === hash)
+    if (!input.force && previous.trim() === hash)
       return "unchanged";
     await input.api.execute("postAgentModelCatalog", {
       agentId: input.agentId,
@@ -31580,14 +31583,18 @@ export default async function (pi) {
         label: labelOf(tool.name),
         description: typeof tool.description === 'string' ? tool.description : tool.name,
         parameters: schema,
-        async execute(_toolCallId, params, signal) {
+        async execute(toolCallId, params, signal) {
           const result = await callServer(
             server,
             {
               jsonrpc: '2.0',
               id: 1,
               method: 'tools/call',
-              params: { name: tool.name, arguments: params ?? {} },
+              params: {
+                name: tool.name,
+                arguments: params ?? {},
+                _meta: { beelineToolCallId: toolCallId },
+              },
             },
             signal,
           );
@@ -32082,6 +32089,7 @@ function beelineAgentMcpServer(config, api, context) {
       { name: "BEELINE_DAEMON_ROOM_ID", value: context.roomId },
       { name: "BEELINE_DAEMON_WORKSPACE_ID", value: context.workspaceId },
       ...context.cornerId ? [{ name: "BEELINE_DAEMON_CORNER_ID", value: context.cornerId }] : [],
+      ...context.agentMayCloseCorner ? [{ name: "BEELINE_CORNER_AGENT_CLOSE", value: "1" }] : [],
       ...context.reviewer ? [{ name: "BEELINE_CORNER_REVIEWER", value: "1" }] : [],
       ...context.attachRoot ? [{ name: "BEELINE_ATTACH_ROOT", value: context.attachRoot }] : [],
       ...context.attachScratchRoot ? [{ name: "BEELINE_ATTACH_SCRATCH_ROOT", value: context.attachScratchRoot }] : [],
@@ -34026,6 +34034,8 @@ function cornerReviewerInstruction(input) {
   const headSha = input.headSha ?? "<head sha>";
   return `Checks are green on PR #${number} at ${headSha}. Review it now with the beeline-review skill against that exact head. FAIL: reply \`@${author}\` with the confirmed findings to fix. PASS: call the approve_merge tool for ${headSha}, then reply \`@${author} approved ${headSha}, merge\`. Never merge yourself. Never say you are holding or waiting for checks.`;
 }
+var CORNER_REVIEWER_SESSION_INSTRUCTION = "You are this Room's configured reviewer. The active turn prompt names the latest stable green PR head. Review and approve only that exact head; if no stable green head is named, end the turn without a verdict. Never merge yourself.";
+var CORNER_REVIEWER_UNSTABLE_HEAD_INSTRUCTION = "There is no stable green PR head for this active reviewer turn. Do not review or call approve_merge. End this turn without a verdict; the next green transition will wake you.";
 function cornerSelfReviewerInstruction(input) {
   if (!input.reviewerHandle || !input.agentHandle || !input.openedByAgent || input.agentHandle.replace(/^@/, "") !== input.reviewerHandle.replace(/^@/, ""))
     return void 0;
@@ -34247,6 +34257,8 @@ var MonolithCornerTurnLoop = class {
   yoloMode = false;
   /** The live parent-Room reviewer baked into the current session. */
   reviewerHandle;
+  /** Identity-only reviewer context; the exact PR head is refreshed inside each active turn. */
+  reviewerInstructionInput;
   /** The role-specific second-chance instruction for this session. */
   cornerTurnEndNudge = CORNER_DELIVERY_NUDGE;
   /** Repository state already given a delivery reminder, until that state changes. */
@@ -34421,17 +34433,8 @@ var MonolithCornerTurnLoop = class {
       authorHandle: opener?.handle,
       openedByAgent: !this.options.openedBy || this.options.openedBy === this.agent.publicKey
     };
-    let reviewerInstruction = cornerReviewerInstruction(reviewerInput);
-    if (reviewerInstruction) {
-      const restore = await this.options.api.execute("getCornerRestoreState", {
-        cornerId: this.options.cornerId
-      });
-      reviewerInstruction = cornerReviewerInstruction({
-        ...reviewerInput,
-        pullRequestNumber: restore.lifecycle?.pr?.number,
-        headSha: restore.lifecycle?.pr?.headSha
-      });
-    }
+    const reviewerInstruction = cornerReviewerInstruction(reviewerInput) ? CORNER_REVIEWER_SESSION_INSTRUCTION : void 0;
+    this.reviewerInstructionInput = reviewerInstruction ? reviewerInput : void 0;
     const selfReviewerInstruction = cornerSelfReviewerInstruction(reviewerInput);
     this.cornerTurnEndNudge = reviewerInstruction ?? selfReviewerInstruction ?? cornerMergeInstruction(configuration.yoloMode, configuration.reviewerHandle);
     await mkdir14(this.options.worktreePath, { recursive: true });
@@ -34579,6 +34582,7 @@ var MonolithCornerTurnLoop = class {
         roomId: this.options.parentRoomId,
         workspaceId: this.options.workspaceId,
         cornerId: this.options.cornerId,
+        agentMayCloseCorner: Boolean(repository),
         reviewer: Boolean(reviewerInstruction),
         attachRoot: this.options.worktreePath,
         // The whole per-session overlay, not an enumerated subset: see
@@ -34636,10 +34640,9 @@ var MonolithCornerTurnLoop = class {
           "Work in this corner's writable workspace. Use write_scratch_file or ordinary tools to create files, then post_artifact with the path to send them back to the corner.",
           "Do not initialize a repository, create a branch, commit, push, open a pull request, or wait for GitHub checks.",
           // This lane has no pull request URL and no merge card, so its
-          // attached final reply is the requester-facing completion
-          // signal. close_corner is still the lifecycle completion: it
-          // archives the corner and reaps this scratch workspace.
-          this.options.requesterHandle ? `Deliver the result as artifacts: post_artifact everything the objective asked for, then call close_corner. Finish the turn by replying with @${this.options.requesterHandle} and one line on what you posted; that attached reply is the requester-facing completion signal.` : `Deliver the result as artifacts: post_artifact everything the objective asked for, then call close_corner. Finish the turn by replying with one line on what you posted; that attached reply is the requester-facing completion signal.`
+          // attached final reply reports delivery to the requester. The
+          // corner remains open until a human explicitly closes it.
+          this.options.requesterHandle ? `Deliver the result as artifacts: post_artifact everything the objective asked for. Finish the turn by replying with @${this.options.requesterHandle} and one line on what you posted. The corner stays open until a human explicitly closes it.` : `Deliver the result as artifacts: post_artifact everything the objective asked for. Finish the turn by replying with one line on what you posted. The corner stays open until a human explicitly closes it.`
         ]
       ].filter(Boolean).join("\n\n")
     });
@@ -34652,6 +34655,41 @@ var MonolithCornerTurnLoop = class {
     }
     return opened.sessionId;
   }
+  /**
+   * Resolve the review target at prompt time, not session activation time.
+   *
+   * A push can land after a reviewer session starts but before its first
+   * prompt, or while that prompt is running. The active prompt and its bounded
+   * second pass therefore each read the current green lifecycle head. The
+   * server still compares approve_merge's SHA with the current head, so a push
+   * after this read fails closed too.
+   */
+  async activeReviewerInstruction() {
+    const input = this.reviewerInstructionInput;
+    if (!input)
+      return void 0;
+    try {
+      const [restore, localHead] = await Promise.all([
+        this.options.api.execute("getCornerRestoreState", {
+          cornerId: this.options.cornerId
+        }),
+        execFileAsync4("git", ["-C", this.options.worktreePath, "rev-parse", "HEAD"]).then(({ stdout: stdout6 }) => stdout6.trim())
+      ]);
+      const pr = restore.lifecycle?.pr;
+      if (restore.lifecycle?.checks !== "passing" || !pr?.number || !pr.headSha || pr.headSha !== localHead)
+        return CORNER_REVIEWER_UNSTABLE_HEAD_INSTRUCTION;
+      return [
+        "Current stable reviewer target for this active turn; it supersedes any older head in the trigger or transcript:",
+        cornerReviewerInstruction({
+          ...input,
+          pullRequestNumber: pr.number,
+          headSha: pr.headSha
+        })
+      ].join("\n");
+    } catch {
+      return CORNER_REVIEWER_UNSTABLE_HEAD_INSTRUCTION;
+    }
+  }
   /** The scheduler seam: `queue-wait` closes when a slot buys a session. */
   lifecycle(trace) {
     return {
@@ -34757,10 +34795,11 @@ var MonolithCornerTurnLoop = class {
             throw new Error("corner turn stopped for daemon handoff");
           this.busy = true;
           await this.syncBranch();
-          const [conversation, roster, delivered] = await trace.measure("context-fetch", () => Promise.all([
+          const [conversation, roster, delivered, activeReviewerInstruction] = await trace.measure("context-fetch", () => Promise.all([
             api.execute("getRoomConversation", { roomId: cornerId, limit: 200 }),
             this.roster(),
-            this.attachmentDir && attachments.length ? deliverAttachments(attachments, join12(this.attachmentDir, requestId.replace(/[^\w-]/g, "_")), this.options.fetchImpl) : Promise.resolve([])
+            this.attachmentDir && attachments.length ? deliverAttachments(attachments, join12(this.attachmentDir, requestId.replace(/[^\w-]/g, "_")), this.options.fetchImpl) : Promise.resolve([]),
+            this.activeReviewerInstruction()
           ]));
           const names = new Map(roster.members.map((member) => [member.identityId, member.name]));
           const requestedBy = requester && !requester.name && names.get(requester.pubkey) ? { ...requester, name: names.get(requester.pubkey) } : requester;
@@ -34779,13 +34818,14 @@ var MonolithCornerTurnLoop = class {
 ${this.options.objective}`,
             WarmTranscript.render(this.warmTranscript.select(this.sessionId, transcriptRows), "Corner transcript:", "New in the corner since your last turn (the earlier transcript is already in this session):"),
             roomMentionDirectory(roster, this.agent.publicKey),
+            activeReviewerInstruction,
             [
               ...sourceMessageId ? [`Reaction target message id: ${sourceMessageId}`] : [],
               `Newest trigger:
 ${trigger}`,
               ...attachmentPromptLines(attachments, delivered, this.acceptsImages())
             ].join("\n"),
-            this.options.repository ? "Continue the objective. Obey the PR checks and human hold rules in your session instructions." : "Continue the objective. Attach completed files before calling close_corner.",
+            this.options.repository ? "Continue the objective. Obey the PR checks and human hold rules in your session instructions." : "Continue the objective. Attach completed files; only a human can close this corner.",
             MAINTAIN_ASSIGNED_IDENTITY_DIRECTIVE
           ].filter(Boolean).join("\n\n");
           const stream = new AgentTurnStream({
@@ -34926,7 +34966,9 @@ ${trigger}`,
               this.lastDeliveryNudgeState = deliveryState;
             replyBeforeNudge = durableReplyText(result.agentText);
             await flushToolCalls(result.toolCalls, "");
-            result = await runPrompt(this.reviewerHandle ? this.cornerTurnEndNudge : checksTurn ? CORNER_YOLO_MERGE_NUDGE : CORNER_DELIVERY_NUDGE);
+            if (this.reviewerInstructionInput)
+              await this.syncBranch();
+            result = await runPrompt(this.reviewerHandle ? await this.activeReviewerInstruction() ?? this.cornerTurnEndNudge : checksTurn ? CORNER_YOLO_MERGE_NUDGE : CORNER_DELIVERY_NUDGE);
             trace.promptSettled();
             explained = await this.explainEmpty(result);
           }
@@ -35784,6 +35826,7 @@ var RoomRuntimeCoordinator = class {
     });
     this.options.daemonApi.setConfigChangedListener?.(() => {
       void this.scheduler.suspendIdle().catch((error) => console.error("[body] config-change session restart failed", error));
+      void Promise.resolve(this.options.onConfigChanged?.()).catch((error) => console.error("[body] config-change catalog refresh failed", error));
     });
     this.options.daemonApi.setHiccupRestartListener?.((attempt) => {
       this.options.onHiccupRestart?.(attempt);
@@ -38211,8 +38254,6 @@ async function collectConnectWizard(prompts = clackPrompts, loadModels = loadCon
     return (picked ?? "").trim();
   };
   const askEffort = async (catalog2, forHarness, model2, forProvider, forKey) => {
-    if (!catalog2.effort)
-      return void 0;
     let axis = catalog2.effort;
     if (model2 !== catalog2.currentValue) {
       const reread = await loadModels({
@@ -38224,7 +38265,7 @@ async function collectConnectWizard(prompts = clackPrompts, loadModels = loadCon
       }).catch(() => void 0);
       axis = reread?.effort ?? axis;
     }
-    if (!axis.options.length)
+    if (!axis?.options.length)
       return void 0;
     const picked = await prompts.select({
       message: brass("Choose reasoning effort"),
@@ -39394,10 +39435,27 @@ async function runStoredDaemon(pathOrPointer) {
   scratchSweepTimer.unref();
   let ready = false;
   let connectorLoop;
+  let catalogRefresh;
+  const refreshCatalog = () => {
+    catalogRefresh ??= syncAgentModelCatalog({
+      api: daemonApi,
+      agent,
+      agentEnv: config.agentEnv,
+      agentId: runtime.agent.publicKey,
+      workspaceId: runtime.communityId,
+      runtimeDir,
+      ...runtime.modelSelection ? { runtimeSelection: runtime.modelSelection } : {},
+      force: true
+    }).then(() => void 0).finally(() => {
+      catalogRefresh = void 0;
+    });
+    return catalogRefresh;
+  };
   let stoppingStatus = "daemon stopped";
   try {
     const core = new ThinDaemonCore(runtime, configPath, config, {
       daemonApi,
+      onConfigChanged: refreshCatalog,
       onHiccupRestart: (attempt) => {
         const delay = hiccupBackoffMs(attempt);
         console.warn(`[thin-core] hiccup restart attempt ${attempt}; exiting so systemd can start a fresh helper`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "usebeeline",
-  "version": "0.0.122",
+  "version": "0.0.123",
   "description": "Connect an AI coding agent to Beeline with one command.",
   "homepage": "https://usebeeline.app",
   "bugs": {