usebeeline 0.0.58 → 0.0.62

package/README.md

@@ -41,12 +41,12 @@ npx usebeeline connect
 
 The command asks for the pairing code shown in the Beeline app, then four questions and no more:
 
-| Step | What it asks |
-| --- | --- |
-| Harness | Claude Code, Codex, Goose, Pi, or Grok |
-| Provider | Goose and Pi only — OpenRouter (default), OpenAI, Anthropic, Google, or xAI |
-| API key | Goose and Pi only — verified against the provider, then saved to `~/.config/beeline/providers.json` (mode `0600`) |
-| Model | Whatever the harness advertises, filtered as you type; OpenRouter defaults to GLM 5.3 Flash |
+| Step     | What it asks                                                                                                      |
+| -------- | ----------------------------------------------------------------------------------------------------------------- |
+| Harness  | Claude Code, Codex, Goose, Pi, or Grok                                                                            |
+| Provider | Goose and Pi only — OpenRouter (default), OpenAI, Anthropic, Google, or xAI                                       |
+| API key  | Goose and Pi only — verified against the provider, then saved to `~/.config/beeline/providers.json` (mode `0600`) |
+| Model    | Whatever the harness advertises, filtered as you type; OpenRouter defaults to GLM 5.3 Flash                       |
 
 It does **not** ask for a name or a soul. The server assigns the agent one of twelve animals nobody in your Workspace is already wearing, and prints it:
 
@@ -102,7 +102,7 @@ The corner receives a GitHub App token scoped to **that one repository**, instal
 - **When the sandbox cannot be built, the daemon says so and keeps serving.** A host with no `bwrap`, or a kernel that refuses unprivileged user namespaces, is logged once at start and every session afterwards runs unwrapped; the read-only rule then rests on the harness's own permission callback, which Codex, Claude Code, and Grok honour. Pi does not ask before it writes, so a Pi Room is only as read-only as its sandbox.
 - **Write access requires a corner.** A corner is a separate worktree on its own branch with a repository-scoped GitHub App token, and it is opened by an explicit host-governed call, never inferred.
 - **Reach outside the sandbox is a grant.** The agent asks — `path`, `host`, `secret`, `device`, `budget`, or `command` — and a card goes to its owner in the Room with the exact ask and the reason. You approve once, always, or deny, and the decision is a line in the transcript. Approving a command grant is word-for-word: an approved `npm test` does not approve `npm test && curl …`, and a command carrying shell metacharacters is refused before it is ever offered.
-- **Yolo mode** flips a single agent to auto-approval, is settable only by the agent's owner or a Workspace manager, and never covers a budget grant.
+- **Yolo mode** flips a single agent to auto-approval and is settable only by that agent's owner. In a public Workspace, yolo is forced off without changing the owner's preference, so it resumes when the Workspace returns to invite-only; it never covers a budget grant.
 - **Provider keys never reach Beeline's servers.** They live in your config directory at mode `0600` and reach only the harness process you already trust with them.
 - **Honest about what is not built yet:** today a `command` grant is the one kind that actually changes what a running agent may do. `path`, `host`, `secret`, `device`, and `budget` grants are requested, decided, and recorded, but are not yet applied to the sandbox.
 
@@ -124,24 +124,24 @@ Two MCP surfaces are mounted into every agent session.
 
 `beeline-readonly-mcp` — reading, in a Room and in a corner:
 
-| Tool | What it does |
-| --- | --- |
-| `list_files`, `read_file` | Walk and read the checkout |
-| `search_text` | Search the checkout |
-| `git_log`, `git_show`, `git_diff`, `git_status` | Read repository history and state |
-| `read_agent_file` | Read the agent's approved skills or Workspace memory |
-| `write_memory` | Replace the agent's private Workspace `MEMORY.md` — the only memory write a Room allows |
+| Tool                                            | What it does                                                                            |
+| ----------------------------------------------- | --------------------------------------------------------------------------------------- |
+| `list_files`, `read_file`                       | Walk and read the checkout                                                              |
+| `search_text`                                   | Search the checkout                                                                     |
+| `git_log`, `git_show`, `git_diff`, `git_status` | Read repository history and state                                                       |
+| `read_agent_file`                               | Read the agent's approved skills or Workspace memory                                    |
+| `write_memory`                                  | Replace the agent's private Workspace `MEMORY.md` — the only memory write a Room allows |
 
 `beeline-agent` — acting, host-governed:
 
