usebeeline 0.0.104 → 0.0.106

package/README.md

@@ -141,7 +141,7 @@ Two MCP surfaces are mounted into every agent session.
 | ------------------------------------------------------ | --------------- | ------------------------------------------------------------- |
 | `open_corner`                                          | Top-level Rooms | Open one write-enabled corner with a ≤24-word objective       |
 | `pr_checks_status`                                     | Corners         | Read checks, human hold, and PR/head-bound merge approval     |
-| `attach_file`                                          | Everywhere      | Attach one file from the checkout or scratch dir to the reply |
+| `post_artifact`                                        | Everywhere      | Upload one file (path or html/bytes) as an attachment         |
 | `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   |

package/dist/usebeeline.mjs

@@ -3987,7 +3987,7 @@ __export(self_update_exports, {
 import { createHash as createHash7 } from "node:crypto";
 import { constants as fsConstants2 } from "node:fs";
 import { access, chmod as chmod5, lstat as lstat3, mkdir as mkdir15, open, readFile as readFile10, rename as rename4, rm as rm6, symlink as symlink3, writeFile as writeFile10 } from "node:fs/promises";
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 import { homedir as homedir9 } from "node:os";
 import { dirname as dirname11, join as join9, resolve as resolve22 } from "node:path";
 function anchorLayout(rawLibDir) {
@@ -4137,7 +4137,7 @@ async function fetchText(url, fetchImpl) {
 }
 function run(command, args, timeoutMs) {
   return new Promise((resolveRun) => {
-    const child = spawn4(command, args, { stdio: ["ignore", "ignore", "pipe"] });
+    const child = spawn6(command, args, { stdio: ["ignore", "ignore", "pipe"] });
     let stderr = "";
     child.stderr?.setEncoding("utf8");
     child.stderr?.on("data", (chunk) => {
@@ -4210,7 +4210,7 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
     }
     await writeFile10(tempArchive, Buffer.concat(chunks), { mode: 384 });
     const entries = (await new Promise((resolveList, rejectList) => {
-      const child = spawn4("tar", ["-tzf", tempArchive], { stdio: ["ignore", "pipe", "inherit"] });
+      const child = spawn6("tar", ["-tzf", tempArchive], { stdio: ["ignore", "pipe", "inherit"] });
       let out = "";
       child.stdout?.on("data", (chunk) => {
         out += chunk.toString("utf8");
@@ -6898,14 +6898,8 @@ var PI_ACP_HARNESS = /(^|[/\\])pi-acp(?:\.[a-z]+)?$/i;
 function isPiAcpHarness(agentLabel) {
   return Boolean(agentLabel && PI_ACP_HARNESS.test(agentLabel));
 }
-function withoutOneTrailingLineEnding(text2) {
-  if (/\r?\n\r?\n$/.test(text2))
-    return text2;
-  const stripped = text2.replace(/\r?\n$/, "");
-  return stripped || text2;
-}
-function normalizeStreamDelta(text2, agentLabel) {
-  return agentLabel && PI_ACP_HARNESS.test(agentLabel) ? withoutOneTrailingLineEnding(text2) : text2;
+function normalizeStreamDelta(text2, _agentLabel) {
+  return text2;
 }
 function agentMessageRuns(updates, agentLabel) {
   const runs = [];
@@ -8162,6 +8156,534 @@ async function syncAgentModelCatalog(input) {
   }
 }
 
+// apps/body/dist/connector-squire.js
+import { execFile, spawn as spawn2 } from "node:child_process";
+var REMOTE_LOGIN_BINARIES = ["xvfb-run", "Xvfb", "x11vnc", "websockify", "cloudflared"];
+var SQUIRE_CONNECT_PACKAGE = "@trusty-squire/mcp";
+var defaultShellRunner = (command, args) => new Promise((resolve31) => {
+  execFile(command, [...args], { timeout: 12e4, maxBuffer: 4 * 1024 * 1024, encoding: "utf8" }, (error, stdout6, stderr) => {
+    const code = error?.code;
+    resolve31({
+      code: typeof code === "number" ? code : error ? 1 : 0,
+      stdout: String(stdout6 ?? ""),
+      stderr: String(stderr ?? "")
+    });
+  });
+});
+var CONNECT_TIMEOUT_MS = 3e5;
+var defaultStreamedRunner = (command, args) => new Promise((resolve31) => {
+  const child = spawn2(command, args, {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  let stdout6 = "";
+  let stderr = "";
+  let resolved = false;
+  const safetyTimer = setTimeout(() => {
+    if (!resolved) {
+      resolved = true;
+      resolve31({ stdout: stdout6, stderr, signIn: void 0, abort: () => {
+      } });
+    }
+    child.kill();
+  }, CONNECT_TIMEOUT_MS);
+  const abort = () => {
+    clearTimeout(safetyTimer);
+    child.kill();
+  };
+  const finish = (result) => {
+    if (!resolved) {
+      resolved = true;
+      clearTimeout(safetyTimer);
+      resolve31(result);
+    }
+  };
+  const checkOutput = () => {
+    const combined = `${stdout6}
+${stderr}`;
+    const signIn = parseConnectOutput(combined);
+    if (signIn) {
+      finish({ stdout: stdout6, stderr, signIn, abort });
+    }
+  };
+  child.stdout?.on("data", (chunk) => {
+    stdout6 += String(chunk);
+    checkOutput();
+  });
+  child.stderr?.on("data", (chunk) => {
+    stderr += String(chunk);
+    checkOutput();
+  });
+  child.on("close", () => {
+    finish({ stdout: stdout6, stderr, signIn: void 0, abort: () => {
+    } });
+  });
+  child.on("error", () => {
+    finish({ stdout: stdout6, stderr, signIn: void 0, abort: () => {
+    } });
+  });
+});
+var step = (label, status, reason) => ({
+  label,
+  status,
+  ...reason ? { reason } : {}
+});
+function binaryExists(binary) {
+  return new Promise((resolve31) => {
+    execFile("sh", ["-c", `command -v ${JSON.stringify(binary)}`], (error, stdout6) => {
+      const path = String(stdout6 ?? "").trim();
+      resolve31({ binary, found: !error && path.length > 0, ...path ? { path } : {} });
+    });
+  });
+}
+async function checkRemoteLoginPrerequisites(probe = binaryExists) {
+  return Promise.all(REMOTE_LOGIN_BINARIES.map(probe));
+}
+function missingPrerequisiteStep(checks) {
+  const missing = checks.filter((check) => !check.found).map((check) => check.binary);
+  return step("remote sign-in prerequisites", "failed", `missing on this helper: ${missing.join(", ")}`);
+}
+function parseConnectOutput(output) {
+  const url = output.match(/https:\/\/[^\s"'<>]+/)?.[0];
+  if (!url)
+    return void 0;
+  if (/oauth|authorize/i.test(url) || /oauth/i.test(output)) {
+    return { method: "oauth", url };
+  }
+  if (/novnc|vnc\.html|remote|stream/i.test(url) || /novnc|remote login|vnc/i.test(output)) {
+    return { method: "streamed-page", url };
+  }
+  return { method: "streamed-page", url };
+}
+async function installedSquireVersion(run2) {
+  const probe = await run2("npx", ["-y", SQUIRE_CONNECT_PACKAGE, "--version"]);
+  const version = probe.stdout.match(/\d+\.\d+\.\d+[^\s]*/)?.[0];
+  return version;
+}
+function parseSignedInAs(output) {
+  return output.match(/signed in as ([^\s,;]+)/i)?.[1];
+}
+async function installSquire(options) {
+  const run2 = options.run ?? defaultShellRunner;
+  const streamRun = options.streamRun ?? defaultStreamedRunner;
+  const steps = [step("helper reached", "done")];
+  const emit = () => options.onProgress?.([...steps]);
+  const push = (next) => {
+    steps.push(next);
+    emit();
+  };
+  const fail = (reason) => {
+    steps.push(step("waiting for sign-in", "pending"));
+    emit();
+    return { status: "error", steps, errorMessage: reason };
+  };
+  emit();
+  const checks = await checkRemoteLoginPrerequisites(options.probeBinary);
+  if (checks.some((check) => !check.found)) {
+    push(missingPrerequisiteStep(checks));
+    return fail("this helper cannot host the remote sign-in surface");
+  }
+  push(step("remote sign-in prerequisites", "done"));
+  const install = await streamRun("xvfb-run", [
+    "-a",
+    "npx",
+    "-y",
+    SQUIRE_CONNECT_PACKAGE,
+    "connect",
+    "--force-relogin=google",
+    "--target=codex"
+  ]);
+  if (!install.signIn) {
+    const stderr = install.stderr.trim();
+    push(step("trusty-squire installed", "failed", stderr || "connect printed no sign-in URL"));
+    return fail(stderr || "the trusty-squire connect command printed no sign-in surface");
+  }
+  const version = await installedSquireVersion(run2);
+  push(step(`trusty-squire${version ? ` ${version}` : ""} installed`, "done"));
+  const signIn = install.signIn;
+  const signedInAs = parseSignedInAs(`${install.stdout}
+${install.stderr}`);
+  push(step("waiting for sign-in", "done"));
+  const pair = await pairSquire(options.mcp, options.workspaceId);
+  if (!pair.ok) {
+    push(step("paired to workspace", "failed", pair.reason));
+    return {
+      status: "installing",
+      steps,
+      signIn,
+      ...version ? { squireVersion: version } : {},
+      ...signedInAs ? { signedInAs } : {}
+    };
+  }
+  push(step("paired to workspace", "done"));
+  return {
+    status: "connected",
+    steps,
+    signIn,
+    ...version ? { squireVersion: version } : {},
+    ...signedInAs ? { signedInAs } : {}
+  };
+}
+async function pairSquire(mcp, _workspaceId) {
+  if (!mcp)
+    return { ok: false, reason: "the Squire MCP surface is not mounted on this helper" };
+  try {
+    await mcp.call("list_credentials", { fields: "summary" });
+    return { ok: true };
+  } catch (error) {
+    return { ok: false, reason: error instanceof Error ? error.message : String(error) };
+  }
+}
+function asRecord(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function stringList(value) {
+  return asArray(value).filter((entry) => typeof entry === "string");
+}
+function numberOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function vaultConnectionMeta(raw) {
+  const record3 = asRecord(raw);
+  const reference = String(record3.reference ?? record3.id ?? "");
+  return {
+    reference,
+    service: typeof record3.service === "string" ? record3.service : null,
+    label: String(record3.label ?? record3.service ?? reference),
+    fieldNames: stringList(record3.field_names ?? record3.fieldNames),
+    allowedHosts: stringList(record3.allowed_hosts ?? record3.allowedHosts ?? record3.login_hosts),
+    createdAt: numberOrNull(record3.created_at ?? record3.createdAt) ?? 0,
+    stale: record3.stale === true,
+    state: record3.state === "error" ? "error" : "active"
+  };
+}
+async function readVault(mcp) {
+  const result = asRecord(await mcp.call("list_credentials"));
+  return asArray(result.credentials ?? result.items ?? result).map(vaultConnectionMeta);
+}
+function connectionGrant(raw) {
+  const record3 = asRecord(raw);
+  return {
+    grantId: String(record3.grant_id ?? record3.grantId ?? record3.id ?? ""),
+    credentialRef: String(record3.credential_ref ?? record3.credentialRef ?? record3.reference ?? ""),
+    createdAt: numberOrNull(record3.created_at ?? record3.createdAt) ?? 0,
+    ...numberOrNull(record3.revoked_at ?? record3.revokedAt) !== null ? { revokedAt: numberOrNull(record3.revoked_at ?? record3.revokedAt) } : {},
+    ...numberOrNull(record3.rate_limit_per_hour) !== null ? { rateLimitPerHour: numberOrNull(record3.rate_limit_per_hour) } : {},
+    ...numberOrNull(record3.spend_cap_usd) !== null ? { spendCapUsd: numberOrNull(record3.spend_cap_usd) } : {}
+  };
+}
+async function readGrants(mcp, ref) {
+  const result = asRecord(await mcp.call("list_app_access", {}));
+  return asArray(result.grants ?? result.items ?? result).map(connectionGrant).filter((grant) => grant.credentialRef === ref && grant.revokedAt === void 0);
+}
+async function revokeGrants(mcp, ref) {
+  const grants = await readGrants(mcp, ref);
+  let revoked = 0;
+  let failed = 0;
+  for (const grant of grants) {
+    try {
+      const result = asRecord(await mcp.call("revoke_app_access", { grant_id: grant.grantId }));
+      if (result.revoked === false)
+        failed += 1;
+      else
+        revoked += 1;
+    } catch {
+      failed += 1;
+    }
+  }
+  return { revoked, failed };
+}
+
+// apps/body/dist/squire-mcp-client.js
+import { spawn as spawn3 } from "node:child_process";
+var INITIALIZE_TIMEOUT_MS = 3e4;
+var CALL_TIMEOUT_MS = 12e4;
+var StdioSquireMcpClient = class {
+  options;
+  child;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  buffer = "";
+  initialized;
+  closed = false;
+  log;
+  constructor(options = {}) {
+    this.options = options;
+    this.log = options.log ?? (() => {
+    });
+  }
+  /** One Squire MCP tool call; resolves with the tool's parsed result. */
+  async call(tool, args = {}) {
+    await this.ensureSession();
+    const response = await this.request("tools/call", { name: tool, arguments: args });
+    if (response.isError) {
+      const text3 = response.content?.find((entry) => entry.type === "text")?.text ?? "tool error";
+      throw new Error(`${tool} failed: ${text3}`);
+    }
+    const text2 = response.content?.find((entry) => entry.type === "text")?.text;
+    if (typeof text2 !== "string")
+      return response;
+    try {
+      return JSON.parse(text2);
+    } catch {
+      return response;
+    }
+  }
+  /** Tear the session down; safe to call repeatedly. */
+  close() {
+    this.closed = true;
+    this.initialized = void 0;
+    for (const entry of this.pending.values()) {
+      clearTimeout(entry.timer);
+      entry.reject(new Error("Squire MCP session closed"));
+    }
+    this.pending.clear();
+    this.child?.kill();
+    this.child = void 0;
+  }
+  ensureSession() {
+    if (this.closed)
+      throw new Error("Squire MCP client is closed");
+    this.initialized ??= this.initialize().catch((error) => {
+      this.initialized = void 0;
+      throw error;
+    });
+    return this.initialized;
+  }
+  initialize() {
+    const child = (this.options.spawn ?? spawn3)(this.options.command ?? "npx", [
+      ...this.options.args ?? ["-y", "@trusty-squire/mcp"]
+    ]);
+    this.child = child;
+    this.buffer = "";
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => this.onData(chunk));
+    child.stderr.on("data", (chunk) => this.log(`squire mcp stderr: ${chunk.trim()}`));
+    child.on("exit", (code) => {
+      this.log(`squire mcp exited (${String(code)})`);
+      this.initialized = void 0;
+      this.child = void 0;
+      for (const entry of this.pending.values()) {
+        clearTimeout(entry.timer);
+        entry.reject(new Error("Squire MCP server exited"));
+      }
+      this.pending.clear();
+    });
+    return this.request("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "beeline-helper", version: "1.0.0" }
+    }).then(() => {
+      this.notify("notifications/initialized");
+    });
+  }
+  notify(method, params) {
+    this.child?.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, ...params ? { params } : {} })}
+`);
+  }
+  request(method, params) {
+    const id = this.nextId++;
+    const child = this.child;
+    if (!child)
+      return Promise.reject(new Error("Squire MCP session is not running"));
+    return new Promise((resolve31, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`${method} timed out`));
+      }, method === "initialize" ? INITIALIZE_TIMEOUT_MS : CALL_TIMEOUT_MS);
+      this.pending.set(id, { resolve: resolve31, reject, timer });
+      child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}
+`);
+    });
+  }
+  onData(chunk) {
+    this.buffer += chunk;
+    for (; ; ) {
+      const newline = this.buffer.indexOf("\n");
+      if (newline < 0)
+        return;
+      const line = this.buffer.slice(0, newline).trim();
+      this.buffer = this.buffer.slice(newline + 1);
+      if (!line)
+        continue;
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const id = typeof message.id === "number" ? message.id : void 0;
+      if (id === void 0)
+        continue;
+      const entry = this.pending.get(id);
+      if (!entry)
+        continue;
+      this.pending.delete(id);
+      clearTimeout(entry.timer);
+      if (message.error) {
+        const error = message.error;
+        entry.reject(new Error(error.message ?? "Squire MCP error"));
+      } else {
+        entry.resolve(message.result);
+      }
+    }
+  }
+};
+function defaultSquireMcpClient() {
+  return new StdioSquireMcpClient();
+}
+
+// apps/body/dist/connector-assignments.js
+var CONNECTOR_POLL_INTERVAL_MS = 1e4;
+var ConnectorAssignmentLoop = class {
+  agentId;
+  api;
+  intervalMs;
+  log;
+  install;
+  readVaultFn;
+  revokeGrantsFn;
+  schedule;
+  cancel;
+  timer;
+  started = false;
+  stopped = false;
+  /** One install at a time per connector; other polls skip it. */
+  inFlight = /* @__PURE__ */ new Set();
+  mcp;
+  constructor(options) {
+    this.agentId = options.agentId;
+    this.api = options.api;
+    this.intervalMs = options.intervalMs ?? CONNECTOR_POLL_INTERVAL_MS;
+    this.log = options.log ?? (() => {
+    });
+    this.install = options.install ?? installSquire;
+    this.readVaultFn = options.readVault ?? readVault;
+    this.revokeGrantsFn = options.revokeGrants ?? revokeGrants;
+    this.schedule = options.schedule ?? ((fn, ms) => {
+      const timer = setTimeout(fn, ms);
+      timer.unref?.();
+      return timer;
+    });
+    this.cancel = options.cancel ?? ((handle) => clearTimeout(handle));
+  }
+  start() {
+    if (this.stopped || this.started)
+      return;
+    this.started = true;
+    void this.runOnce();
+    this.timer = this.schedule(() => this.poll(), this.intervalMs);
+  }
+  stop() {
+    this.stopped = true;
+    if (this.timer !== void 0) {
+      this.cancel(this.timer);
+      this.timer = void 0;
+    }
+  }
+  /** One interval tick: poll, then re-arm. */
+  poll() {
+    if (this.stopped)
+      return;
+    void this.runOnce();
+    this.timer = this.schedule(() => this.poll(), this.intervalMs);
+  }
+  /** Drain the queue once; every failure is logged, never raised. */
+  async runOnce() {
+    let assignments;
+    try {
+      const result = await this.api.execute("getConnectorAssignments", { agentId: this.agentId });
+      assignments = result.assignments;
+    } catch (error) {
+      this.log(`connector assignments unavailable: ${describe(error)}`);
+      return;
+    }
+    for (const assignment of assignments) {
+      const key = `${assignment.kind}:${assignment.connectorId}`;
+      if (assignment.kind === "uninstall")
+        continue;
+      if (this.inFlight.has(key))
+        continue;
+      this.inFlight.add(key);
+      void this.handle(assignment).catch((error) => this.log(`connector assignment ${key} failed: ${describe(error)}`)).finally(() => this.inFlight.delete(key));
+    }
+  }
+  squire() {
+    this.mcp ??= defaultSquireMcpClient();
+    return this.mcp;
+  }
+  async handle(assignment) {
+    if (assignment.kind === "install")
+      await this.runInstall(assignment.connectorId);
+    else if (assignment.kind === "sync")
+      await this.runSync();
+    else if (assignment.kind === "revoke-grants")
+      await this.runRevoke(assignment.connectorId, assignment.reference);
+  }
+  /** Install Trusty Squire, reporting every step as it settles. */
+  async runInstall(connectorId) {
+    const report = async (steps) => {
+      try {
+        await this.api.execute("postConnectorStatus", { agentId: this.agentId, connectorId, steps });
+      } catch (error) {
+        this.log(`step report failed: ${describe(error)}`);
+      }
+    };
+    const result = await this.install({
+      workspaceId: this.agentId,
+      mcp: this.squire(),
+      onProgress: report
+    });
+    if (result.status === "error") {
+      await this.api.execute("postConnectorStatus", {
+        agentId: this.agentId,
+        connectorId,
+        steps: result.steps,
+        errorMessage: result.errorMessage
+      });
+      return;
+    }
+    if (result.status === "connected") {
+      await this.api.execute("installConnector", {
+        agentId: this.agentId,
+        connectorId,
+        ...result.squireVersion ? { squireVersion: result.squireVersion } : {},
+        ...result.signedInAs ? { signedInAs: result.signedInAs } : {},
+        ...result.signIn ? { signIn: result.signIn } : {}
+      });
+      await this.reportVault(connectorId);
+      return;
+    }
+    await this.api.execute("postConnectorStatus", {
+      agentId: this.agentId,
+      connectorId,
+      steps: result.steps,
+      ...result.squireVersion ? { squireVersion: result.squireVersion } : {},
+      ...result.signedInAs ? { signedInAs: result.signedInAs } : {},
+      ...result.signIn ? { signIn: result.signIn } : {}
+    });
+  }
+  /** One vault report covers every live trusty-squire connector on this helper. */
+  async runSync() {
+    await this.reportVault();
+  }
+  async runRevoke(connectorId, reference) {
+    const outcome = await this.revokeGrantsFn(this.squire(), reference);
+    this.log(`revoked ${outcome.revoked} grant(s) on ${reference}` + (outcome.failed ? `, ${outcome.failed} failed` : ""));
+    void connectorId;
+  }
+  async reportVault(_connectorId) {
+    const connections = await this.readVaultFn(this.squire());
+    await this.api.execute("postConnectorVault", { agentId: this.agentId, connections });
+  }
+};
+function describe(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 // packages/api-contract/dist/daemon-operations.js
 function isAgentCommand(value) {
   if (!value || typeof value !== "object")
@@ -8185,7 +8707,7 @@ function isAgentCommand(value) {
 }
 
 // packages/api-contract/dist/artifacts.js
-var ARTIFACT_MAXIMUM_BYTES = 2 * 1024 * 1024;
+var ARTIFACT_MAXIMUM_BYTES = 25 * 1024 * 1024;
 
 // packages/api-contract/dist/system-events.js
 var SERVER_EVENT_KINDS = [
@@ -8216,12 +8738,12 @@ var wrapper_default = import_websocket.default;
 
 // apps/body/dist/runtime.js
 import { randomBytes as randomBytes5 } from "node:crypto";
-import { execFile } from "node:child_process";
+import { execFile as execFile2 } from "node:child_process";
 import { closeSync, openSync } from "node:fs";
 import { mkdir, readFile as readFile2, readdir, rename, stat, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
 import { dirname as dirname2, resolve as resolve6 } from "node:path";
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 import { promisify } from "node:util";
 
 // node_modules/@noble/hashes/_u64.js
@@ -16344,13 +16866,13 @@ var NegentropyStorageVector = class {
     let count = last - first;
     while (count > 0) {
       let it = first;
-      let step = Math.floor(count / 2);
-      it += step;
+      let step2 = Math.floor(count / 2);
+      it += step2;
       if (cmp(arr[it])) {
         first = ++it;
-        count -= step + 1;
+        count -= step2 + 1;
       } else {
-        count = step;
+        count = step2;
       }
     }
     return first;
@@ -16752,7 +17274,7 @@ function decodeNsec(nsec) {
 }
 
 // apps/body/dist/runtime.js
-var execFileAsync = promisify(execFile);
+var execFileAsync = promisify(execFile2);
 var DEFAULT_AGENT_IDENTITY_NAME = "beeline-agent";
 var DEFAULT_BODY_IDENTITY_NAME = "beeline-body";
 var DEFAULT_DAEMON_MONOLITH_BASE_URL = "https://server.usebeeline.app";
@@ -16942,7 +17464,7 @@ async function launchRuntimeDaemon(configPath, opts = {}) {
   const entrypoint = opts.entrypoint ?? process.argv[1];
   if (!entrypoint)
     throw new Error("cannot resolve daemon CLI entrypoint");
-  const child = spawn2(process.execPath, [...opts.execArgv ?? [], entrypoint, "daemon", "--config", resolve6(configPath)], {
+  const child = spawn4(process.execPath, [...opts.execArgv ?? [], entrypoint, "daemon", "--config", resolve6(configPath)], {
     cwd: directory,
     env: opts.env ?? process.env,
     detached: !foreground,
@@ -17213,7 +17735,7 @@ async function activateDaemonTransport(path, fetchImpl = fetch) {
 }
 
 // apps/body/dist/room-runtime.js
-import { execFile as execFile5 } from "node:child_process";
+import { execFile as execFile6 } from "node:child_process";
 import { createHash as createHash6 } from "node:crypto";
 import { existsSync as existsSync4, mkdirSync } from "node:fs";
 import { mkdir as mkdir13, rm as rm5 } from "node:fs/promises";
@@ -17221,7 +17743,7 @@ import { dirname as dirname8, resolve as resolve20 } from "node:path";
 import { promisify as promisify4 } from "node:util";
 
 // apps/body/dist/grant-runner.js
-import { execFile as execFile2 } from "node:child_process";
+import { execFile as execFile3 } from "node:child_process";
 import { createHash as createHash2, randomBytes as randomBytes6 } from "node:crypto";
 import { readFile as readFile4 } from "node:fs/promises";
 import { createServer } from "node:http";
@@ -17880,9 +18402,9 @@ var GrantCommandRunner = class {
       ...Object.fromEntries(secrets)
     };
     const cap = this.options.outputCapBytes ?? GRANT_COMMAND_OUTPUT_CAP_BYTES;
-    const spawn8 = surfaceAllows(policy.surface, "run-host-command") ? { command: argv[0], args: argv.slice(1) } : roomSandboxCommand(policy, room.cwd, argv);
+    const spawn10 = surfaceAllows(policy.surface, "run-host-command") ? { command: argv[0], args: argv.slice(1) } : roomSandboxCommand(policy, room.cwd, argv);
     const outcome = await new Promise((resolveRun) => {
-      const child = execFile2(spawn8.command, spawn8.args, {
+      const child = execFile3(spawn10.command, spawn10.args, {
         cwd: room.cwd,
         env,
         timeout: this.options.timeoutMs ?? GRANT_COMMAND_TIMEOUT_MS,
@@ -18318,7 +18840,7 @@ async function runServerCommandIntake(options) {
 }
 
 // apps/body/dist/monolith-corner-turn.js
-import { execFile as execFile4 } from "node:child_process";
+import { execFile as execFile5 } from "node:child_process";
 import { createHash as createHash5 } from "node:crypto";
 import { mkdir as mkdir12 } from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
@@ -18352,6 +18874,9 @@ function isAgentPairingCode(value) {
 // apps/body/dist/beeline-skill.js
 var USING_BEELINE_SKILL_NAME = "using-beeline";
 var BEELINE_REVIEW_SKILL_NAME = "beeline-review";
+function isConfiguredReviewer(agentHandle, reviewerHandle) {
+  return Boolean(agentHandle && reviewerHandle && agentHandle.replace(/^@/, "") === reviewerHandle.replace(/^@/, ""));
+}
 var BEELINE_ROOM_CAPABILITIES = [
   "The repository filesystem is read-only in this Room session.",
   "You may address any Room member, including another agent, by writing @name in your reply; the server routes that mention to them. Each turn prompt lists the Room members and the exact spelling that tags each one - use those spellings, and never guess or reuse one from an older message.",
@@ -18359,7 +18884,7 @@ var BEELINE_ROOM_CAPABILITIES = [
   "Tag the user only when you need a decision or input, or when the task they asked for is finished. Never tag for progress, acknowledgement, or questions the transcript already answers.",
   "Every MCP server mounted into this session is approved tool by tool - use operator and host tools freely; the read-only filesystem sandbox is the boundary, not a tool list. Network web search is enabled.",
   "Files and photos people share are downloaded for you: read them at the local path named in the prompt (photos may also arrive inline); never fetch the reference URL.",
-  "To create a file (this Room has no other way to write one), call beeline-agent write_scratch_file with a relative path and content - text by default, or base64 for bytes you computed; it returns a path in your writable session home. To send a file, call beeline-agent attach_file with a path inside your checkout or anywhere in your writable session home (wherever a file you or your harness generated actually landed, including one you just wrote); it is attached to your reply. write_scratch_file produces the file, not a picture - turning it into a raster image needs a converter, which needs shell, which this Room does not have.",
+  "To create a file (this Room has no other way to write one), call beeline-agent write_scratch_file with a relative path and content - text by default, or base64 for bytes you computed; it returns a path in your writable session home. To send a file, call beeline-agent post_artifact with a path inside your checkout or anywhere in your writable session home (wherever a file you or your harness generated actually landed, including one you just wrote), or with html/bytes content directly; it is uploaded and attached to your reply, and title and mime default from the file when you post by path. write_scratch_file produces the file, not a picture - turning it into a raster image needs a converter, which needs shell, which this Room does not have.",
   "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.",
   `To react to things that HAPPEN in this Room rather than only to what is said to you, call beeline-agent subscribe_events with the kinds you want (${SERVER_EVENT_KINDS.join(", ")}); each one then wakes you for a turn. It replaces your list, so send every kind you want - list_event_subscriptions shows the current one. You do this yourself: nobody has to configure it for you. grant-decided carries the grant id and status and resumes the turn that asked for the grant.`,
   "To state something that happened so the Room and other agents can act on it, call beeline-agent emit_event with your own agent:<slug> kind, one sentence, and optionally the agent members to wake. Chains of events are bounded and a refused emit posts nothing.",
@@ -18375,7 +18900,7 @@ var BEELINE_DM_CAPABILITIES = [
   "The repository filesystem is read-only in this session.",
   "Every MCP server mounted into this session is approved tool by tool - use operator and host tools freely; the read-only filesystem sandbox is the boundary, not a tool list. Network web search is enabled.",
   "Files and photos people share are downloaded for you: read them at the local path named in the prompt (photos may also arrive inline); never fetch the reference URL.",
-  "To create a file (this Room has no other way to write one), call beeline-agent write_scratch_file with a relative path and content - text by default, or base64 for bytes you computed; it returns a path in your writable session home. To send a file, call beeline-agent attach_file with a path inside your checkout or anywhere in your writable session home (wherever a file you or your harness generated actually landed, including one you just wrote); it is attached to your reply. write_scratch_file produces the file, not a picture - turning it into a raster image needs a converter, which needs shell, which this Room does not have.",
+  "To create a file (this Room has no other way to write one), call beeline-agent write_scratch_file with a relative path and content - text by default, or base64 for bytes you computed; it returns a path in your writable session home. To send a file, call beeline-agent post_artifact with a path inside your checkout or anywhere in your writable session home (wherever a file you or your harness generated actually landed, including one you just wrote), or with html/bytes content directly; it is uploaded and attached to your reply, and title and mime default from the file when you post by path. write_scratch_file produces the file, not a picture - turning it into a raster image needs a converter, which needs shell, which this Room does not have.",
   "Tag the person only when you need a decision or input, or when the task they asked for is finished.",
   "Never claim an action or reply happened unless the prompt or a tool result proves it."
 ].join(" ");
@@ -18417,6 +18942,8 @@ description: How to answer inside a Beeline Room.
 
 You are answering inside a Room whose filesystem is read-only. ${BEELINE_ROOM_CAPABILITIES}
 
+When your corner's pull request is ready, merging is your step: once the configured reviewer approves and tags you, you run \`gh pr merge\` yourself - nothing merges it for you.
+
 ## Tools and the Workbench
 
 A **tool** is something you can use once a human pairs it; a **key** is the credential that tool holds for that human. You spend a key through the mounted connector and never see the credential itself.
@@ -18507,7 +19034,7 @@ Then take exactly one action:
 
 - FAIL: reply \`@author\` with the confirmed findings to fix.
 - PASS: call \`approve_merge\` with the reviewed head SHA, then reply \`@author approved <reviewed sha>, merge\`.
-- Never merge the pull request yourself.
+- Approving is your last step as reviewer. The author merges it; you never do, and nothing merges it automatically.
 `;
 }
 
