usebeeline 0.0.40 → 0.0.44

package/dist/usebeeline.mjs

@@ -489,7 +489,7 @@ function requiredBundlePaths() {
 }
 async function stageRelease(layout, manifestUrl, published, opts = {}) {
   const fetchImpl = opts.fetchImpl ?? fetch;
-  const log = opts.logger ?? ((line) => console.log(`[body] self-update: ${line}`));
+  const log2 = opts.logger ?? ((line) => console.log(`[body] self-update: ${line}`));
   const releaseId = sanitizeReleaseId(published.commit ?? published.version ?? `release-${Date.now()}`);
   const releaseDir = join6(layout.releasesRoot, releaseId);
   const okMarker = join6(releaseDir, ".stage-ok");
@@ -504,7 +504,7 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
   await mkdir10(releaseDir, { recursive: true });
   const tempArchive = join6(layout.releasesRoot, `.download-${releaseId}-${process.pid}.tar.gz`);
   try {
-    log(`downloading ${published.file}`);
+    log2(`downloading ${published.file}`);
     const response = await fetchImpl(archiveUrlFor(manifestUrl, published.file), {
       signal: AbortSignal.timeout(10 * 6e4)
     });
@@ -555,7 +555,7 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
     }
     await writeFile8(okMarker, `${published.sha256}
 `, "utf8");
-    log(`staged release ${releaseId} (sha256 verified)`);
+    log2(`staged release ${releaseId} (sha256 verified)`);
     return releaseId;
   } catch (error) {
     if (!previouslyVerified)
@@ -955,7 +955,7 @@ var init_self_update = __esm({
 });
 
 // apps/body/dist/cli.js
-import { dirname as dirname14, resolve as resolve25 } from "node:path";
+import { dirname as dirname15, resolve as resolve25 } from "node:path";
 import { readFile as readFile13, unlink as unlink3, writeFile as writeFile14 } from "node:fs/promises";
 import { stdin as stdin4, stdout as stdout5 } from "node:process";
 
@@ -2057,6 +2057,49 @@ var MULTISELECT_INSTRUCTIONS = [
   `${styleText2("dim", "Space:")} select`,
   `${styleText2("dim", "Enter:")} confirm`
 ];
+var log = {
+  message: (s = [], {
+    symbol: e = styleText2("gray", S_BAR),
+    secondarySymbol: r2 = styleText2("gray", S_BAR),
+    output: m2 = process.stdout,
+    spacing: l2 = 1,
+    withGuide: c2
+  } = {}) => {
+    const t2 = [], o = c2 ?? settings.withGuide, f = o ? r2 : "", O = o ? `${e}  ` : "", u4 = o ? `${r2}  ` : "";
+    for (let i3 = 0; i3 < l2; i3++)
+      t2.push(f);
+    const g2 = Array.isArray(s) ? s : s.split(`
+`);
+    if (g2.length > 0) {
+      const [i3, ...y] = g2;
+      i3.length > 0 ? t2.push(`${O}${i3}`) : t2.push(o ? e : "");
+      for (const p of y)
+        p.length > 0 ? t2.push(`${u4}${p}`) : t2.push(o ? r2 : "");
+    }
+    m2.write(`${t2.join(`
+`)}
+`);
+  },
+  info: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("blue", S_INFO) });
+  },
+  success: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("green", S_SUCCESS) });
+  },
+  step: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("green", S_STEP_SUBMIT) });
+  },
+  warn: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("yellow", S_WARN) });
+  },
+  /** alias for `log.warn()`. */
+  warning: (s, e) => {
+    log.warn(s, e);
+  },
+  error: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("red", S_ERROR) });
+  }
+};
 var cancel = (o = "", t2) => {
   const i3 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR_END)}  ` : "";
   i3.write(`${e}${styleText2("red", o)}
@@ -4173,12 +4216,25 @@ async function applyAgentModelSelection(client, sessionId, advertisedOptions, se
 }
 
 // apps/body/dist/model-catalog.js