-| Tool | Where | What it does |
-| --- | --- | --- |
-| `open_corner` | Top-level Rooms | Open one write-enabled corner with a ≤24-word objective |
-| `pr_checks_status` | Corners | Read the server-posted checks verdict and human hold state |
-| `attach_file` | Everywhere | Attach one file from the checkout or scratch dir to the reply |
-| `create_schedule`, `list_schedules`, `delete_schedule` | Everywhere | Run a prompt again later — interval minutes or a 5-field cron |
-| `request_grant` | Everywhere | Ask the owner for reach outside the sandbox |
-| `run_granted_command` | Everywhere | Run a command an approved grant covers, outside the sandbox |
+| Tool                                                   | Where           | What it does                                                  |
+| ------------------------------------------------------ | --------------- | ------------------------------------------------------------- |
+| `open_corner`                                          | Top-level Rooms | Open one write-enabled corner with a ≤24-word objective       |
+| `pr_checks_status`                                     | Corners         | Read the server-posted checks verdict and human hold state    |
+| `attach_file`                                          | Everywhere      | Attach one file from the checkout or scratch dir to the reply |
+| `create_schedule`, `list_schedules`, `delete_schedule` | Everywhere      | Run a prompt again later — interval minutes or a 5-field cron |
+| `request_grant`                                        | Everywhere      | Ask the owner for reach outside the sandbox                   |
+| `run_granted_command`                                  | Everywhere      | Run a command an approved grant covers, outside the sandbox   |
 
 ## The app
 

package/dist/usebeeline.mjs

