usebeeline 0.0.72 → 0.0.90

package/dist/usebeeline.mjs

@@ -19777,7 +19777,8 @@ function sessionConfigFingerprint(input) {
     input.effort ?? "",
     input.soul?.name ?? "",
     input.soul?.instructions ?? "",
-    input.agentName ?? ""
+    input.agentName ?? "",
+    input.yoloMode ?? false
   ]);
 }
 
@@ -19968,9 +19969,6 @@ export default async function (pi) {
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
 var execFileAsync2 = promisify2(execFile3);
-var CornerBranchDivergedError = class extends Error {
-  name = "CornerBranchDivergedError";
-};
 async function syncCornerBranch(input) {
   const git = input.git ?? (async (args) => (await execFileAsync2("git", ["-C", input.worktreePath, ...args], {
     ...input.env ? { env: input.env } : {},
@@ -19996,22 +19994,15 @@ async function syncCornerBranch(input) {
   try {
     await git(behind ? ["merge", "--ff-only", remote] : ["rebase", remote]);
     return behind ? "fast-forwarded" : "rebased";
-  } catch (error) {
+  } catch {
     await git(["rebase", "--abort"]).catch(() => void 0);
-    throw new CornerBranchDivergedError(divergedReason(input.featureBranch, error));
+    await git(["reset", "--hard", remote]);
+    return "realigned";
   }
 }
 async function contains(git, head, ancestor) {
   return git(["merge-base", "--is-ancestor", ancestor, head]).then(() => true, () => false);
 }
-function divergedReason(featureBranch, error) {
-  const detail = String(error?.stderr ?? "").split("\n").map((line) => line.trim()).find((line) => /conflict|could not|error:/i.test(line));
-  return [
-    `could not rebase onto origin/${featureBranch}: another agent pushed to this corner's branch`,
-    detail ? ` (${detail})` : "",
-    ". Nothing was pushed; the branch needs a person."
-  ].join("").slice(0, 200);
-}
 
 // apps/body/dist/room-session.js
 import { resolve as resolve15 } from "node:path";
@@ -21382,8 +21373,6 @@ var MonolithRoomTurnLoop = class {
           const buildPrompt = () => [
             this.turnInstructionPrefix,
             WarmTranscript.render(this.warmTranscript.select(this.sessionId, transcriptRows), "Room conversation so far:", "New in the Room since your last turn (the earlier conversation is already in this session):"),
-            `Newest message from ${inboxItemAuthorName(item, this.agent.publicKey, names)}:`,
-            roomMessagePrompt("", inboxItemPromptBody(item, this.agent.publicKey), item.attachments, delivered, this.acceptsImages()),
             grantDecision ? [
               "This is the answer to your grant request; your paused work resumes now.",
               "If it was approved and it is a command grant, run it with run_granted_command and the exact argv.",
@@ -21393,9 +21382,11 @@ var MonolithRoomTurnLoop = class {
             [
               "Write only the substantive Room message you want the human to read.",
               "Do not repeat or paraphrase these instructions.",
-              "If the newest message is only a nudge to respond, answer the most recent unanswered human message in the conversation instead of echoing the nudge.",
+              "If the current task is only a nudge to respond, answer the most recent unanswered human message in the conversation instead of echoing the nudge.",
               MAINTAIN_ASSIGNED_IDENTITY_DIRECTIVE
-            ].join(" ")
+            ].join(" "),
+            `Current task selected by the server from ${inboxItemAuthorName(item, this.agent.publicKey, names)}:`,
+            roomMessagePrompt("", inboxItemPromptBody(item, this.agent.publicKey), item.attachments, delivered, this.acceptsImages())
           ].filter(Boolean).join("\n\n");
           const stream = new AgentTurnStream({
             api,
@@ -21571,6 +21562,9 @@ var execFileAsync3 = promisify3(execFile4);
 var TOOL_ARGUMENT_MAX_BYTES = 1200;
 var TOOL_OUTPUT_MAX_BYTES = 3200;
 var TOOL_PATH_LIMIT = 12;
+function cornerMergeInstruction(yoloMode) {
+  return yoloMode ? "Yolo mode is on: when that merge gate passes, merge this pull request yourself with gh." : "Yolo mode is off: never merge the pull request yourself; leave it for human approval in the app.";
+}
 function oneLine(value) {
   return value.replace(/\s+/g, " ").trim();
 }
@@ -21831,7 +21825,8 @@ var MonolithCornerTurnLoop = class {
       model: configuration.model ?? this.options.config.modelSelection?.model,
       effort: configuration.effort ?? this.options.config.modelSelection?.effort,
       soul: configuration.soul ?? self?.soul,
-      agentName: self?.name ?? this.agent.name
+      agentName: self?.name ?? this.agent.name,
+      yoloMode: configuration.yoloMode
     });
   }
   async activate(trace) {
@@ -21850,7 +21845,8 @@ var MonolithCornerTurnLoop = class {
       model: configuration.model ?? this.options.config.modelSelection?.model,
       effort: configuration.effort ?? this.options.config.modelSelection?.effort,
       soul: configuration.soul ?? self?.soul,
-      agentName: self?.name ?? this.agent.name
+      agentName: self?.name ?? this.agent.name,
+      yoloMode: configuration.yoloMode
     });
     await mkdir11(this.options.worktreePath, { recursive: true });
     const selection = configuration.model || configuration.effort ? { model: configuration.model, effort: configuration.effort } : this.options.config.modelSelection;
@@ -21981,16 +21977,13 @@ var MonolithCornerTurnLoop = class {
         personaInstructions,
         ...repository ? [
           `You are in an isolated git worktree on ${repository.featureBranch}, targeting ${repository.targetBranch}.`,
-          "Work normally with the full coding tools. Commit and push only this feature branch. Use gh to open its pull request.",
-          `This corner is shared: any of its member agents may be addressed in it and work on ${repository.featureBranch}. Run git pull --rebase origin ${repository.featureBranch} before you push, and never force-push it.`,
+          `Work normally, then commit and push only ${repository.featureBranch}; never force-push or write to ${repository.targetBranch}. Open its pull request with gh. Before each push, rebase on origin/${repository.featureBranch}; resolve conflicts autonomously and rerun affected tests.`,
           "PR-opening turn rule: as soon as a pull request exists, print its full GitHub URL as your final response and end the turn immediately. Do not call pr_checks_status in that same turn and do not wait for checks inside it. Then stay idle until a later corner fact or human message starts another turn.",
-          'Never merge because local tests pass or because gh reports passing checks. On a later turn triggered by a server-posted checks-passed note, call beeline-agent pr_checks_status. Merge only when it returns checks="passed", held=false, and approvalPending=false.',
-          "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.",
+          'On a later server checks turn, call beeline-agent pr_checks_status. Never merge unless it returns checks="passed", held=false, and approvalPending=false; a human hold remains until a later human explicitly resumes.',
+          cornerMergeInstruction(configuration.yoloMode),
           "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."
+          "When approval is pending, wait for the server close request. Never merge a different pull request."
         ] : [
           "This is a chat-only corner with no repository or GitHub workflow.",
           "Work in this corner's writable workspace. Use write_scratch_file or ordinary tools to create files, then attach_file to send them back to the corner.",
@@ -22320,8 +22313,8 @@ ${trigger}`,
    * The branch is the shared artifact: another member agent may have pushed to
    * it since this helper last looked, and a first touch of a corner this
    * helper did not open starts from whatever `room-runtime.ts` restored. A
-   * divergence this cannot rebase away is raised, not pushed over — the turn
-   * fails with that sentence and the server inscribes it in the corner.
+   * conflicting local commits are realigned to that remote branch so the
+   * fixed objective can be attempted again without clobbering a sibling push.
    */
   async syncBranch() {
     const repository = this.options.repository;
@@ -22781,6 +22774,7 @@ var ROOM_JOIN_CONCURRENCY = 4;
 var DEFAULT_ROOM_WATCHDOG_STALE_MS = 9e4;
 var DEFAULT_RECONCILE_HEARTBEAT_MS = 6e4;
 var DEFAULT_DRAIN_DEADLINE_MS = 30 * 6e4;
+var CORNER_BRANCH_DELETE_ATTEMPTS = 3;
 function shouldPostInitialCornerWorkingState(restore, isOpener = true) {
   return isOpener && !restore.featureBranch && !restore.lifecycle?.branch && !restore.lifecycle?.pr;
 }
@@ -22873,6 +22867,52 @@ async function mapWithConcurrency(values, limit, visit) {
     }
   }));
 }
+async function removeCornerWorktreeAndBranches(worktree) {
+  const localRef = `refs/heads/${worktree.branch}`;
+  const remoteRef = `refs/heads/${worktree.branch}`;
+  const worktreeExists = existsSync4(worktree.path);
+  const localExists = await gitRefExists(worktree.gitCommonDir, localRef);
+  if (worktreeExists) {
+    const checkedOut = await execFileAsync4("git", [
+      "-C",
+      worktree.path,
+      "symbolic-ref",
+      "--quiet",
+      "HEAD"
+    ]);
+    if (checkedOut.stdout.trim() !== localRef) {
+      throw new Error(`corner worktree branch mismatch: expected ${localRef}`);
+    }
+    await execFileAsync4("git", [
+      `--git-dir=${worktree.gitCommonDir}`,
+      "worktree",
+      "remove",
+      "--force",
+      worktree.path
+    ]);
+  } else if (!localExists) {
+    await deleteExactRemoteBranch(worktree.gitCommonDir, remoteRef, worktree.token, {
+      requireAbsent: true
+    });
+    return;
+  } else {
+    const head = await repositoryHeadRef(worktree.gitCommonDir);
+    if (head === localRef) {
+      throw new Error(`refusing to delete repository HEAD ${localRef}`);
+    }
+  }
+  await deleteExactRemoteBranch(worktree.gitCommonDir, remoteRef, worktree.token);
+  if (await gitRefExists(worktree.gitCommonDir, localRef)) {
+    await execFileAsync4("git", [
+      `--git-dir=${worktree.gitCommonDir}`,
+      "branch",
+      "--delete",
+      "--force",
+      "--",
+      worktree.branch
+    ]);
+  }
+}
 var execFileAsync4 = promisify4(execFile5);
 async function removeCornerScratchWorkspace(input) {
   const expected = resolve19(input.roomRoot, "scratch");
@@ -22887,6 +22927,8 @@ var RoomRuntimeCoordinator = class {
   options;
   runtime;
   running = /* @__PURE__ */ new Map();
+  /** Close/reconcile leftovers retried until local and remote refs are gone. */
+  pendingCornerReaps = /* @__PURE__ */ new Map();
   startingCorners = /* @__PURE__ */ new Set();
   /** Corners whose start failure has already been said out loud, once each. */
   reportedCornerStartFailures = /* @__PURE__ */ new Set();
@@ -23029,6 +23071,7 @@ var RoomRuntimeCoordinator = class {
     });
     for (const channelId of desired)
       this.roomRemovalConfirmations.delete(channelId);
+    await this.retryPendingCornerReaps(desired);
     for (const [channelId, running] of [...this.running]) {
       if (desired.has(channelId))
         continue;
@@ -23040,10 +23083,15 @@ var RoomRuntimeCoordinator = class {
       }
       running.controller.abort();
       await running.promise.catch(() => void 0);
-      if (running.worktree)
-        await this.reapCornerWorktree(running.worktree);
-      else if (running.scratch)
-        await this.reapCornerScratch(running.scratch);
+      try {
+        if (running.worktree)
+          await this.reapCornerWorktree(running.worktree);
+        else if (running.scratch)
+          await this.reapCornerScratch(running.scratch);
+      } catch (error) {
+        console.error(`[thin-core] corner ${channelId} cleanup failed; will retry:`, error);
+        this.confirmationPending = true;
+      }
     }
     await mapWithConcurrency(desiredTopRooms, ROOM_JOIN_CONCURRENCY, async (roomId) => {
       if (!this.running.has(roomId))
@@ -23182,18 +23230,10 @@ var RoomRuntimeCoordinator = class {
       return;
     this.startingCorners.add(corner.cornerId);
     try {
-      const [restore, repository, conversation] = await Promise.all([
+      const [restore, repository] = await Promise.all([
         this.options.daemonApi.execute("getCornerRestoreState", { cornerId: corner.cornerId }),
         this.options.daemonApi.execute("getRoomRepositoryState", {
           roomId: corner.parentRoomId
-        }),
-        // Startup recovers the objective from the corner's FIRST durable
-        // message, so this is the one conversation read that wants the oldest
-        // end of the Room. Every other read defaults to the newest page.
-        this.options.daemonApi.execute("getRoomConversation", {
-          roomId: corner.cornerId,
-          limit: 200,
-          window: "earliest"
         })
       ]);
       if (repository.resolution === "unverified") {
@@ -23202,9 +23242,9 @@ var RoomRuntimeCoordinator = class {
       if (repository.resolution === "repository" && (!repository.remote || !repository.key)) {
         throw new Error("corner parent Room has an incomplete repository binding");
       }
-      const objective = conversation.items.find((item) => item.type === "message")?.body.trim();
+      const objective = restore.objective.trim();
       if (!objective)
-        throw new Error("corner has no durable objective post");
+        throw new Error("corner has no authoritative objective fact");
       const repositoryBacked = repository.resolution === "repository";
       const targetBranch = repositoryBacked ? repository.targetBranch || "main" : void 0;
       const featureBranch = repositoryBacked ? restore.featureBranch ?? `feature/corner-${corner.cornerId.replaceAll("-", "").slice(0, 12)}` : void 0;
@@ -23260,7 +23300,9 @@ var RoomRuntimeCoordinator = class {
         onCloseRequested: () => worktree ? this.reapCornerWorktree({
           ...worktree,
           cornerId: corner.cornerId,
-          branch: featureBranch
+          branch: featureBranch,
+          parentRoomId: corner.parentRoomId,
+          token: ""
         }) : this.reapCornerScratch({ path: workspacePath, cornerId: corner.cornerId })
       });
       const promise = loop.run().catch((error) => {
@@ -23283,7 +23325,9 @@ var RoomRuntimeCoordinator = class {
           worktree: {
             ...worktree,
             cornerId: corner.cornerId,
-            branch: featureBranch
+            branch: featureBranch,
+            parentRoomId: corner.parentRoomId,
+            token: ""
           }
         } : {},
         ...!worktree ? { scratch: { path: workspacePath, cornerId: corner.cornerId } } : {}
@@ -23339,22 +23383,40 @@ var RoomRuntimeCoordinator = class {
       committer: { name: this.agent.name, publicKey: this.agent.publicKey }
     });
   }
+  async retryPendingCornerReaps(desired) {
+    for (const [cornerId, worktree] of [...this.pendingCornerReaps]) {
+      if (desired.has(cornerId)) {
+        this.pendingCornerReaps.delete(cornerId);
+        continue;
+      }
+      try {
+        await this.reapCornerWorktree(worktree);
+      } catch (error) {
+        console.error(`[thin-core] corner ${cornerId} branch cleanup retry failed:`, error);
+        this.confirmationPending = true;
+      }
+    }
+  }
   async reapCornerWorktree(worktree) {
-    if (existsSync4(worktree.path)) {
-      await execFileAsync4("git", [
-        `--git-dir=${worktree.gitCommonDir}`,
-        "worktree",
-        "remove",
-        "--force",
-        worktree.path
-      ]);
+    try {
+      const parentRoomId = worktree.parentRoomId;
+      if (!parentRoomId) {
+        throw new Error(`corner ${worktree.cornerId} has no parent Room for GitHub token`);
+      }
+      const token = (await this.options.daemonApi.execute("getRoomGitHubToken", { roomId: parentRoomId })).token;
+      await removeCornerWorktreeAndBranches({ ...worktree, token });
+      await this.options.daemonApi.execute("postCornerRemoteState", {
+        cornerId: worktree.cornerId,
+        branch: worktree.branch,
+        state: "gone",
+        checks: "unknown"
+      });
+      this.pendingCornerReaps.delete(worktree.cornerId);
+    } catch (error) {
+      this.pendingCornerReaps.set(worktree.cornerId, { ...worktree, token: "" });
+      this.confirmationPending = true;
+      throw error;
     }
-    await this.options.daemonApi.execute("postCornerRemoteState", {
-      cornerId: worktree.cornerId,
-      branch: worktree.branch,
-      state: "gone",
-      checks: "unknown"
-    });
   }
   async reapCornerScratch(scratch) {
     await removeCornerScratchWorkspace({
@@ -23437,6 +23499,68 @@ function githubGitEnv(token) {
     GIT_TERMINAL_PROMPT: "0"
   };
 }
+async function gitRefExists(gitCommonDir, ref) {
+  try {
+    await execFileAsync4("git", [`--git-dir=${gitCommonDir}`, "show-ref", "--verify", "--quiet", ref]);
+    return true;
+  } catch (error) {
+    if (error.code === 1)
+      return false;
+    throw error;
+  }
+}
+async function repositoryHeadRef(gitCommonDir) {
+  try {
+    const head = await execFileAsync4("git", [
+      `--git-dir=${gitCommonDir}`,
+      "symbolic-ref",
+      "--quiet",
+      "HEAD"
+    ]);
+    return head.stdout.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function gitStderr(error) {
+  return typeof error === "object" && error && "stderr" in error ? String(error.stderr ?? "") : "";
+}
+function isRemoteRefMissing(error) {
+  return /remote ref does not exist|remote reference does not exist/i.test(`${error instanceof Error ? error.message : String(error)}
+${gitStderr(error)}`);
+}
+async function deleteExactRemoteBranch(gitCommonDir, remoteRef, token, options = {}) {
+  const authEnv = githubGitEnv(token);
+  const listRemote = () => execFileAsync4("git", [`--git-dir=${gitCommonDir}`, "ls-remote", "--heads", "origin", remoteRef], {
+    env: authEnv,
+    maxBuffer: 4 * 1024 * 1024
+  });
+  if (options.requireAbsent) {
+    const remote = await listRemote();
+    if (remote.stdout.trim()) {
+      throw new Error(`cannot delete ${remoteRef} without the local ref that proves this corner owns it`);
+    }
+    return;
+  }
+  let remoteError;
+  for (let attempt = 1; attempt <= CORNER_BRANCH_DELETE_ATTEMPTS; attempt += 1) {
+    try {
+      const remote = await listRemote();
+      if (remote.stdout.trim()) {
+        await execFileAsync4("git", [`--git-dir=${gitCommonDir}`, "push", "origin", `:${remoteRef}`], {
+          env: authEnv,
+          maxBuffer: 4 * 1024 * 1024
+        });
+      }
+      return;
+    } catch (error) {
+      if (isRemoteRefMissing(error))
+        return;
+      remoteError = error;
+    }
+  }
+  throw remoteError;
+}
 
 // apps/body/dist/thin-core.js
 async function waitForNextTick(ms, signal) {

package/package.json

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