@@ -19177,7 +19704,7 @@ async function prepareRoomAgentHome(input) {
     await symlink(source, target).catch(() => void 0);
   }
   const prior = agentHomeProvisionQueues.get(root) ?? Promise.resolve();
-  const provision = prior.catch(() => void 0).then(() => provisionAgentSkillsAndMcp(root, operatorHome, input.skillReleaseId ?? runningBeelineReleaseId(), input.failClosed ?? false, input.sharedSkills ?? [], agentSkillDir(input.agentKind), input.openRouterRouting));
+  const provision = prior.catch(() => void 0).then(() => provisionAgentSkillsAndMcp(root, operatorHome, input.skillReleaseId ?? runningBeelineReleaseId(), input.failClosed ?? false, input.sharedSkills ?? [], agentSkillDir(input.agentKind), input.openRouterRouting, input.isReviewer ?? false));
   agentHomeProvisionQueues.set(root, provision);
   try {
     await provision;
@@ -19187,10 +19714,10 @@ async function prepareRoomAgentHome(input) {
   }
   return roomAgentHomeEnv(root);
 }
-async function provisionAgentSkillsAndMcp(root, operatorHome, skillReleaseId, failClosed, sharedSkills, skillDir, openRouterRouting) {
+async function provisionAgentSkillsAndMcp(root, operatorHome, skillReleaseId, failClosed, sharedSkills, skillDir, openRouterRouting, isReviewer) {
   const managedSkills = [
     { name: USING_BEELINE_SKILL_NAME, content: usingBeelineSkillMarkdown(skillReleaseId) },
-    { name: BEELINE_REVIEW_SKILL_NAME, content: beelineReviewSkillMarkdown(skillReleaseId) }
+    ...isReviewer ? [{ name: BEELINE_REVIEW_SKILL_NAME, content: beelineReviewSkillMarkdown(skillReleaseId) }] : []
   ];
   const shared = await resolveSharedSkillSources(operatorHome, sharedSkills);
   await provisionManagedSkillsDir(resolve13(root, skillDir, "skills"), managedSkills, shared, sharedSkills.length === 0);
@@ -20245,9 +20772,9 @@ export default async function (pi) {
 `;
 
 // apps/body/dist/corner-branch-sync.js
-import { execFile as execFile3 } from "node:child_process";
+import { execFile as execFile4 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
-var execFileAsync2 = promisify2(execFile3);
+var execFileAsync2 = promisify2(execFile4);
 async function syncCornerBranch(input) {
   const git = input.git ?? (async (args) => (await execFileAsync2("git", ["-C", input.worktreePath, ...args], {
     ...input.env ? { env: input.env } : {},
@@ -20426,7 +20953,7 @@ function isMountedMcpToolPermissionRequest(request, mountedServers = ROOM_MOUNTE
 var AGENT_SURFACE_TOOL_NAMES = [
   "open_corner",
   "pr_checks_status",
-  "attach_file",
+  "post_artifact",
   "write_scratch_file"
 ];
 var SQUIRE_TITLE_PREFIXES = [
@@ -21267,7 +21794,7 @@ async function seedWarmNodeModules(input) {
     for (const target of placed) {
       await rm4(target, { recursive: true, force: true }).catch(() => void 0);
     }
-    return { reason: "failed", key: plan.key, detail: describe(error) };
+    return { reason: "failed", key: plan.key, detail: describe2(error) };
   } finally {
     await rm4(staging, { recursive: true, force: true }).catch(() => void 0);
   }
@@ -21310,7 +21837,7 @@ async function harvestWarmNodeModules(input) {
   } catch (error) {
     if (await pathExists(entry))
       return { reason: "already-warm", key: plan.key };
-    return { reason: "failed", key: plan.key, detail: describe(error) };
+    return { reason: "failed", key: plan.key, detail: describe2(error) };
   } finally {
     await rm4(staging, { recursive: true, force: true }).catch(() => void 0);
   }
@@ -21453,7 +21980,7 @@ async function deviceOf(path) {
 async function isDirectory(path) {
   return stat2(path).then((info) => info.isDirectory(), () => false);
 }
-function describe(error) {
+function describe2(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
@@ -21731,10 +22258,13 @@ var MonolithRoomTurnLoop = class {
     });
     const directMessage = Array.isArray(repositoryState.directParticipants) && repositoryState.directParticipants.length === 2;
     await mkdir11(this.options.cwd, { recursive: true });
-    const selection = configuration.model || configuration.effort ? { model: configuration.model, effort: configuration.effort } : this.options.config.modelSelection;
+    const selectionModel = configuration.model ?? this.options.config.modelSelection?.model;
+    const selectionEffort = configuration.effort ?? this.options.config.modelSelection?.effort;
+    const selection = selectionModel || selectionEffort ? { model: selectionModel, effort: selectionEffort } : void 0;
     const homeOverlay = this.options.config.agentHomeRoot ? await prepareRoomAgentHome({
       root: this.options.config.agentHomeRoot,
       sharedSkills: this.options.config.sharedSkills ?? [],
+      isReviewer: isConfiguredReviewer(self?.handle, configuration.reviewerHandle),
       ...this.options.config.agentKind ? { agentKind: this.options.config.agentKind } : {},
       ...this.options.config.operatorHome ? { operatorHome: this.options.config.operatorHome } : {},
       ...openRouterRoutingInput(this.options.config, selection, this.options.fetchImpl, {
@@ -21957,6 +22487,7 @@ var MonolithRoomTurnLoop = class {
     this.busy = true;
     const trace = this.beginTurnTrace(item.id);
     let liveStream;
+    let liveCornerOpened = false;
     try {
       if (!this.memberNames.has(item.authorId))
         await this.roster().catch(() => void 0);
@@ -22038,7 +22569,11 @@ ${JSON.stringify((corners.corners ?? []).filter((corner) => !corner.archived))}`
                 result2 = await this.client.sessionPrompt(this.sessionId, nextPrompt, ROOM_PROMPT_INACTIVITY_TIMEOUT_MS, (delta, full) => {
                   trace.firstModelOutput();
                   stream.onChunk(delta, full);
-                }, void 0, (calls) => trace.toolCalls(calls));
+                }, void 0, (calls) => {
+                  trace.toolCalls(calls);
+                  if (openedACorner(openCornerToolCall(calls)))
+                    liveCornerOpened = true;
+                });
               } catch (error) {
                 promptError = error;
               }