+function modelCatalogProbeEnvironment(agent, agentEnv, scratchCwd) {
+  if (agent.kind !== "goose")
+    return agentEnv;
+  return {
+    ...agentEnv,
+    GOOSE_PATH_ROOT: resolve4(scratchCwd, "goose")
+  };
+}
+function filterAgentModelCatalog(agent, raw, agentEnv) {
+  const allowed = filterAllowedModelConfigOptions(raw);
+  return agent.kind === "goose" ? allowed : filterModelOptionsByCredentials(allowed, agentEnv);
+}
 async function withAgentModelCatalog(agent, agentEnv, selection, inspect) {
   const scratchCwd = await mkdtemp(resolve4(tmpdir(), "beeline-pair-model-check-"));
+  const probeEnv = modelCatalogProbeEnvironment(agent, agentEnv, scratchCwd);
   const client = new AcpClient({
     agentCommand: agent.command,
     agentArgs: agentArgsWithModelSelection(agent, selection),
-    agentEnv,
+    agentEnv: probeEnv,
     agentCwd: scratchCwd,
     // The wizard probe runs on the human's own machine for a few seconds —
     // inherit the caller's environment so harness launchers resolve (`pi`,
@@ -4191,7 +4247,7 @@ async function withAgentModelCatalog(agent, agentEnv, selection, inspect) {
     await client.start();
     const { sessionId, raw: sessionRaw } = await client.sessionNew({ cwd: scratchCwd });
     const raw = parseAdvertisedConfigOptions(sessionRaw, selection?.model, isGrokAgentCommand(agent));
-    const catalog = filterModelOptionsByCredentials(filterAllowedModelConfigOptions(raw), agentEnv);
+    const catalog = filterAgentModelCatalog(agent, raw, probeEnv);
     return await inspect({ client, sessionId, raw, catalog });
   } finally {
     await client.stop().catch(() => void 0);
@@ -4274,7 +4330,7 @@ async function withTimeout(work, timeoutMs, what) {
   }
 }
 async function syncAgentModelCatalog(input) {
-  const log = input.log ?? ((line) => console.log(line));
+  const log2 = input.log ?? ((line) => console.log(line));
   const fetchCatalog = input.fetchCatalog ?? fetchAgentModelCatalog;
   const hashPath = resolve5(input.runtimeDir, MODEL_CATALOG_HASH_FILE);
   try {
@@ -4299,10 +4355,10 @@ async function syncAgentModelCatalog(input) {
     });
     await writeFile(hashPath, `${hash}
 `, { mode: 384 });
-    log(`[body] model catalog posted: ${catalog.length} axis(es)` + (selection?.model ? `, model ${selection.model}` : "") + (selection?.effort ? `, effort ${selection.effort}` : ""));
+    log2(`[body] model catalog posted: ${catalog.length} axis(es)` + (selection?.model ? `, model ${selection.model}` : "") + (selection?.effort ? `, effort ${selection.effort}` : ""));
     return "posted";
   } catch (error) {
-    log(`[body] model catalog not posted this activation: ${error instanceof Error ? error.message : String(error)}`);
+    log2(`[body] model catalog not posted this activation: ${error instanceof Error ? error.message : String(error)}`);
     return "failed";
   }
 }
@@ -4690,6 +4746,7 @@ var BEELINE_ROOM_CAPABILITIES = [
   "To send a file, call beeline-agent attach_file with a path inside your checkout; it is attached to your reply.",
   "To run something later or repeatedly, call beeline-agent create_schedule (interval in minutes or a 5-field cron, optional maxRuns); list_schedules / delete_schedule manage them.",
   "When repository work is needed, you MUST call beeline-agent open_corner with a complete objective of no more than 24 words. The host-governed call is the only way to start write work.",
+  "When open_corner succeeds, the server posts the corner card: do not announce or restate the opening. End the turn with nothing more unless the person asked something else.",
   "Never claim an action or reply happened unless the prompt or a tool result proves it."
 ].join(" ");
 var BEELINE_DM_CAPABILITIES = [
@@ -4843,7 +4900,7 @@ function openRouterRoutingFor(providers) {
     only: [...providers],
     order: [...providers],
     allow_fallbacks: true,
-    require_parameters: true
+    require_parameters: false
   };
 }
 function openRouterRoutingCacheDir(runtimeDir) {
@@ -5657,6 +5714,52 @@ function sanitizeAgentReply(message) {
   }
   return lines.slice(1).join("\n").trim();
 }
+var CORNER_OPEN_ECHO = /^(?:(?:ok(?:ay)?|done|sure|great|alright)[,.!:]?\s+)?(?:i(?:'ve| have|'ll| will|'m| am)?\s+)?(?:just\s+)?open(?:ed|ing)?\s+(?:up\s+)?(?:a\s+|the\s+|your\s+)?(?:new\s+|write(?:-enabled)?\s+|repository\s+)*corner\b/iu;
+var CORNER_OPEN_ECHO_MAX_CHARS = 320;
+function stripCornerOpenEcho(message) {
+  const visible = message.trim();
+  if (!visible)
+    return "";
+  const paragraphs = visible.split(/\n\s*\n/);
+  const first = paragraphs[0].trim();
+  if (first.length > CORNER_OPEN_ECHO_MAX_CHARS || !CORNER_OPEN_ECHO.test(first))
+    return visible;
+  return paragraphs.slice(1).join("\n\n").trim();
+}
+var STATUS_FILLER = new Set("a an the this that it its is are was were be been being has have had do does did now still remains remain remaining ready for review reviewing pr pull request all every both and or so to of in on at as with by no not nothing new further more else needed needs need required action actions change changes changed status state update updates updated waiting wait awaiting pending running progress idle done ok okay good great well fine confirmed confirm already again yet just currently right i we will can should would github remote upstream branch head latest current report reported noted note see looks look like everything nothing appears appear seems seem there here which what from without any".split(/\s+/));
+var STATUS_SYNONYMS = {
+  passed: ["pass", "passed", "passing", "passes", "green", "succeeded", "success", "successful", "successfully"],
+  failed: ["fail", "failed", "failing", "fails", "red", "broke", "broken", "failure", "failures"],
+  check: ["check", "checks", "ci", "run", "runs", "workflow", "workflows", "build", "builds", "test", "tests", "suite"],
+  started: ["start", "started", "starting", "began", "begun", "kicked", "off", "queued"],
+  merged: ["merge", "merged", "merging", "landed", "closed"]
+};
+var STATUS_RESTATEMENT_MAX_CHARS = 200;
+var STATUS_RESTATEMENT_MAX_SENTENCES = 2;
+function statusWords(text2) {
+  return (text2.toLowerCase().match(/[\p{L}\p{N}'-]+/gu) ?? []).map((word) => word.replace(/^'+|'+$/g, "").replace(/'s$/, ""));
+}
+function isCornerStatusRestatement(reply, systemLines) {
+  const text2 = reply.trim();
+  if (!text2)
+    return true;
+  if (text2.length > STATUS_RESTATEMENT_MAX_CHARS)
+    return false;
+  if (/https?:\/\/\S+/i.test(text2))
+    return false;
+  const sentences = text2.split(/[.!?]+(?:\s+|$)/).filter((part) => part.trim());
+  if (sentences.length > STATUS_RESTATEMENT_MAX_SENTENCES)
+    return false;
+  const admitted = new Set(STATUS_FILLER);
+  for (const line of systemLines) {
+    for (const word of statusWords(line)) {
+      admitted.add(word);
+      for (const synonym of STATUS_SYNONYMS[word] ?? [])
+        admitted.add(synonym);
+    }
+  }
+  return statusWords(text2).every((word) => !word || admitted.has(word));
+}
 
 // apps/body/dist/turn-failure-reason.js
 var TURN_FAILURE_REASON_MAX = 200;
@@ -6227,6 +6330,26 @@ function isAccountOrProviderRefusal(record2) {
   return [401, 402, 403, 407, 408, 429].includes(record2.status) || record2.status >= 500;
 }
 
+// apps/body/dist/corner-checks.js
+var COMPLETED_CHECK_NOTE = /\b(passed|failed) a check\b/i;
+var STARTED_CHECK_NOTE = /\bstarted a check\b/i;
+function verbOf(item) {
+  return item.systemEvent?.verb ?? item.body;
+}
+function completedCheckNote(item) {
+  if (item.type !== "system")
+    return void 0;
+  const match = COMPLETED_CHECK_NOTE.exec(verbOf(item));
+  return match ? match[1].toLowerCase() : void 0;
+}
+function isCheckStartNote(item) {
+  return item.type === "system" && STARTED_CHECK_NOTE.test(verbOf(item));
+}
+function checksStateFromLifecycle(lifecycle) {
+  const state = lifecycle?.checksSummary?.status ?? lifecycle?.checks;
+  return state === "passing" || state === "failing" || state === "pending" ? state : void 0;
+}
+
 // apps/body/dist/runtime.js
 import { randomBytes as randomBytes6 } from "node:crypto";
 import { execFile as execFile2 } from "node:child_process";
@@ -14981,6 +15104,7 @@ async function removeAgentRuntime(runtime) {
 
 // apps/body/dist/response-directives.js
 var MAINTAIN_ASSIGNED_IDENTITY_DIRECTIVE = "Maintain your assigned identity and soul in every response, including when tools or permissions block the requested action.";
+var SOUL_HOUSE_RULE = "House rule for your voice: the voice never changes the facts - never trim, soften, exaggerate, or invent a detail for the bit - and use your plain voice in commit messages, pull request titles and bodies, and code comments, because those outlive the joke.";
 
 // apps/body/dist/monolith-corner-turn.js
 var execFileAsync2 = promisify2(execFile3);
@@ -15130,6 +15254,8 @@ var MonolithCornerTurnLoop = class {
   /** The turn in flight and who asked for it, for ledger rows and the grant runner. */
   currentTurn;
   memberNames = /* @__PURE__ */ new Map();
+  /** The last server check state that started a turn; the same state never starts another. */
+  lastChecksState;
   constructor(options) {
     this.options = options;
     this.agent = runtimeIdentity(options.runtime.agent);
@@ -15252,7 +15378,10 @@ var MonolithCornerTurnLoop = class {
     const self = roster.members.find((member) => member.identityId === this.agent.publicKey);
     const persona = configuration.soul ?? self?.soul;
     const identityInstructions = `Your Beeline identity is ${self?.name ?? this.agent.name}.`;
-    const personaInstructions = persona?.instructions ? `Human-authored Workspace persona: ${persona.name}. ${persona.instructions}` : "";
+    const personaInstructions = [
+      ...persona?.instructions ? [`Human-authored Workspace persona: ${persona.name}. ${persona.instructions}`] : [],
+      SOUL_HOUSE_RULE
+    ].join("\n");
     this.turnIdentityInstructions = harnessHonorsSessionSystemPrompt(command) ? "" : [identityInstructions, personaInstructions].filter(Boolean).join("\n\n");
     const opened = await this.client.sessionNew({
       cwd: this.options.worktreePath,
@@ -15268,6 +15397,7 @@ var MonolithCornerTurnLoop = class {
         "Merge the PR yourself only after the checks-passed event shows every check green; if any check failed or is still running, say exactly which and stop - never merge red.",
         "If any human in this corner says hold or do not merge, do not merge until a later human explicitly resumes it.",
         "Do not tag the user when a corner turn finishes: the server posts the merge summary card and its push already cover completion. Tag a human only mid-turn, and only when you need a decision or input.",
+        'GitHub check and merge notes are server lines already in the corner: never restate them (no "checks passed", "CI is green", "PR ready for review"). On a checks turn, say nothing unless you act - a merge or a pushed fix - and then one short line about that.',
         "A human approval in the app asks the server to merge. When approval is pending, wait for the server close request instead of racing it with gh. If checks passed, no hold exists, and no approval is pending, merge the pull request yourself with gh.",
         "Never push directly to the target branch. Never merge a different pull request."
       ].filter(Boolean).join("\n\n")
@@ -15291,8 +15421,9 @@ var MonolithCornerTurnLoop = class {
       }
     };
   }
-  async prompt(requestId, trigger, attachments = [], requestedById) {
+  async prompt(requestId, trigger, attachments = [], requestedById, restates) {
     const { api, cornerId } = this.options;
+    const spoken = (text2) => restates && isCornerStatusRestatement(text2, restates) ? "" : text2;
     const requester = requestedById ? {
       pubkey: requestedById,
       ...this.memberNames.get(requestedById) ? { name: this.memberNames.get(requestedById) } : {}
@@ -15350,7 +15481,7 @@ ${trigger}`, ...attachmentPromptLines(attachments, delivered)].join("\n"),
           const start = narrationPostedChars;
           narrationPostedChars = segmentEnd;
           narrationSegments += 1;
-          const trimmed = segment.trim();
+          const trimmed = spoken(segment.trim());
           if (!trimmed)
             return;
           this.activityTail = this.activityTail.catch(() => void 0).then(async () => {
@@ -15407,11 +15538,12 @@ ${trigger}`, ...attachmentPromptLines(attachments, delivered)].join("\n"),
             result
           });
           reply = explained.recoveredText ? stripAgentReplyPreamble(explained.recoveredText).trim() : "";
-          if (!reply)
+          if (!reply && !(restates && !isAccountOrProviderRefusal(explained.record))) {
             throw new Error(explained.reason);
+          }
           console.warn(`[thin-core] corner ${cornerId} turn ${requestId}: ${explained.reason}`);
         }
-        const durableTail = narrationPostedChars > 0 ? stripAgentReplyPreamble(result.agentText.slice(narrationPostedChars)).trim() : reply;
+        const durableTail = spoken(narrationPostedChars > 0 ? stripAgentReplyPreamble(result.agentText.slice(narrationPostedChars)).trim() : reply);
         if (durableTail) {
           await api.execute("postRoomMessage", {
             roomId: cornerId,
@@ -15449,6 +15581,20 @@ ${trigger}`, ...attachmentPromptLines(attachments, delivered)].join("\n"),
       this.currentTurn = void 0;
     }
   }
+  /** The server's check state for this head, or the notes' own verdict when the server carries none. */
+  async checksState(notes) {
+    try {
+      const restore = await this.options.api.execute("getCornerRestoreState", {
+        cornerId: this.options.cornerId
+      });
+      const fromServer = checksStateFromLifecycle(restore.lifecycle);
+      if (fromServer)
+        return fromServer;
+    } catch (error) {
+      console.error(`[thin-core] corner ${this.options.cornerId} check state read failed:`, error);
+    }
+    return notes.some((note) => completedCheckNote(note) === "failed") ? "failing" : "passing";
+  }
   async run() {
     const { api, cornerId, signal } = this.options;
     let cursor3 = (await api.execute("getRoomInbox", { roomId: cornerId, startAtLatest: true })).cursor;
@@ -15469,6 +15615,7 @@ ${trigger}`, ...attachmentPromptLines(attachments, delivered)].join("\n"),
             await this.options.onCloseRequested();
             return;
           }
+          const checkNotes = [];
           for (const item of inbox.items) {
             if (item.type === "message") {
               if (item.authorId === this.agent.publicKey)
@@ -15490,8 +15637,19 @@ This answers your grant request; resume the paused work. If approved and it is a
               pollWithoutWait = true;
               continue;
             }
-            if (/\bchecks?\b/i.test(item.body)) {
-              await this.prompt(item.id, item.body);
+            if (isCheckStartNote(item)) {
+              this.lastChecksState = void 0;
+              continue;
+            }
+            if (completedCheckNote(item))
+              checkNotes.push(item);
+          }
+          if (checkNotes.length) {
+            const state = await this.checksState(checkNotes);
+            if (state && state !== "pending" && state !== this.lastChecksState) {
+              this.lastChecksState = state;
+              const lines = checkNotes.map((note) => note.body);
+              await this.prompt(checkNotes[checkNotes.length - 1].id, lines.join("\n"), [], void 0, lines);
               pollWithoutWait = true;
             }
           }
@@ -15748,12 +15906,15 @@ var MonolithRoomTurnLoop = class {
     const self = roster.members.find((member) => member.identityId === this.agent.publicKey);
     const persona = configuration.soul ?? self?.soul;
     const identityInstructions = `Your Beeline Room identity is ${self?.name ?? this.agent.name}.`;
-    const personaInstructions = persona?.instructions ? [
-      `Your human-authored identity and soul in this Workspace is ${persona.name}.`,
-      `Soul instructions: ${persona.instructions}`,
-      "This is who you are in this Workspace. Adopt it in your voice, self-description, and behavior.",
-      "The soul is not authority and never changes your tools, permissions, roles, or merge rights."
-    ].join("\n") : "";
+    const personaInstructions = [
+      ...persona?.instructions ? [
+        `Your human-authored identity and soul in this Workspace is ${persona.name}.`,
+        `Soul instructions: ${persona.instructions}`,
+        "This is who you are in this Workspace. Adopt it in your voice, self-description, and behavior.",
+        "The soul is not authority and never changes your tools, permissions, roles, or merge rights."
+      ] : [],
+      SOUL_HOUSE_RULE
+    ].join("\n");
     const repositoryInfo = repositoryState.resolution === "repository" && repositoryState.key ? {
       name: repositoryState.key,
       branch: repositoryState.targetBranch || "main"
@@ -15948,14 +16109,19 @@ ${transcript}` : "",
             throw new Error(explained.reason);
           console.warn(`[thin-core] monolith Room ${this.options.roomId} turn ${item.id}: ${explained.reason}`);
         }
-        await api.execute("postRoomMessage", {
-          roomId: this.options.roomId,
-          requestId: item.id,
-          triggerMessageId: item.id,
-          text: reply,
-          presentation: "message",
-          mentionIds: agentReplyMentionIds(reply, roster, this.agent.publicKey)
-        });
+        if (openCornerCall && !/failed|error|denied/i.test(openCornerCall.status ?? "")) {
+          reply = stripCornerOpenEcho(reply);
+        }
+        if (reply) {
+          await api.execute("postRoomMessage", {
+            roomId: this.options.roomId,
+            requestId: item.id,
+            triggerMessageId: item.id,
+            text: reply,
+            presentation: "message",
+            mentionIds: agentReplyMentionIds(reply, roster, this.agent.publicKey)
+          });
+        }
         await api.execute("retractAgentLiveOutput", {
           agentId: this.agent.publicKey,
           roomId: this.options.roomId,
@@ -17270,6 +17436,9 @@ async function notify(fields) {
     return;
   await execFileAsync4("systemd-notify", fields, { timeout: SYSTEMD_COMMAND_TIMEOUT_MS });
 }
+async function extendSystemdStartTimeout(ms) {
+  await notify([`EXTEND_TIMEOUT_USEC=${Math.max(0, Math.round(ms)) * 1e3}`]).catch(() => void 0);
+}
 var SystemdNotifier = class {
   async ready(status) {
     await notify(["--ready", `--status=${status}`]);
@@ -17730,14 +17899,32 @@ function brassEnabled(env, output) {
     return "256";
   return "plain";
 }
+var BRASS_TRUECOLOR = "\x1B[38;2;215;175;95m";
+var BRASS_256 = "\x1B[38;5;179m";
 function brass(value, env = process.env, output = stdout4) {
   const level = brassEnabled(env, output);
   if (level === "truecolor")
-    return `\x1B[38;2;194;147;60m${value}\x1B[39m`;
+    return `${BRASS_TRUECOLOR}${value}\x1B[39m`;
   if (level === "256")
-    return `\x1B[38;5;178m${value}\x1B[39m`;
+    return `${BRASS_256}${value}\x1B[39m`;
   return value;
 }
+function brassRails(text2, env = process.env, output = stdout4) {
+  const level = brassEnabled(env, output);
+  if (level === "plain")
+    return text2;
+  return text2.replace(/\u001b\[(?:36|96)m/g, level === "truecolor" ? BRASS_TRUECOLOR : BRASS_256);
+}
+function paintWizardBrass(output = stdout4) {
+  const original = output.write;
+  const patched = function write(chunk, ...rest) {
+    return original.call(this, typeof chunk === "string" ? brassRails(chunk, process.env, output) : chunk, ...rest);
+  };
+  output.write = patched;
+  return () => {
+    output.write = original;
+  };
+}
 var clackPrompts = {
   async select(input) {
     clackPromptOutput();
@@ -17762,12 +17949,12 @@ var clackPrompts = {
     }), "Connection cancelled.");
   }
 };
-function connectModelPickerFromAxes(axes, fallbackModel, harness) {
+function connectModelPickerFromAxes(axes, fallbackModel, harness, rawAxes = axes) {
   const filtered = axes.find((axis) => axis.category === "model");
   if (filtered?.options.length) {
     return { currentValue: filtered.currentValue, options: filtered.options };
   }
-  const raw = axes.find((axis) => axis.category === "model" && axis.options.length);
+  const raw = rawAxes.find((axis) => axis.category === "model" && axis.options.length);
   if (raw) {
     return { currentValue: raw.currentValue, options: raw.options };
   }
@@ -17785,7 +17972,7 @@ async function loadConnectModelCatalog(input) {
     ...input.apiKey ? { apiKey: input.apiKey } : {},
     model: defaultConnectModel(input.harness, input.provider)
   }));
-  return connectModelPickerFromAxes(catalog.catalog, defaultConnectModel(input.harness, input.provider), input.harness);
+  return connectModelPickerFromAxes(catalog.catalog, defaultConnectModel(input.harness, input.provider), input.harness, catalog.raw);
 }
 async function collectConnectWizard(prompts = clackPrompts, loadModels = loadConnectModelCatalog, keyStore = fileConnectKeyStore, env = process.env, verifyKey = (input) => verifyProviderKey(input)) {
   const harness = await prompts.select({
@@ -17862,25 +18049,11 @@ async function collectConnectWizard(prompts = clackPrompts, loadModels = loadCon
     placeholder: "Type to filter available models\u2026",
     maxItems: 12
   });
-  const name = await prompts.text({
-    message: brass("Agent name"),
-    validate: (value) => {
-      if (!value.trim())
-        return "Agent name is required";
-      return isReasonableAgentName(value) ? void 0 : `Use letters, spaces, hyphens, or apostrophes (${AGENT_NAME_MAX_LENGTH} characters max)`;
-    }
-  });
-  const soul = await prompts.text({
-    message: brass("Input soul"),
-    validate: (value) => value.trim() ? void 0 : "Soul is required"
-  });
   return {
-    name: name.trim().replace(/\s+/g, " "),
     harness,
     ...provider ? { provider } : {},
     ...apiKey ? { apiKey: apiKey.trim() } : {},
-    model: model.trim(),
-    soul: soul.trim()
+    model: model.trim()
   };
 }
 async function jsonRequest(url, body, fetchImpl) {
@@ -17906,11 +18079,19 @@ function requestConnectGrant(baseUrl, pairingCode, selection, fetchImpl) {
     harness: selection.harness,
     ...selection.provider ? { provider: selection.provider } : {},
     model: selection.model,
-    soul: selection.soul,
-    avatar_seed: avatarSeed,
-    agent_name: selection.name
+    avatar_seed: avatarSeed
   }, fetchImpl);
 }
+async function renameConnectedAgent(baseUrl, pairingCode, name, fetchImpl) {
+  const normalizedPairingCode = normalizeAgentPairingCode(pairingCode);
+  if (!normalizedPairingCode)
+    throw new Error("invalid pairing code");
+  const renamed = await jsonRequest(`${baseUrl}/auth/agent/connect/name`, { pairing_code: normalizedPairingCode, agent_name: name.trim().replace(/\s+/g, " ") }, fetchImpl);
+  return renamed.agent_name;
+}
+function seededIdentityLine(grant) {
+  return grant.agent_face ? `${grant.agent_name} the ${grant.agent_face}` : grant.agent_name;
+}
 async function installCurrentRelease(fetchImpl) {
   const manifestUrl = resolveManifestUrl(process.env);
   const response = await fetchImpl(manifestUrl, { signal: AbortSignal.timeout(3e4) });
@@ -18003,15 +18184,23 @@ async function runConnectCommand(code, options = {}) {
   if (!stdin3.isTTY || !stdout4.isTTY) {
     throw new Error("`usebeeline connect` needs an interactive terminal");
   }
+  const restoreRails = paintWizardBrass();
+  try {
+    await runConnectWizard(code, options.fetchImpl ?? fetch);
+  } finally {
+    restoreRails();
+  }
+}
+async function runConnectWizard(code, fetchImpl) {
   intro(brass("Beeline connect"));
-  const fetchImpl = options.fetchImpl ?? fetch;
   const pairingCode = code?.trim() || await clackPrompts.text({
     message: brass("Pairing code from the app"),
     validate: (value) => normalizeAgentPairingCode(value) ? void 0 : "Enter the pairing code shown in the app"
   });
   const selection = await collectConnectWizard(clackPrompts, loadConnectModelCatalog, fileConnectKeyStore, process.env, (input) => verifyProviderKey({ ...input, fetchImpl }));
   const baseUrl = (process.env.BEELINE_AUTH_URL ?? "https://server.usebeeline.app").replace(/\/$/, "");
-  const grant = await brassSpinner("Connecting to your Beeline Workspace\u2026", () => requestConnectGrant(baseUrl, pairingCode, selection, fetchImpl), (connectedGrant) => `Connected to ${connectedGrant.workspace_name}`);
+  const claimed = await brassSpinner("Connecting to your Beeline Workspace\u2026", () => requestConnectGrant(baseUrl, pairingCode, selection, fetchImpl), (connectedGrant) => `Connected to ${connectedGrant.workspace_name}`);
+  const grant = { ...claimed, agent_name: await confirmSeededName(baseUrl, pairingCode, claimed, fetchImpl) };
   const installedRelease = await brassSpinner("Installing the Beeline daemon\u2026", () => installCurrentRelease(fetchImpl), (release) => `Installed Beeline helper ${release.version}`);
   const llmEnvFile = await writeProviderEnv(selection, grant.agent_pubkey);
   const grantPath = resolve19(defaultSupervisorRoot(process.env), "beeline", "connect", `grant-${process.pid}-${Date.now()}.json`);
@@ -18031,10 +18220,38 @@ async function runConnectCommand(code, options = {}) {
   });
   await brassSpinner("Starting your agent\u2026", () => runInstalledFinish(installedRelease.binary, grantPath), () => `Started ${grant.agent_name}`);
   console.log("");
-  console.log(`${brass("Agent")}      ${grant.agent_name}`);
+  console.log(`${brass("Agent")}      ${seededIdentityLine(grant)}`);
   console.log(`${brass("Workspace")}  ${grant.workspace_name}`);
   outro(brass("Say hi in the app."));
 }
+async function confirmSeededName(baseUrl, pairingCode, grant, fetchImpl, prompts = clackPrompts) {
+  log.info(brass(`Your agent is ${seededIdentityLine(grant)}.`));
+  const choice = await prompts.select({
+    message: brass("Name"),
+    initialValue: "keep",
+    options: [
+      { value: "keep", label: `Keep ${grant.agent_name}`, hint: "default" },
+      { value: "rename", label: "Rename this agent" }
+    ]
+  });
+  if (choice === "keep")
+    return grant.agent_name;
+  const renamed = await prompts.text({
+    message: brass("Agent name"),
+    initialValue: grant.agent_name,
+    validate: (value) => {
+      if (!value.trim())
+        return "Agent name is required";
+      return isReasonableAgentName(value) ? void 0 : `Use letters, spaces, hyphens, or apostrophes (${AGENT_NAME_MAX_LENGTH} characters max)`;
+    }
+  });
+  try {
+    return await renameConnectedAgent(baseUrl, pairingCode, renamed, fetchImpl);
+  } catch (error) {
+    log.warn(brass(`Could not rename this agent (${error instanceof Error ? error.message : String(error)}); it stays ${grant.agent_name}. Rename it in the app.`));
+    return grant.agent_name;
+  }
+}
 function isDevicePairingGrant(value) {
   if (!value || typeof value !== "object")
     return false;
@@ -18818,12 +19035,36 @@ var UPDATE_PROBE_TURN_TIMEOUT_MS = 45e3;
 var UpdateFunctionalProbeError = class extends Error {
   reason;
   code = "BEELINE_UPDATE_FUNCTIONAL_PROBE_FAILED";
+  /** Present when the turn failed on a provider refusal with an HTTP status. */
+  providerRefusal;
   constructor(reason, detail, options) {
     super(`functional update probe failed (${reason}): ${detail}`, options);
     this.reason = reason;
     this.name = "UpdateFunctionalProbeError";
+    this.providerRefusal = options?.providerRefusal;
   }
 };
+async function probeOutcome(run2) {
+  try {
+    await run2();
+    return { kind: "served" };
+  } catch (error) {
+    if (error instanceof UpdateFunctionalProbeError && error.providerRefusal) {
+      return { kind: "refused", ...error.providerRefusal };
+    }
+    return { kind: "unavailable", reason: error instanceof Error ? error.message : String(error) };
+  }
+}
+function describeCurrentReleaseOutcome(outcome) {
+  switch (outcome.kind) {
+    case "served":
+      return "the current release answered";
+    case "refused":
+      return `the current release got a different refusal (${outcome.reason})`;
+    case "unavailable":
+      return `the current release could not be compared (${outcome.reason})`;
+  }
+}
 async function runUpdateFunctionalProbe(input) {
   const command = input.config.agentCommand ?? input.config.agentBinary;
   const harness = input.config.agentKind ?? command;
@@ -18833,7 +19074,7 @@ async function runUpdateFunctionalProbe(input) {
   if (input.sandboxRequired && !input.config.bwrapPath) {
     throw new UpdateFunctionalProbeError("sandbox-unavailable", "the configured bubblewrap boundary did not pass its startup self-test");
   }
-  const root = resolve23(input.runtimeDir, "update-functional-probe");
+  const root = input.probeRoot ?? resolve23(input.runtimeDir, "update-functional-probe");
   const cwd = resolve23(root, "checkout");
   const homeRoot = resolve23(root, "agent-home");
   await rm7(root, { recursive: true, force: true });
@@ -18915,12 +19156,28 @@ async function runUpdateFunctionalProbe(input) {
           });
           const modelSide = isAccountOrProviderRefusal(explained.record) || explained.record?.kind === "empty";
           if (!modelSide) {
-            throw new UpdateFunctionalProbeError("turn-failed", `the harness completed a session/prompt without an agent answer: ${explained.reason}`);
+            const refusal = explained.record?.kind === "error" && explained.record.status !== void 0 ? { status: explained.record.status, reason: explained.record.reason } : void 0;
+            const detail = `the harness completed a session/prompt without an agent answer: ${explained.reason}`;
+            if (!refusal || !input.compareWithCurrentRelease) {
+              throw new UpdateFunctionalProbeError("turn-failed", detail, {
+                ...refusal ? { providerRefusal: refusal } : {}
+              });
+            }
+            const current = await input.compareWithCurrentRelease(refusal);
+            if (current.kind !== "refused" || current.status !== refusal.status) {
+              throw new UpdateFunctionalProbeError("turn-failed", `${detail}; ${describeCurrentReleaseOutcome(current)}`, { providerRefusal: refusal });
+            }
+            const reason = `${explained.reason} (the current release gets the same ${refusal.status})`;
+            console.warn(`[body] update probe: the provider refused this release and the current release alike (${refusal.reason}); that refusal is not this bundle's doing, so the probe passes as inconclusive`);
+            modelAnswer = { modelAnswer: "unavailable", modelAnswerReason: reason };
+          } else {
+            console.warn(`[body] update probe: the bundle reached the model boundary but the model answered nothing (${explained.reason}); that is the model's own answer on any release, so the probe passes without one`);
+            modelAnswer = { modelAnswer: "unavailable", modelAnswerReason: explained.reason };
           }
-          console.warn(`[body] update probe: the bundle reached the model boundary but the model answered nothing (${explained.reason}); that is the model's own answer on any release, so the probe passes without one`);
-          modelAnswer = { modelAnswer: "unavailable", modelAnswerReason: explained.reason };
         }
       } catch (error) {
+        if (error instanceof UpdateFunctionalProbeError)
+          throw error;
         throw new UpdateFunctionalProbeError("turn-failed", error instanceof Error ? error.message : String(error), { cause: error });
       }
     } catch (error) {
@@ -18942,6 +19199,137 @@ async function runUpdateFunctionalProbe(input) {
   }
 }
 
+// apps/body/dist/current-release-probe.js
+import { spawn as spawn7 } from "node:child_process";
+import { dirname as dirname14, join as join7 } from "node:path";
+init_self_update();
+var CURRENT_RELEASE_PROBE_TIMEOUT_MS = 8e4;
+var UPDATE_PROBE_COMMAND = "update-probe";
+function parseReport(line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return void 0;
+  }
+  if (!parsed || typeof parsed !== "object")
+    return void 0;
+  const report = parsed;
+  if (report.probe === "served")
+    return { probe: "served" };
+  if (report.probe === "refused" && typeof report.status === "number" && typeof report.reason === "string") {
+    return { probe: "refused", status: report.status, reason: report.reason };
+  }
+  if (report.probe === "failed" && typeof report.reason === "string") {
+    return { probe: "failed", reason: report.reason };
+  }
+  return void 0;
+}
+function outcomeFromReport(report) {
+  switch (report.probe) {
+    case "served":
+      return { kind: "served" };
+    case "refused":
+      return { kind: "refused", status: report.status, reason: report.reason };
+    case "failed":
+      return { kind: "unavailable", reason: report.reason };
+  }
+}
+async function probeReleaseInSubprocess(input) {
+  const bundleDir = join7(input.layout.releasesRoot, input.releaseId);
+  const entrypoint = await resolveBundleEntrypoint(bundleDir);
+  if (!entrypoint) {
+    return { kind: "unavailable", reason: `release ${input.releaseId} has no runnable CLI entrypoint` };
+  }
+  const timeoutMs = input.timeoutMs ?? CURRENT_RELEASE_PROBE_TIMEOUT_MS;
+  return new Promise((resolve26) => {
+    const child = spawn7(input.execPath ?? process.execPath, [entrypoint, UPDATE_PROBE_COMMAND, "--config", input.runtimeConfigPath], { env: input.env ?? process.env, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout6 = "";
+    let stderr = "";
+    let settled = false;
+    const finish = (outcome) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve26(outcome);
+    };
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      finish({
+        kind: "unavailable",
+        reason: `release ${input.releaseId} did not finish its probe within ${timeoutMs}ms`
+      });
+    }, timeoutMs);
+    child.stdout.on("data", (chunk) => {
+      stdout6 += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      finish({ kind: "unavailable", reason: `release ${input.releaseId} could not be spawned: ${error.message}` });
+    });
+    child.on("close", (code, signal) => {
+      const lines = stdout6.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+      for (let index = lines.length - 1; index >= 0; index -= 1) {
+        const report = parseReport(lines[index]);
+        if (report) {
+          finish(outcomeFromReport(report));
+          return;
+        }
+      }
+      const tail = stderr.trim().split(/\r?\n/).slice(-3).join(" | ").slice(0, 300);
+      finish({
+        kind: "unavailable",
+        reason: `release ${input.releaseId} printed no probe report (exit ${signal ?? code})` + (tail ? `: ${tail}` : "")
+      });
+    });
+  });
+}
+async function runUpdateProbeCommand(args, options = {}) {
+  const env = options.env ?? process.env;
+  const write = options.write ?? ((line) => process.stdout.write(`${line}
+`));
+  const configFlag = args.indexOf("--config");
+  const configArg = configFlag >= 0 ? args[configFlag + 1] : void 0;
+  if (!configArg)
+    throw new Error(`${UPDATE_PROBE_COMMAND} requires --config <runtime.json>`);
+  const configPath = await resolveRuntimeConfigPath(configArg);
+  const runtime = await readRuntimeRecord(configPath);
+  const agent = runtimeAgentCommand(runtime);
+  const config = loadBodyConfig({
+    workspaceRoot: join7(dirname14(configPath), "workspace"),
+    llmEnvFile: runtime.llmEnvFile,
+    env: { ...env, BUZZ_AGENT_BIN: agent.command, BUZZ_DEV_MCP_BIN: runtime.mcpBinary },
+    agent
+  });
+  if (runtime.sharedSkills)
+    config.sharedSkills = [...runtime.sharedSkills];
+  if (runtime.modelSelection)
+    config.modelSelection = runtime.modelSelection;
+  config.runtimeConfigPath = configPath;
+  const sandbox = detectBwrapSandbox({ ...runtime.sandbox ? { policy: runtime.sandbox } : {}, env });
+  if (sandbox.path)
+    config.bwrapPath = sandbox.path;
+  if (runtime.sandboxMaskPaths?.length) {
+    config.sandboxMaskPaths = [...config.sandboxMaskPaths ?? [], ...runtime.sandboxMaskPaths];
+  }
+  const layout = beelineInstallLayout(env);
+  const releaseId = (layout && await activeReleaseId(layout).catch(() => void 0)) ?? "unknown";
+  const runtimeDir = dirname14(configPath);
+  const outcome = await probeOutcome(() => (options.probe ?? runUpdateFunctionalProbe)({
+    config,
+    runtimeDir,
+    releaseId,
+    sandboxRequired: runtime.sandbox !== "off",
+    // The successor's probe still holds `<runtimeDir>/update-functional-probe`.
+    probeRoot: join7(runtimeDir, "current-release-probe")
+  }));
+  const report = outcome.kind === "served" ? { probe: "served" } : outcome.kind === "refused" ? { probe: "refused", status: outcome.status, reason: outcome.reason } : { probe: "failed", reason: outcome.reason };
+  write(JSON.stringify(report));
+}
+
 // apps/body/dist/release-status.js
 import { readFile as readFile12, readdir as readdir4, rename as rename6, writeFile as writeFile13 } from "node:fs/promises";
 import { resolve as resolve24 } from "node:path";
@@ -19004,7 +19392,7 @@ var DaemonExitError = class extends Error {
 };
 async function runStoredDaemon(pathOrPointer) {
   const configPath = await resolveRuntimeConfigPath(pathOrPointer);
-  daemonFailureRuntimeDir = dirname14(configPath);
+  daemonFailureRuntimeDir = dirname15(configPath);
   const accessMigration = await migrateRuntimeRecordAccessPolicy(configPath);
   let runtime = accessMigration.runtime;
   if (!runtime.transport) {
@@ -19016,7 +19404,7 @@ async function runStoredDaemon(pathOrPointer) {
   runtime = activated.runtime;
   const daemonApi = activated.client;
   const agent = runtimeAgentCommand(runtime);
-  await writeFile14(resolve25(dirname14(configPath), "daemon.pid"), `${process.pid}
+  await writeFile14(resolve25(dirname15(configPath), "daemon.pid"), `${process.pid}
 `, { mode: 384 });
   const env = {
     ...process.env,
@@ -19024,7 +19412,7 @@ async function runStoredDaemon(pathOrPointer) {
     BUZZ_DEV_MCP_BIN: runtime.mcpBinary
   };
   const config = loadBodyConfig({
-    workspaceRoot: resolve25(dirname14(configPath), "workspace"),
+    workspaceRoot: resolve25(dirname15(configPath), "workspace"),
     llmEnvFile: runtime.llmEnvFile,
     env,
     agent
@@ -19059,7 +19447,7 @@ async function runStoredDaemon(pathOrPointer) {
   const stop = () => controller.abort();
   process.once("SIGINT", stop);
   process.once("SIGTERM", stop);
-  const runtimeDir = dirname14(configPath);
+  const runtimeDir = dirname15(configPath);
   const layout = beelineInstallLayout(process.env);
   const notifier = new SystemdNotifier();
   let rollbackAlertDrain;
@@ -19126,6 +19514,7 @@ async function runStoredDaemon(pathOrPointer) {
       onEstablished: async () => {
         let functionalProof;
         if (layout && pendingSuccessor) {
+          const currentReleaseId = (await readUpdateAttempt(layout))?.previousReleaseId;
           const gate = await gateManagedSuccessor({
             layout,
             runtimeDir,
@@ -19135,7 +19524,18 @@ async function runStoredDaemon(pathOrPointer) {
               config,
               runtimeDir,
               releaseId: loadedRelease ?? "unknown",
-              sandboxRequired: runtime.sandbox !== "off"
+              sandboxRequired: runtime.sandbox !== "off",
+              ...currentReleaseId ? {
+                compareWithCurrentRelease: async (refusal) => {
+                  console.warn(`[thin-core] successor probe refused by the provider (${refusal.reason}); probing the current release ${currentReleaseId} for the same refusal`);
+                  await extendSystemdStartTimeout(CURRENT_RELEASE_PROBE_TIMEOUT_MS + 15e3);
+                  return probeReleaseInSubprocess({
+                    layout,
+                    releaseId: currentReleaseId,
+                    runtimeConfigPath: configPath
+                  });
+                }
+              } : {}
             })
           });
           if (gate.kind === "failed") {
@@ -19185,7 +19585,7 @@ async function runStoredDaemon(pathOrPointer) {
     throw error;
   } finally {
     await notifier.stopping(stoppingStatus).catch(() => void 0);
-    const pidPath = resolve25(dirname14(configPath), "daemon.pid");
+    const pidPath = resolve25(dirname15(configPath), "daemon.pid");
     const recorded = Number((await readFile13(pidPath, "utf8").catch(() => "")).trim());
     if (recorded === process.pid) {
       await unlink3(pidPath).catch(() => void 0);
@@ -19242,7 +19642,7 @@ async function main() {
     const agentPubkey = agentFlag >= 0 ? args[agentFlag + 1] : void 0;
     if (!configPath && agentPubkey) {
       const configs = await findAgentRuntimeConfigPaths(process.env, process.cwd());
-      configPath = configs.find((candidate) => dirname14(candidate).endsWith(agentPubkey));
+      configPath = configs.find((candidate) => dirname15(candidate).endsWith(agentPubkey));
     }
     if (!configPath && agentPubkey) {
       throw new DaemonExitError(`unknown agent ${agentPubkey}: no durable runtime exists; refusing systemd restart loop`, UNKNOWN_AGENT_EXIT_STATUS);
@@ -19256,6 +19656,10 @@ async function main() {
     await runUpdateCommand(args);
     return;
   }
+  if (command === UPDATE_PROBE_COMMAND) {
+    await runUpdateProbeCommand(args);
+    return;
+  }
   if (command === "start") {
     await runStartCommand(args, interactiveUi);
     return;
@@ -19266,7 +19670,7 @@ async function main() {
     if (!agentPubkey)
       throw new Error("stop requires --agent <pubkey>");
     const configs = await findAgentRuntimeConfigPaths(process.env, process.cwd());
-    const configPath = configs.find((candidate) => dirname14(candidate).endsWith(agentPubkey));
+    const configPath = configs.find((candidate) => dirname15(candidate).endsWith(agentPubkey));
     if (!configPath)
       throw new Error(`no stored runtime found for agent ${agentPubkey}`);
     const runtime = await readRuntimeRecord(configPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "usebeeline",
-  "version": "0.0.40",
+  "version": "0.0.44",
   "description": "Connect an AI coding agent to Beeline with one command.",
   "repository": {
     "type": "git",