@@ -8126,6 +8126,7 @@ async function syncAgentModelCatalog(input) {
 
 // apps/body/dist/daemon-api-client.js
 import { resolve as resolve7 } from "node:path";
+import { randomUUID } from "node:crypto";
 
 // node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -16940,12 +16941,11 @@ var DaemonApiClient = class {
   agentId;
   fetchImpl;
   webSocketFactory;
+  presenceLifecycleId = randomUUID();
   liveSocket;
   liveReconnect;
   liveReconnectDelayMs = 1e3;
   liveRooms = /* @__PURE__ */ new Map();
-  parityPending = /* @__PURE__ */ new Map();
-  parityMisses = /* @__PURE__ */ new Map();
   constructor(baseUrl, daemonToken, agentId, fetchImpl = fetch, webSocketFactory = (url, protocols) => new wrapper_default(url, protocols)) {
     this.baseUrl = baseUrl;
     this.daemonToken = daemonToken;
@@ -16957,18 +16957,21 @@ var DaemonApiClient = class {
   connection() {
     return { baseUrl: this.baseUrl, daemonToken: this.daemonToken, agentId: this.agentId };
   }
-  /** Add one Room to this agent's shared live socket. Polling remains active in Phase 2. */
-  liveSubscribe(roomId, cursor3, onItems) {
+  /** Add one Room to this agent's shared live socket. */
+  liveSubscribe(roomId, cursor3, onItems, onState, presence) {
     const existing = this.liveRooms.get(roomId);
     if (existing) {
       existing.cursor = cursor3 ?? existing.cursor;
       existing.onItems = onItems ?? existing.onItems;
+      existing.onState = onState ?? existing.onState;
+      existing.presence = presence ?? existing.presence;
     } else {
       this.liveRooms.set(roomId, {
         ...cursor3 ? { cursor: cursor3 } : {},
         pushedIds: /* @__PURE__ */ new Set(),
-        parityMissIds: /* @__PURE__ */ new Set(),
-        ...onItems ? { onItems } : {}
+        ...onItems ? { onItems } : {},
+        ...onState ? { onState } : {},
+        ...presence ? { presence } : {}
       });
     }
     this.ensureLiveSocket();
@@ -16976,11 +16979,6 @@ var DaemonApiClient = class {
       this.sendLiveSubscription(roomId);
     return () => {
       this.liveRooms.delete(roomId);
-      const pending = this.parityPending.get(roomId);
-      if (pending)
-        for (const timer of pending.values())
-          clearTimeout(timer);
-      this.parityPending.delete(roomId);
       if (this.liveSocket?.readyState === wrapper_default.OPEN) {
         this.liveSocket.send(JSON.stringify({ type: "unsubscribe", roomId }));
       }
@@ -16996,42 +16994,6 @@ var DaemonApiClient = class {
     if (room && cursor3)
       room.cursor = cursor3;
   }
-  /** Count a poll delivery only if push still has not produced its id after a grace window. */
-  notePolled(roomId, items) {
-    const room = this.liveRooms.get(roomId);
-    if (!room)
-      return;
-    const now2 = Date.now();
-    if (room.parityReportedAt === void 0 || now2 - room.parityReportedAt >= 6e4) {
-      room.parityReportedAt = now2;
-      console.info(`[thin-core] push parity room=${roomId} poll_only=${room.parityMissIds.size}`);
-    }
-    let pending = this.parityPending.get(roomId);
-    if (!pending) {
-      pending = /* @__PURE__ */ new Map();
-      this.parityPending.set(roomId, pending);
-    }
-    for (const item of items) {
-      if (room.pushedIds.has(item.id) || pending.has(item.id))
-        continue;
-      const timer = setTimeout(() => {
-        pending.delete(item.id);
-        if (room.pushedIds.has(item.id) || room.parityMissIds.has(item.id))
-          return;
-        room.parityMissIds.add(item.id);
-        while (room.parityMissIds.size > 1e4)
-          room.parityMissIds.delete(room.parityMissIds.values().next().value);
-        const count = room.parityMissIds.size;
-        this.parityMisses.set(roomId, count);
-        console.warn(`[thin-core] push parity miss room=${roomId} count=${count}`);
-      }, 5e3);
-      timer.unref?.();
-      pending.set(item.id, timer);
-    }
-  }
-  pushParityMissCount(roomId) {
-    return this.parityMisses.get(roomId) ?? 0;
-  }
   async execute(name, input) {
     const candidate = input;
     if (typeof candidate.agentId === "string" && candidate.agentId !== this.agentId) {
@@ -17052,7 +17014,9 @@ var DaemonApiClient = class {
   ensureLiveSocket() {
     if (this.liveSocket || !this.liveRooms.size)
       return;
-    const socket = this.webSocketFactory(this.baseUrl.replace(/^http/, "ws") + "/v1/phone/live", [`bearer.${this.daemonToken}`]);
+    const socket = this.webSocketFactory(this.baseUrl.replace(/^http/, "ws") + "/v1/phone/live", [
+      `bearer.${this.daemonToken}`
+    ]);
     this.liveSocket = socket;
     socket.onopen = () => {
       this.liveReconnectDelayMs = 1e3;
@@ -17069,6 +17033,14 @@ var DaemonApiClient = class {
       if (!value || typeof value !== "object")
         return;
       const event = value;
+      if (event.type === "subscribed" && typeof event.roomId === "string") {
+        const capabilities = event.capabilities;
+        this.liveRooms.get(event.roomId)?.onState?.(true, {
+          pushIntake: capabilities?.pushIntake === true,
+          connectionPresence: capabilities?.connectionPresence === true
+        });
+        return;
+      }
       if (event.type !== "inbox" || typeof event.roomId !== "string" || !Array.isArray(event.items))
         return;
       const room = this.liveRooms.get(event.roomId);
@@ -17083,14 +17055,6 @@ var DaemonApiClient = class {
           if (!room.pushedIds.has(id))
             items.push(candidate);
           room.pushedIds.add(id);
-          if (room.parityMissIds.delete(id)) {
-            this.parityMisses.set(event.roomId, room.parityMissIds.size);
-            console.info(`[thin-core] push parity room=${event.roomId} poll_only=${room.parityMissIds.size}`);
-          }
-          const pending = this.parityPending.get(event.roomId)?.get(id);
-          if (pending)
-            clearTimeout(pending);
-          this.parityPending.get(event.roomId)?.delete(id);
         }
       }
       while (room.pushedIds.size > 1e4)
@@ -17102,6 +17066,8 @@ var DaemonApiClient = class {
       if (this.liveSocket !== socket)
         return;
       this.liveSocket = void 0;
+      for (const room of this.liveRooms.values())
+        room.onState?.(false);
       if (!this.liveRooms.size)
         return;
       const delay = this.liveReconnectDelayMs;
@@ -17119,7 +17085,9 @@ var DaemonApiClient = class {
     this.liveSocket.send(JSON.stringify({
       type: "subscribe",
       roomId,
-      ...room.cursor ? { cursor: room.cursor } : {}
+      lifecycleId: this.presenceLifecycleId,
+      ...room.cursor ? { cursor: room.cursor } : {},
+      ...room.presence
     }));
   }
 };
@@ -18018,7 +17986,7 @@ import { promisify as promisify3 } from "node:util";
 
 // apps/body/dist/agent-home.js
 import { existsSync as existsSync3, readFileSync as readFileSync4 } from "node:fs";
-import { createHash as createHash3, randomUUID } from "node:crypto";
+import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
 import { chmod as chmod2, copyFile, lstat, mkdir as mkdir4, readFile as readFile6, readdir as readdir2, realpath, rename as rename2, rm as rm2, symlink, unlink, writeFile as writeFile5 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
 import { basename as basename3, dirname as dirname5, join as join3, relative as relative2, resolve as resolve13, sep } from "node:path";
@@ -18940,7 +18908,7 @@ async function provisionManagedSkillsDir(target, managedSkills, sharedSkills, op
   const plan = await planManagedSkills(managedSkills, sharedSkills, optionalShares);
   if (await materializedSkillManifest(target) === plan.manifest)
     return;
-  const staged = resolve13(parent, `.skills.${process.pid}.${randomUUID()}.tmp`);
+  const staged = resolve13(parent, `.skills.${process.pid}.${randomUUID2()}.tmp`);
   await mkdir4(staged, { mode: 448 });
   try {
     for (const entry of plan.entries) {
@@ -19192,7 +19160,7 @@ async function writeIsolatedHarnessFile(path, content) {
   if (!parentStats.isDirectory() || parentStats.isSymbolicLink()) {
     throw new Error(`isolated harness parent is not a real directory: ${parent}`);
   }
-  const temporary = resolve13(parent, `.${basename3(path)}.${process.pid}.${randomUUID()}.tmp`);
+  const temporary = resolve13(parent, `.${basename3(path)}.${process.pid}.${randomUUID2()}.tmp`);
   try {
     await writeFile5(temporary, content, { mode: 384, flag: "wx" });
     await chmod2(temporary, 384);
@@ -20807,6 +20775,14 @@ function cornerClosePollMs(random = Math.random) {
 var MonolithCornerTurnLoop = class {
   options;
   agent;
+  reconciliationRequested = true;
+  wakeIntake;
+  /** Called by the daemon's one slow workspace reconciliation sweep. */
+  requestReconciliation() {
+    this.reconciliationRequested = true;
+    this.wakeIntake?.();
+    this.wakeIntake = void 0;
+  }
   client;
   sessionId;
   /** The configuration the live session baked in; a change invalidates it. */
@@ -20951,11 +20927,9 @@ var MonolithCornerTurnLoop = class {
       })
     }) : {};
     const command = this.options.config.agentCommand ?? this.options.config.agentBinary;
-    let githubEnv = {
-      GH_TOKEN: this.options.githubToken,
-      GITHUB_TOKEN: this.options.githubToken
-    };
-    if (this.options.config.runtimeConfigPath && this.options.config.agentHomeRoot) {
+    const repository = this.options.repository;
+    let githubEnv = repository ? { GH_TOKEN: repository.githubToken, GITHUB_TOKEN: repository.githubToken } : {};
+    if (repository && this.options.config.runtimeConfigPath && this.options.config.agentHomeRoot) {
       const gitBinary = (await execFileAsync3("which", ["git"])).stdout.trim();
       const ghBinary = await execFileAsync3("which", ["gh"]).then((result) => result.stdout.trim()).catch(() => void 0);
       githubEnv = await installCornerGitHubWrappers({
@@ -20994,7 +20968,7 @@ var MonolithCornerTurnLoop = class {
         mode: "edit",
         cwd: this.options.worktreePath,
         worktreePath: this.options.worktreePath,
-        gitCommonDir: this.options.gitCommonDir,
+        ...repository ? { gitCommonDir: repository.gitCommonDir } : {},
         protectedPaths: [this.options.runtime.supervisorRoot],
         harnessStateDirs: stateDirs,
         harnessHomeStateDirs: homeStateDirs,
@@ -21017,19 +20991,21 @@ var MonolithCornerTurnLoop = class {
     this.client = (this.options.createAcpClient ?? ((value) => new AcpClient(value)))(clientOptions);
     await this.client.start();
     const servers = [
-      {
-        name: "buzz-dev-mcp",
-        command: this.options.config.mcpBinary,
-        args: [],
-        // ACP hosts launch stdio MCP servers with an explicit, sanitized env.
-        // This token is minted for this exact corner and is also the credential
-        // helper's password source, so its shell commands need the same scope as
-        // the corner harness without inheriting any host credentials.
-        env: [
-          { name: "GH_TOKEN", value: this.options.githubToken },
-          { name: "GITHUB_TOKEN", value: this.options.githubToken }
-        ]
-      },
+      ...repository ? [
+        {
+          name: "buzz-dev-mcp",
+          command: this.options.config.mcpBinary,
+          args: [],
+          // ACP hosts launch stdio MCP servers with an explicit, sanitized env.
+          // This token is minted for this exact corner and is also the credential
+          // helper's password source, so its shell commands need the same scope as
+          // the corner harness without inheriting any host credentials.
+          env: [
+            { name: "GH_TOKEN", value: repository.githubToken },
+            { name: "GITHUB_TOKEN", value: repository.githubToken }
+          ]
+        }
+      ] : [],
       beelineAgentMcpServer(this.options.config, this.options.api, {
         roomId: this.options.parentRoomId,
         workspaceId: this.options.workspaceId,
@@ -21060,17 +21036,23 @@ var MonolithCornerTurnLoop = class {
       systemPrompt: [
         identityInstructions,
         personaInstructions,
-        `You are in an isolated git worktree on ${this.options.featureBranch}, targeting ${this.options.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 ${this.options.featureBranch}. Run git pull --rebase origin ${this.options.featureBranch} before you push, and never force-push it.`,
-        "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.",
-        "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."
+        ...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.`,
+          "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.",
+          "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."
+        ] : [
+          "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.",
+          "Do not initialize a repository, create a branch, push, open a pull request, or wait for GitHub checks."
+        ]
       ].filter(Boolean).join("\n\n")
     });
     this.sessionId = opened.sessionId;
@@ -21203,7 +21185,7 @@ ${this.options.objective}`,
 ${trigger}`,
               ...attachmentPromptLines(attachments, delivered, this.acceptsImages())
             ].join("\n"),
-            "Continue the objective. Obey the PR checks and human hold rules in your session instructions.",
+            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.",
             MAINTAIN_ASSIGNED_IDENTITY_DIRECTIVE
           ].filter(Boolean).join("\n\n");
           const stream = new AgentTurnStream({
@@ -21353,10 +21335,13 @@ ${trigger}`,
    * fails with that sentence and the server inscribes it in the corner.
    */
   async syncBranch() {
-    const token = await this.options.api.execute("getRoomGitHubToken", { roomId: this.options.parentRoomId }).then((granted) => granted.token).catch(() => this.options.githubToken);
+    const repository = this.options.repository;
+    if (!repository)
+      return;
+    const token = await this.options.api.execute("getRoomGitHubToken", { roomId: this.options.parentRoomId }).then((granted) => granted.token).catch(() => repository.githubToken);
     await syncCornerBranch({
       worktreePath: this.options.worktreePath,
-      featureBranch: this.options.featureBranch,
+      featureBranch: repository.featureBranch,
       env: { ...process.env, GH_TOKEN: token, GITHUB_TOKEN: token, GIT_TERMINAL_PROMPT: "0" }
     });
   }
@@ -21384,15 +21369,23 @@ ${trigger}`,
     const processedInboxIds = /* @__PURE__ */ new Set();
     const pushedInbox = [];
     let pendingPushedCursor;
-    let wakeForPush;
+    let liveConnected = false;
     const rewindSupported = Array.isArray(activation.rewindIds);
     for (const id of activation.rewindIds ?? [])
       processedInboxIds.add(id);
     const stopLive = api.liveSubscribe?.(cornerId, cursor3, (items, pushedCursor) => {
       pushedInbox.push(...items);
       pendingPushedCursor = laterInboxCursor(pendingPushedCursor, pushedCursor);
-      wakeForPush?.();
-      wakeForPush = void 0;
+      this.wakeIntake?.();
+      this.wakeIntake = void 0;
+    }, (connected, capabilities) => {
+      liveConnected = connected && capabilities?.pushIntake === true;
+      this.wakeIntake?.();
+      this.wakeIntake = void 0;
+    }, {
+      ...this.options.config.daemonReleaseVersion ? { releaseVersion: this.options.config.daemonReleaseVersion } : {},
+      ...this.options.config.daemonSourceSha ? { sourceSha: this.options.config.daemonSourceSha } : {},
+      available: !this.options.config.modelUnavailable
     });
     const history = await api.execute("getRoomConversation", { roomId: cornerId, limit: 200 });
     await this.roster().catch(() => void 0);
@@ -21407,14 +21400,14 @@ ${trigger}`,
       let pollWithoutWait = false;
       while (!signal?.aborted) {
         try {
-          const pollNow = pushedInbox.length === 0;
+          const pollNow = pushedInbox.length > 0 || !liveConnected || this.reconciliationRequested;
           const inbox = !pollNow ? { items: [], cursor: void 0, closeRequested: false } : await api.execute("getCornerCloseRequests", {
             cornerId,
             ...cursor3 ? { after: cursor3 } : {},
             ...rewindSupported ? { rewind: true } : {}
           });
           if (pollNow) {
-            api.notePolled?.(cornerId, inbox.items.filter((item) => !processedInboxIds.has(item.id)));
+            this.reconciliationRequested = false;
           }
           if (inbox.closeRequested) {
             await this.options.onCloseRequested();
@@ -21473,10 +21466,9 @@ This answers your grant request; resume the paused work. If approved and it is a
           if (pollNow)
             this.options.onPoll();
           await Promise.race([
-            wait(pollWithoutWait ? 0 : this.options.pollMs ?? cornerClosePollMs(), signal),
-            waitForWake(api, cornerId, signal),
+            wait(pollWithoutWait ? 0 : liveConnected ? 2147483647 : this.options.pollMs ?? cornerClosePollMs(), signal),
             pushedInbox.length ? Promise.resolve() : new Promise((resolve30) => {
-              wakeForPush = resolve30;
+              this.wakeIntake = resolve30;
             })
           ]);
           pollWithoutWait = false;
@@ -21490,27 +21482,12 @@ This answers your grant request; resume the paused work. If approved and it is a
       }
     } finally {
       stopLive?.();
+      this.wakeIntake = void 0;
       this.options.grantRunner?.unregister(cornerId);
       await this.options.scheduler.suspend(cornerId);
     }
   }
 };
-async function waitForWake(api, cornerId, signal) {
-  if (signal?.aborted)
-    return;
-  try {
-    await api.execute("waitForCornerWake", { cornerId });
-  } catch {
-    await never(signal);
-  }
-}
-async function never(signal) {
-  if (signal?.aborted)
-    return;
-  await new Promise((resolveNever) => {
-    signal?.addEventListener("abort", () => resolveNever(), { once: true });
-  });
-}
 async function wait(ms, signal) {
   if (signal?.aborted)
     return;
@@ -21658,6 +21635,14 @@ function agentReplyMentionIds(text2, roster, authorId) {
 var MonolithRoomTurnLoop = class {
   options;
   agent;
+  reconciliationRequested = true;
+  wakeIntake;
+  /** Called by the daemon's one slow workspace reconciliation sweep. */
+  requestReconciliation() {
+    this.reconciliationRequested = true;
+    this.wakeIntake?.();
+    this.wakeIntake = void 0;
+  }
   client;
   sessionId;
   /** The configuration the live session baked in; a change invalidates it. */
@@ -22251,25 +22236,11 @@ var MonolithRoomTurnLoop = class {
   }
   async run() {
     const { api, roomId, signal } = this.options;
-    const status = this.options.config.modelUnavailable ? "offline" : "online";
-    const postPresence = async (presence) => {
-      await api.execute("postAgentPresence", {
-        agentId: this.agent.publicKey,
-        roomId,
-        status: presence,
-        ...this.options.config.daemonReleaseVersion ? { releaseVersion: this.options.config.daemonReleaseVersion } : {},
-        ...this.options.config.daemonSourceSha ? { sourceSha: this.options.config.daemonSourceSha } : {}
-      });
-      this.options.health.presence(presence);
-    };
-    await postPresence(status);
-    const heartbeat = setInterval(() => void postPresence(status).catch((error) => console.error(`[thin-core] monolith Room ${roomId} presence heartbeat failed:`, error)), 3e4);
-    heartbeat.unref?.();
     let cursor3;
     const processedInboxIds = /* @__PURE__ */ new Set();
     const pushedInbox = [];
     let pendingPushedCursor;
-    let wakeForPush;
+    let liveConnected = false;
     let stopLive;
     try {
       const activation = await api.execute("getRoomInbox", { roomId, startAtLatest: true });
@@ -22280,15 +22251,24 @@ var MonolithRoomTurnLoop = class {
       stopLive = api.liveSubscribe?.(roomId, cursor3, (items, pushedCursor) => {
         pushedInbox.push(...items);
         pendingPushedCursor = laterInboxCursor(pendingPushedCursor, pushedCursor);
-        wakeForPush?.();
-        wakeForPush = void 0;
+        this.wakeIntake?.();
+        this.wakeIntake = void 0;
+      }, (connected, capabilities) => {
+        liveConnected = connected && capabilities?.pushIntake === true;
+        this.options.health.presence(connected && !this.options.config.modelUnavailable ? "online" : "offline");
+        this.wakeIntake?.();
+        this.wakeIntake = void 0;
+      }, {
+        ...this.options.config.daemonReleaseVersion ? { releaseVersion: this.options.config.daemonReleaseVersion } : {},
+        ...this.options.config.daemonSourceSha ? { sourceSha: this.options.config.daemonSourceSha } : {},
+        available: !this.options.config.modelUnavailable
       });
       while (!signal?.aborted) {
         try {
           if (!this.activeTurn && this.queuedTurns.length) {
             this.startPrompt(this.queuedTurns.shift());
           }
-          const pollNow = pushedInbox.length === 0;
+          const pollNow = pushedInbox.length === 0 && (!liveConnected || this.reconciliationRequested);
           const inbox = !pollNow ? { items: [], cursor: void 0 } : await api.execute("getRoomInbox", {
             roomId,
             ...cursor3 ? { after: cursor3 } : {},
@@ -22296,7 +22276,7 @@ var MonolithRoomTurnLoop = class {
             limit: 200
           });
           if (pollNow) {
-            api.notePolled?.(roomId, inbox.items.filter((item) => !processedInboxIds.has(item.id)));
+            this.reconciliationRequested = false;
           }
           const delivered = [...pushedInbox.splice(0), ...inbox.items];
           for (const item of delivered) {
@@ -22331,9 +22311,9 @@ var MonolithRoomTurnLoop = class {
             this.options.health.poll();
           if (!pushedInbox.length) {
             await Promise.race([
-              wait2(this.options.pollMs ?? 1e3, signal),
+              wait2(liveConnected ? 2147483647 : this.options.pollMs ?? 1e3, signal),
               new Promise((resolve30) => {
-                wakeForPush = resolve30;
+                this.wakeIntake = resolve30;
               })
             ]);
           }
@@ -22347,13 +22327,12 @@ var MonolithRoomTurnLoop = class {
       }
     } finally {
       stopLive?.();
-      clearInterval(heartbeat);
+      this.wakeIntake = void 0;
       this.options.grantRunner?.unregister(roomId);
       if (this.activeTurn?.phase === "prompting" && this.client && this.sessionId) {
         this.client.sessionCancel(this.sessionId);
       }
       await this.activeTurn?.promise;
-      await postPresence("offline").catch((error) => console.error(`[thin-core] monolith Room ${roomId} offline presence failed:`, error));
       await this.options.scheduler.suspend(roomId);
     }
   }
@@ -22844,7 +22823,14 @@ async function materializeCornerWorktree(input) {
     "credential.https://github.com.helper",
     "!f() { echo username=x-access-token; echo password=$GH_TOKEN; }; f"
   ]);
-  await execFileAsync4("git", ["-C", path, "config", "--worktree", "user.name", input.committer.name]);
+  await execFileAsync4("git", [
+    "-C",
+    path,
+    "config",
+    "--worktree",
+    "user.name",
+    input.committer.name
+  ]);
   await execFileAsync4("git", [
     "-C",
     path,
@@ -22873,6 +22859,13 @@ async function mapWithConcurrency(values, limit, visit) {
   }));
 }
 var execFileAsync4 = promisify4(execFile5);
+async function removeCornerScratchWorkspace(input) {
+  const expected = resolve19(input.roomRoot, "scratch");
+  if (resolve19(input.scratchPath) !== expected) {
+    throw new Error(`refusing to remove scratch outside corner ${input.cornerId}`);
+  }
+  await rm4(expected, { recursive: true, force: true });
+}
 var RoomRuntimeCoordinator = class {
   configPath;
   baseConfig;
@@ -23037,6 +23030,8 @@ var RoomRuntimeCoordinator = class {
       await running.promise.catch(() => void 0);
       if (running.worktree)
         await this.reapCornerWorktree(running.worktree);
+      else if (running.scratch)
+        await this.reapCornerScratch(running.scratch);
     }
     await mapWithConcurrency(desiredTopRooms, ROOM_JOIN_CONCURRENCY, async (roomId) => {
       if (!this.running.has(roomId))
@@ -23046,6 +23041,8 @@ var RoomRuntimeCoordinator = class {
       if (!this.running.has(corner.cornerId))
         await this.startCorner(corner);
     });
+    for (const running of this.running.values())
+      running.body.requestReconciliation();
     return "member";
   }
   roomRecord(roomId) {
@@ -23069,8 +23066,7 @@ var RoomRuntimeCoordinator = class {
       return void 0;
     }
   }
-  roomConfig(roomId) {
-    const workspaceRoot = this.roomRoot(roomId);
+  roomConfig(roomId, workspaceRoot = this.roomRoot(roomId)) {
     const agentHomeRoot = this.roomAgentHomeRoot(workspaceRoot, true);
     return {
       ...this.baseConfig,
@@ -23174,7 +23170,7 @@ var RoomRuntimeCoordinator = class {
       return;
     this.startingCorners.add(corner.cornerId);
     try {
-      const [restore, repository, conversation, granted] = await Promise.all([
+      const [restore, repository, conversation] = await Promise.all([
         this.options.daemonApi.execute("getCornerRestoreState", { cornerId: corner.cornerId }),
         this.options.daemonApi.execute("getRoomRepositoryState", {
           roomId: corner.parentRoomId
@@ -23186,28 +23182,35 @@ var RoomRuntimeCoordinator = class {
           roomId: corner.cornerId,
           limit: 200,
           window: "earliest"
-        }),
-        this.options.daemonApi.execute("getRoomGitHubToken", {
-          roomId: corner.parentRoomId
         })
       ]);
-      if (repository.resolution !== "repository" || !repository.remote || !repository.key) {
-        throw new Error("corner parent Room has no verified repository binding");
+      if (repository.resolution === "unverified") {
+        throw new Error("corner parent Room repository state is not verified yet");
+      }
+      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();
       if (!objective)
         throw new Error("corner has no durable objective post");
-      const targetBranch = repository.targetBranch || "main";
-      const featureBranch = restore.featureBranch ?? `feature/corner-${corner.cornerId.replaceAll("-", "").slice(0, 12)}`;
-      const worktree = await this.materializeCornerWorktree({
+      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;
+      const granted = repositoryBacked ? await this.options.daemonApi.execute("getRoomGitHubToken", {
+        roomId: corner.parentRoomId
+      }) : void 0;
+      const worktree = repositoryBacked ? await this.materializeCornerWorktree({
         cornerId: corner.cornerId,
         remote: repository.remote,
         targetBranch,
         featureBranch,
         token: granted.token
-      });
+      }) : void 0;
+      const workspacePath = worktree?.path ?? resolve19(this.roomRoot(corner.cornerId), "scratch");
+      if (!worktree)
+        await mkdir11(workspacePath, { recursive: true, mode: 448 });
       const isOpener = !corner.openedBy || corner.openedBy === this.agent.publicKey;
-      if (shouldPostInitialCornerWorkingState(restore, isOpener)) {
+      if (worktree && shouldPostInitialCornerWorkingState(restore, isOpener)) {
         await this.options.daemonApi.execute("postCornerRemoteState", {
           cornerId: corner.cornerId,
           branch: featureBranch,
@@ -23226,23 +23229,27 @@ var RoomRuntimeCoordinator = class {
         workspaceId: this.runtime.communityId,
         ...corner.openedBy ? { openedBy: corner.openedBy } : {},
         objective,
-        featureBranch,
-        targetBranch,
-        worktreePath: worktree.path,
-        gitCommonDir: worktree.gitCommonDir,
-        githubToken: granted.token,
+        worktreePath: workspacePath,
+        ...worktree ? {
+          repository: {
+            featureBranch,
+            targetBranch,
+            gitCommonDir: worktree.gitCommonDir,
+            githubToken: granted.token
+          }
+        } : {},
         runtime: this.runtime,
-        config: this.roomConfig(corner.cornerId),
+        config: this.roomConfig(corner.cornerId, worktree ? void 0 : workspacePath),
         api: this.options.daemonApi,
         scheduler: this.scheduler,
         signal: controller.signal,
         onPoll: () => this.notePoll(corner.cornerId),
         onFailure: (retryInMs) => this.noteFailure(corner.cornerId, retryInMs),
-        onCloseRequested: () => this.reapCornerWorktree({
+        onCloseRequested: () => worktree ? this.reapCornerWorktree({
           ...worktree,
           cornerId: corner.cornerId,
           branch: featureBranch
-        })
+        }) : this.reapCornerScratch({ path: workspacePath, cornerId: corner.cornerId })
       });
       const promise = loop.run().catch((error) => {
         if (!controller.signal.aborted) {
@@ -23260,14 +23267,17 @@ var RoomRuntimeCoordinator = class {
         lastPollAt: startedAt,
         backoffUntil: 0,
         recovering: false,
-        worktree: {
-          ...worktree,
-          cornerId: corner.cornerId,
-          branch: featureBranch
-        }
+        ...worktree ? {
+          worktree: {
+            ...worktree,
+            cornerId: corner.cornerId,
+            branch: featureBranch
+          }
+        } : {},
+        ...!worktree ? { scratch: { path: workspacePath, cornerId: corner.cornerId } } : {}
       });
       this.reportedCornerStartFailures.delete(corner.cornerId);
-      console.log(`[thin-core] serving corner ${corner.cornerId} on ${featureBranch} at ${worktree.path}`);
+      console.log(worktree ? `[thin-core] serving corner ${corner.cornerId} on ${featureBranch} at ${workspacePath}` : `[thin-core] serving chat-only corner ${corner.cornerId} at ${workspacePath}`);
     } catch (error) {
       console.error(`[thin-core] failed to start corner ${corner.cornerId}:`, error);
       await this.reportCornerStartFailure(corner.cornerId, error);
@@ -23334,6 +23344,13 @@ var RoomRuntimeCoordinator = class {
       checks: "unknown"
     });
   }
+  async reapCornerScratch(scratch) {
+    await removeCornerScratchWorkspace({
+      cornerId: scratch.cornerId,
+      roomRoot: this.roomRoot(scratch.cornerId),
+      scratchPath: scratch.path
+    });
+  }
   notePoll(roomId) {
     const room = this.running.get(roomId);
     if (!room)

package/package.json

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