@@ -22132,6 +22667,22 @@ ${JSON.stringify((corners.corners ?? []).filter((corner) => !corner.archived))}`
         await trace.finish("cancelled");
         return;
       }
+      if (liveCornerOpened && error instanceof AcpRequestTimeoutError && error.inactivity && error.method === "session/prompt") {
+        console.log(`[thin-core] monolith Room ${this.options.roomId} turn ${item.id}: inactivity timeout after opening a corner; the work continues in the corner`);
+        this.options.onCornerOpened?.();
+        await liveStream?.retract().catch((retractError) => {
+          console.error(`[thin-core] monolith Room ${this.options.roomId} draft retract failed:`, retractError);
+        });
+        await api.execute("postAgentTurnReceipt", {
+          agentId: this.agent.publicKey,
+          roomId: this.options.roomId,
+          requestId: item.id,
+          status: "complete",
+          generationId: this.commandContext.generationId
+        });
+        await trace.finish("complete");
+        return;
+      }
       await liveStream?.retract().catch((retractError) => {
         console.error(`[thin-core] monolith Room ${this.options.roomId} draft retract failed:`, retractError);
       });
@@ -22201,7 +22752,7 @@ function roomMessagePrompt(author, body, attachments, delivered, harnessAcceptsI
 }
 
 // apps/body/dist/monolith-corner-turn.js
-var execFileAsync3 = promisify3(execFile4);
+var execFileAsync3 = promisify3(execFile5);
 var TOOL_ARGUMENT_MAX_BYTES = 1200;
 var TOOL_OUTPUT_MAX_BYTES = 3200;
 var TOOL_PATH_LIMIT = 12;
@@ -22592,6 +23143,7 @@ var MonolithCornerTurnLoop = class {
     const homeOverlay = this.options.config.agentHomeRoot ? await prepareRoomAgentHome({
       root: this.options.config.agentHomeRoot,
       sharedSkills: this.options.config.sharedSkills ?? [],
+      isReviewer: isConfiguredReviewer(self?.handle, configuration.reviewerHandle),
       ...this.options.config.agentKind ? { agentKind: this.options.config.agentKind } : {},
       ...this.options.config.operatorHome ? { operatorHome: this.options.config.operatorHome } : {},
       ...openRouterRoutingInput(this.options.config, selection, this.options.fetchImpl, {
@@ -22742,7 +23294,7 @@ var MonolithCornerTurnLoop = class {
           "Never restate server check or merge notes. On a checks turn, say nothing unless you merge or push a fix, then use one short line. Never merge while approvalPending is true. When approval is pending, wait for the reviewer to tag you. Never merge another pull request. Never create a schedule to poll pr_checks_status or the merge gate: the green transition wakes the reviewer and the reviewer's approval tag wakes you, and tagging any agent other than the configured reviewer cannot clear the gate. If a schedule wakes you in this corner anyway, follow the same rule as a checks turn: say nothing unless you merge, push a fix, or report a genuinely new blocker."
         ] : [
           "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.",
+          "Work in this corner's writable workspace. Use write_scratch_file or ordinary tools to create files, then post_artifact with the path to send them back to the corner.",
           "Do not initialize a repository, create a branch, push, open a pull request, or wait for GitHub checks."
         ]
       ].filter(Boolean).join("\n\n")
@@ -23729,7 +24281,7 @@ async function removeCornerWorktreeAndBranches(worktree) {
     ]);
   }
 }
-var execFileAsync4 = promisify4(execFile5);
+var execFileAsync4 = promisify4(execFile6);
 async function removeCornerScratchWorkspace(input) {
   const expected = resolve20(input.roomRoot, "scratch");
   if (resolve20(input.scratchPath) !== expected) {
@@ -24464,13 +25016,13 @@ var ThinDaemonCore = class {
 };
 
 // apps/body/dist/systemd.js
-import { execFile as execFile6 } from "node:child_process";
+import { execFile as execFile7 } from "node:child_process";
 import { mkdir as mkdir14, readFile as readFile9, writeFile as writeFile9 } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
 import { dirname as dirname9, resolve as resolve21 } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 import { promisify as promisify5 } from "node:util";
-var execFileAsync5 = promisify5(execFile6);
+var execFileAsync5 = promisify5(execFile7);
 var DELIBERATE_REMOVAL_EXIT_STATUS = 78;
 var DAEMON_DISTRESS_EXIT_STATUS = 77;
 var UNKNOWN_AGENT_EXIT_STATUS = 79;
@@ -24709,9 +25261,10 @@ async function runStartCommand(args, interactiveUi) {
 }
 
 // apps/body/dist/connect-command.js
-import { spawn as spawn5 } from "node:child_process";
-import { createHash as createHash8 } from "node:crypto";
+import { spawn as spawn7 } from "node:child_process";
+import { createHash as createHash8, randomUUID as randomUUID5 } from "node:crypto";
 import { chmod as chmod6, mkdir as mkdir16, readFile as readFile11, unlink as unlink2, writeFile as writeFile11 } from "node:fs/promises";
+import { homedir as homedir10, hostname } from "node:os";
 import { dirname as dirname12, resolve as resolve23 } from "node:path";
 import { stdin as stdin3, stdout as stdout4 } from "node:process";
 
@@ -24796,7 +25349,7 @@ async function verifyProviderKey(input) {
 }
 
 // apps/body/dist/pair-agent-selection.js
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 import { stdin as stdin2, stdout as stdout3 } from "node:process";
 var NO_AGENT_MESSAGE = `No supported ACP-capable coding agent was detected.
 Install one of these supported agents:
@@ -24824,7 +25377,7 @@ async function clackSelectAgent(candidates) {
 }
 async function installAdapter(install, opts) {
   await new Promise((resolveInstall, rejectInstall) => {
-    const child = spawn3(install.command, install.args, {
+    const child = spawn5(install.command, install.args, {
       cwd: opts.cwd,
       env: opts.env ?? process.env,
       stdio: "inherit"
@@ -25325,7 +25878,29 @@ function parseConnectSubscriptions(value) {
     ...new Set((value ?? "").split(",").map((entry) => entry.trim().toLowerCase()).filter(Boolean))
   ];
 }
-function requestConnectGrant(baseUrl, pairingCode, selection, fetchImpl) {
+async function readMachineId(env = process.env) {
+  const configDir = resolve23(env.XDG_CONFIG_HOME ?? resolve23(homedir10(), ".config"), "beeline");
+  const machineIdPath = resolve23(configDir, "machine-id");
+  let machineId;
+  let machineName = hostname();
+  try {
+    const existing = await readFile11(machineIdPath, "utf8");
+    machineId = existing.trim();
+    if (!/^[0-9a-f-]{32,}$/.test(machineId))
+      throw new Error("invalid persisted machine id");
+  } catch {
+    machineId = randomUUID5();
+    try {
+      await mkdir16(configDir, { recursive: true, mode: 448 });
+      await writeFile11(machineIdPath, `${machineId}
+`, { mode: 384 });
+    } catch {
+      machineId = createHash8("sha256").update(machineName).digest("hex").slice(0, 36);
+    }
+  }
+  return { machineId, machineName };
+}
+function requestConnectGrant(baseUrl, pairingCode, selection, fetchImpl, machineInfo) {
   const normalizedPairingCode = normalizeAgentPairingCode(pairingCode);
   if (!normalizedPairingCode)
     throw new Error("invalid pairing code");
@@ -25340,7 +25915,8 @@ function requestConnectGrant(baseUrl, pairingCode, selection, fetchImpl) {
     // This wizard always finishes the join itself (`finishConnectedAgentPairing`,
     // called once the rename prompt below settles), so the claim must not
     // join Rooms or announce yet.
-    defer_join: true
+    defer_join: true,
+    ...machineInfo ? { machine_id: machineInfo.machineId, machine_name: machineInfo.machineName } : {}
   }, fetchImpl);
 }
 async function renameConnectedAgent(baseUrl, pairingCode, name, fetchImpl) {
@@ -25419,7 +25995,7 @@ async function writeProviderEnv(selection, agentPubkey) {
 }
 async function runInstalledFinish(binary, grantPath) {
   await new Promise((resolveRun, rejectRun) => {
-    const child = spawn5(binary, ["connect-finish", grantPath], {
+    const child = spawn7(binary, ["connect-finish", grantPath], {
       stdio: ["ignore", "pipe", "pipe"]
     });
     let diagnostic = "";
@@ -25470,7 +26046,8 @@ async function runConnectWizard(code, fetchImpl, eventSubscriptions, accessPolic
   });
   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 claimed = await brassSpinner("Connecting to your Beeline Workspace\u2026", () => requestConnectGrant(baseUrl, pairingCode, selection, fetchImpl), (connectedGrant) => `Connected to ${connectedGrant.workspace_name}`);
+  const machineInfo = await readMachineId(process.env);
+  const claimed = await brassSpinner("Connecting to your Beeline Workspace\u2026", () => requestConnectGrant(baseUrl, pairingCode, selection, fetchImpl, machineInfo), (connectedGrant) => `Connected to ${connectedGrant.workspace_name}`);
   const grant = { ...claimed, agent_name: await confirmSeededName(baseUrl, pairingCode, claimed, fetchImpl) };
   await finishConnectedAgentPairing(baseUrl, pairingCode, grant.workspace_joined, eventSubscriptions, fetchImpl);
   const installedRelease = await brassSpinner("Installing the Beeline daemon\u2026", () => installCurrentRelease(fetchImpl), (release) => `Installed Beeline helper ${release.version}`);
@@ -25592,7 +26169,7 @@ init_self_update_manifest();
 
 // apps/body/dist/managed-update.js
 init_self_update();
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn8 } from "node:child_process";
 import { mkdir as mkdir18, rm as rm7, stat as stat3, writeFile as writeFile13 } from "node:fs/promises";
 import { dirname as dirname14, resolve as resolve25 } from "node:path";
 
@@ -26006,7 +26583,7 @@ async function runManagedUpdateWorkerProcess() {
   if (!entrypoint)
     throw new Error("cannot resolve the current Beeline entrypoint");
   await new Promise((resolveWorker, rejectWorker) => {
-    const child = spawn6(process.execPath, [entrypoint, "managed-update-worker"], {
+    const child = spawn8(process.execPath, [entrypoint, "managed-update-worker"], {
       detached: true,
       env: { ...process.env, BEELINE_INTERNAL_UPDATE_WORKER: "1" },
       stdio: ["ignore", "pipe", "pipe"]
@@ -26360,7 +26937,7 @@ async function clearDaemonStartFailures(runtimeDir) {
 
 // apps/body/dist/update-functional-probe.js
 import { mkdir as mkdir20, rm as rm9 } from "node:fs/promises";
-import { homedir as homedir10 } from "node:os";
+import { homedir as homedir11 } from "node:os";
 import { resolve as resolve27 } from "node:path";
 var UPDATE_PROBE_SESSION_TIMEOUT_MS = 1e4;
 var UPDATE_PROBE_SESSION_OPEN_TIMEOUT_MS = 2e4;
@@ -26466,7 +27043,7 @@ async function runUpdateFunctionalProbe(input) {
       ...input.config.agentEnv,
       ...await prepareRoomAgentHome({
         root: homeRoot,
-        operatorHome: input.config.operatorHome ?? homedir10(),
+        operatorHome: input.config.operatorHome ?? homedir11(),
         sharedSkills: input.config.sharedSkills ?? [],
         ...input.config.agentKind ? { agentKind: input.config.agentKind } : {},
         skillReleaseId: input.releaseId,
@@ -26487,7 +27064,7 @@ async function runUpdateFunctionalProbe(input) {
     let turnCompleted = true;
     if (input.config.bwrapPath) {
       const { stateDirs, tmpDir } = harnessStateDirsFromEnv(agentEnv);
-      const operatorHome = input.config.operatorHome ?? homedir10();
+      const operatorHome = input.config.operatorHome ?? homedir11();
       const homeStateDirs = harnessHomeStateDirs(command, agentEnv.HOME ?? operatorHome);
       await Promise.all(homeStateDirs.map((dir) => mkdir20(dir, { recursive: true })));
       spawnCommand = wrapAgentCommand({
@@ -26638,7 +27215,7 @@ async function runUpdateFunctionalProbe(input) {
 }
 
 // apps/body/dist/current-release-probe.js
-import { spawn as spawn7 } from "node:child_process";
+import { spawn as spawn9 } from "node:child_process";
 import { dirname as dirname16, join as join10 } from "node:path";
 init_self_update();
 var CURRENT_RELEASE_PROBE_TIMEOUT_MS = 12e4;
@@ -26689,7 +27266,7 @@ async function probeReleaseInSubprocess(input) {
   }
   const timeoutMs = input.timeoutMs ?? CURRENT_RELEASE_PROBE_TIMEOUT_MS;
   return new Promise((resolve31) => {
-    const child = spawn7(input.execPath ?? process.execPath, [entrypoint, UPDATE_PROBE_COMMAND, "--config", input.runtimeConfigPath], { env: input.env ?? process.env, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn9(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;
@@ -27034,6 +27611,7 @@ async function runStoredDaemon(pathOrPointer) {
   const scratchSweepTimer = setInterval(() => runScratchSweepLogged(runtimeDir), SCRATCH_SWEEP_INTERVAL_MS);
   scratchSweepTimer.unref();
   let ready = false;
+  let connectorLoop;
   let stoppingStatus = "daemon stopped";
   try {
     const core = new ThinDaemonCore(runtime, configPath, config, { daemonApi });
@@ -27106,6 +27684,13 @@ async function runStoredDaemon(pathOrPointer) {
           ...runtime.modelSelection ? { runtimeSelection: runtime.modelSelection } : {},
           ...config.modelUnavailable ? { startupUnavailable: config.modelUnavailable.unavailable.label } : {}
         });
+        void readMachineId(process.env).then(({ machineId, machineName }) => daemonApi.execute("postAgentMachineReport", { machineId, machineName }));
+        connectorLoop ??= new ConnectorAssignmentLoop({
+          api: daemonApi,
+          agentId: runtime.agent.publicKey,
+          log: (message) => console.log(`[body] connector: ${message}`)
+        });
+        connectorLoop.start();
       },
       onProgress: async (status) => {
         void drainRollbackAlert(core.activeRoomIds()[0] ?? runtime.rooms[0]?.channelId);

package/package.json

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