@tonbo/yield 0.3.9 → 0.3.11

package/dist/bin/yield.js

@@ -1253,6 +1253,12 @@ async function assertPrivateRegularFile(filename) {
 var exec = promisify(execFile);
 var DEFAULT_LOGIN_HINT = credentialsContract.reader.login_hint;
 var LOOPBACK_HOST = "127.0.0.1";
+var BrowserUnavailableError = class extends Error {
+};
+function prefersDeviceLogin(env = process.env) {
+  const ssh = Boolean(env.SSH_CONNECTION || env.SSH_CLIENT || env.SSH_TTY);
+  return ssh && !env.DISPLAY && !env.WAYLAND_DISPLAY;
+}
 function newLoginSecret() {
   return randomBytes(32).toString("base64url");
 }
@@ -1268,7 +1274,8 @@ var AuthClient = class {
   hostname;
   loginHint;
   entryLine;
-  constructor(credentials, fetcher, loginOrigin2 = "https://tonbo.dev", browserOpener = openBrowser, hostname = loginHostname(), loginHint = DEFAULT_LOGIN_HINT, entryLine = "cli") {
+  env;
+  constructor(credentials, fetcher, loginOrigin2 = "https://tonbo.dev", browserOpener = openBrowser, hostname = loginHostname(), loginHint = DEFAULT_LOGIN_HINT, entryLine = "cli", env = process.env) {
     this.credentials = credentials;
     this.fetcher = fetcher;
     this.loginOrigin = loginOrigin2;
@@ -1276,6 +1283,7 @@ var AuthClient = class {
     this.hostname = hostname;
     this.loginHint = loginHint;
     this.entryLine = entryLine;
+    this.env = env;
   }
   /** The personal key requests are made with: TONBO_API_KEY, or the saved
    * login while it has not expired. */
@@ -1295,12 +1303,16 @@ var AuthClient = class {
    * a free port, then the one-time code is redeemed, with this device's login
    * secret, for the account's login key, which replaces this device's earlier
    * login key there ("CLI on <hostname>" in a personal account, `Yield CLI ·
-   * <8 hex>` in any other). The key joins the file's `accounts`; it becomes
-   * the top level too unless `current` is false (a login made only to publish
-   * into an organization). Answers that account's login.
+   * <8 hex>` in any other). With `device`, in an SSH session without a
+   * display, or when no browser can be opened, the same PKCE challenge goes
+   * to a device-code login instead: the person enters a short code at
+   * /cli/device in any browser and the CLI polls for the key. The key joins
+   * the file's `accounts`; it becomes the top level too unless `current` is
+   * false (a login made only to publish into an organization). Answers that
+   * account's login.
    */
   async login(progress2 = () => {
-  }, account, { current: current2 = true } = {}) {
+  }, account, { current: current2 = true, device } = {}) {
     const existing = await this.credentials.load().catch((error) => {
       if (error instanceof UnusableLoginError)
         return null;
@@ -1309,6 +1321,30 @@ var AuthClient = class {
     const loginSecret = existing?.login_secret ?? newLoginSecret();
     const verifier = randomBytes(48).toString("base64url");
     const challenge = createHash("sha256").update(verifier).digest("base64url");
+    const redeemed = device ?? prefersDeviceLogin(this.env) ? await this.deviceLogin(challenge, verifier, loginSecret, account, progress2) : await this.browserLogin(challenge, verifier, loginSecret, account, progress2).catch((error) => {
+      if (!(error instanceof BrowserUnavailableError))
+        throw error;
+      progress2({ status: "failed", step: "browser", reason: error.message });
+      return this.deviceLogin(challenge, verifier, loginSecret, account, progress2);
+    });
+    const login = {
+      account_id: redeemed.account_id,
+      key_id: redeemed.api_key.id,
+      key: redeemed.key,
+      expires_at: redeemed.api_key.expires_at,
+      kind: redeemed.account_kind ?? null,
+      name: redeemed.account_name ?? null
+    };
+    progress2({ status: "started", step: "credential-store" });
+    const latest = await this.credentials.load().catch(() => existing);
+    await this.credentials.save(withAccountLogin(latest, login, {
+      current: current2,
+      loginSecret: latest?.login_secret ?? loginSecret
+    }));
+    progress2({ status: "completed", step: "credential-store" });
+    return login;
+  }
+  async browserLogin(challenge, verifier, loginSecret, account, progress2) {
     const state = randomBytes(24).toString("base64url");
     const code = await this.listenForCode(state, (redirectUri) => {
       const authorization = new URL("/cli/login", this.loginOrigin);
@@ -1331,34 +1367,85 @@ var AuthClient = class {
       body: JSON.stringify({ code, code_verifier: verifier, login_secret: loginSecret })
     });
     progress2({ status: "completed", step: "key-redemption" });
-    const login = {
-      account_id: redeemed.account_id,
-      key_id: redeemed.api_key.id,
-      key: redeemed.key,
-      expires_at: redeemed.api_key.expires_at,
-      kind: redeemed.account_kind ?? null,
-      name: redeemed.account_name ?? null
-    };
-    progress2({ status: "started", step: "credential-store" });
-    const latest = await this.credentials.load().catch(() => existing);
-    await this.credentials.save(withAccountLogin(latest, login, {
-      current: current2,
-      loginSecret: latest?.login_secret ?? loginSecret
-    }));
-    progress2({ status: "completed", step: "credential-store" });
-    return login;
+    return redeemed;
+  }
+  /**
+   * The device-code login (RFC 8628's shape): the PKCE challenge and the
+   * hostname buy a device code and a user code; the person approves the user
+   * code at /cli/device, seeing the hostname; the CLI polls with the device
+   * code, its verifier and the login secret, all in POST bodies, and the
+   * approved poll answers the key once. A denied or expired code ends it.
+   */
+  async deviceLogin(challenge, verifier, loginSecret, account, progress2) {
+    progress2({ status: "started", step: "device-code" });
+    const started = await requestJson(this.fetcher, new URL("/api/cli/login/device", this.loginOrigin).toString(), {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        code_challenge: challenge,
+        code_challenge_method: "S256",
+        hostname: this.hostname
+      })
+    });
+    progress2({ status: "completed", step: "device-code" });
+    const page = new URL("/cli/device", this.loginOrigin);
+    const complete = new URL(page);
+    complete.search = new URLSearchParams({
+      code: started.user_code,
+      from: this.entryLine,
+      ...account ? { account } : {}
+    }).toString();
+    progress2({
+      status: "device-code",
+      step: "device-authorization",
+      userCode: started.user_code,
+      url: page.toString(),
+      completeUrl: complete.toString(),
+      expiresIn: started.expires_in
+    });
+    progress2({ status: "started", step: "device-authorization" });
+    const expired = new Error(`The login code expired. Run \`${this.loginHint}\` again.`);
+    const deadline = Date.now() + started.expires_in * 1e3;
+    let interval = started.interval;
+    for (; ; ) {
+      await new Promise((resolve) => setTimeout(resolve, interval * 1e3));
+      try {
+        const redeemed = await requestJson(this.fetcher, new URL("/api/cli/login/device/token", this.loginOrigin).toString(), {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            device_code: started.device_code,
+            code_verifier: verifier,
+            login_secret: loginSecret
+          })
+        });
+        progress2({ status: "completed", step: "device-authorization" });
+        return redeemed;
+      } catch (error) {
+        const code = error instanceof HttpError ? error.code : null;
+        if (code === "slow_down")
+          interval += 5;
+        else if (code === "access_denied")
+          throw new Error("The login was not approved (access_denied).");
+        else if (code === "expired_token")
+          throw expired;
+        else if (code !== "authorization_pending" && !transient(error))
+          throw error;
+        if (Date.now() >= deadline)
+          throw expired;
+      }
+    }
   }
   listenForCode(expectedState, authorizationUrl, progress2) {
     return new Promise((resolve, reject) => {
       let settled = false;
       const sockets = /* @__PURE__ */ new Set();
       let authorizationStarted = false;
-      const startAuthorization = (browserOpened = true) => {
+      const startAuthorization = () => {
         if (authorizationStarted)
           return;
         authorizationStarted = true;
-        if (browserOpened)
-          progress2({ status: "completed", step: "browser" });
+        progress2({ status: "completed", step: "browser" });
         progress2({ status: "started", step: "browser-authorization" });
       };
       const finish = (result, completedResponseSocket) => {
@@ -1428,18 +1515,17 @@ var AuthClient = class {
         void Promise.resolve().then(() => this.browserOpener(url)).then(() => startAuthorization(), (error) => {
           if (settled || authorizationStarted)
             return;
-          progress2({
-            status: "failed",
-            step: "browser",
-            reason: error instanceof Error ? error.message : String(error),
-            callbackPort: port
+          finish({
+            error: new BrowserUnavailableError(error instanceof Error ? error.message : String(error))
           });
-          startAuthorization(false);
         });
       });
     });
   }
 };
+function transient(error) {
+  return error instanceof HttpError ? error.status === 429 || error.status >= 500 : error instanceof TypeError;
+}
 function respond(response, outcome, finished) {
   const page = callbackResponse(outcome);
   if (finished)
@@ -1918,7 +2004,7 @@ var USD = new Intl.NumberFormat("en-US", {
 // ../../packages/tonbo-cli-core/dist/src/login.js
 async function loginCommand(deps, options = {}) {
   try {
-    const login = await deps.auth.login((event) => reportLoginProgress(deps.progress, event), options.account, { current: options.current });
+    const login = await deps.auth.login((event) => reportLoginProgress(deps.progress, event), options.account, { current: options.current, device: options.device });
     deps.output(`Logged in to account ${login.name ?? login.account_id}.${login.expires_at ? ` The login expires ${login.expires_at}.` : ""}`);
     return login;
   } catch (error) {
@@ -1947,6 +2033,14 @@ var LOGIN_PROGRESS_MESSAGES = {
     started: "Receiving the CLI key",
     completed: "CLI key received"
   },
+  "device-code": {
+    started: "Requesting a login code",
+    completed: "Login code received"
+  },
+  "device-authorization": {
+    started: "Waiting for approval in a browser",
+    completed: "Login approved"
+  },
   "credential-store": {
     started: "Saving login",
     completed: "Login saved"
@@ -1958,9 +2052,13 @@ function reportLoginProgress(progress2, event) {
     return;
   }
   if (event.status === "failed") {
-    const port = event.callbackPort;
-    progress2.fail(`Could not open a browser: ${event.reason.replace(/\.$/, "")}.`);
-    progress2.note(`Open the URL above in a browser that can reach 127.0.0.1:${port} on this machine. From another computer, forward that port first: \`ssh -L ${port}:127.0.0.1:${port} <this host>\` or your VM's port forwarding both work.`);
+    progress2.fail(`Could not open a browser: ${event.reason.replace(/\.$/, "")}. Approve with a code instead.`);
+    return;
+  }
+  if (event.status === "device-code") {
+    const minutes = Math.max(1, Math.round(event.expiresIn / 60));
+    progress2.note(`To approve this login, open ${event.url} in any browser and enter the code ${event.userCode}. It expires in ${minutes} minutes.`);
+    progress2.note(`Or open ${event.completeUrl}`);
     return;
   }
   const messages = LOGIN_PROGRESS_MESSAGES[event.step];
@@ -3397,8 +3495,8 @@ var recallContract = {
       "GET /files?repo=<name>&path=<path>&limit=<n>": "the turns that changed the file, newest first: {repo, path, change, direct, session, turn, src, device, sub, commit, base, at_ms, cwd, git_branch, stream_offset_from, stream_offset_to}; a row of another author's turn answers no src, device, cwd, git_branch or stream offsets (team_metadata)",
       "GET /sessions/<session id>/files?limit=<n>": "the files the session changed, newest first: {repo, path, change, direct, turn, commit, at_ms}",
       "GET /sessions?repo=<name>&limit=<n>": "sessions seen in the repository, most recent activity first: {session, src, device, sub, cwd, git_branch, started_ms, last_turn, last_ms}; a row of another author's session answers no src, device, cwd or git_branch (team_metadata)",
-      "GET /sessions?scope=team&limit=<n>": "the team catalog: the catalog's rows for every author in the workspace's account, each with its author (the stamped sub), under the catalog's credential rule; in an organization's workspace that is every member's team sessions (ADR-0017 D-1), in a personal one the person's own; the caller's own rows are the catalog's, and another author's row answers team_metadata's fields only: {session, author, last_ms, state, state_ms, paths_written, turns}",
-      "GET /sessions?limit=<n>": "the catalog (docs/design/yield-session-state.md): the sessions whose records the caller appended (their stamped author is the token's sub), most recent activity first, for a person's own key only (a token bound by git_workspace with no agent_id; an Agent's key and a token minted before ADR-0016 PR 3 answer 403) holding git.repos.read on the whole workspace (git:<ws_hex>:*) and denied it on none of it: {session, src, device, device_handle, cwd, git_root, git_branch, started_ms, last_turn, last_ms, state, state_ms, paths_written, paths_inferred}; a row of the organization-published form answers device, cwd and git_root null and names its device_handle, null otherwise; state is the session's latest session_state in stream order, null when none was reported, and paths_written is at most caps.catalog_paths paths, the turn in progress's first, then those of its newest turns; paths_inferred is the same of capture-v1 inbox.paths_inferred, kept apart and never exact"
+      "GET /sessions?scope=team&limit=<n>": "the team catalog: the catalog's rows for every author in the workspace's account, each with its author (the stamped sub), under the catalog's credential rule; in an organization's workspace that is every member's team sessions (ADR-0017 D-1), in a personal one the person's own; the caller's own rows are the catalog's, and another author's row answers team_metadata's fields only: {session, author, project_id, last_ms, state, state_ms, paths_written, turns}",
+      "GET /sessions?limit=<n>": "the catalog (docs/design/yield-session-state.md): the sessions whose records the caller appended (their stamped author is the token's sub), most recent activity first, for a person's own key only (a token bound by git_workspace with no agent_id; an Agent's key and a token minted before ADR-0016 PR 3 answer 403) holding git.repos.read on the whole workspace (git:<ws_hex>:*) and denied it on none of it: {session, src, device, device_handle, project_id, cwd, git_root, git_branch, started_ms, last_turn, last_ms, state, state_ms, paths_written, paths_inferred, turns}; a row of the organization-published form answers device, cwd and git_root null and names its device_handle, null otherwise; state is the session's latest session_state in stream order, null when none was reported, and paths_written is at most caps.catalog_paths paths, the turn in progress's first, then those of its newest turns; paths_inferred is the same of capture-v1 inbox.paths_inferred, kept apart and never exact; project_id is the Project the session's latest record named (capture-v1 inbox.project), null when none did, which the person's sessions of one Project on their other devices share; turns is team_metadata's turns, so the person's daemons compare their own sessions across devices (conflict alerts)"
     },
     "organization": "rows indexed from an organization's proc.inbox, whose records take the published form (contracts/sessions/capture-v1.json inbox.organization_published), answer cwd null, name the device only by its device_handle and never by a device id, and name paths relative to the bound folder; their provenance (session, stream_offset_from, stream_offset_to) points into the author's own session.<session> in the author's personal store (capture-v1 team_session_stream), or for a session captured before ADR-0017's metadata-only amendment into session.t.<session> in the organization's store, and only the author's rows carry it",
     "provenance": "every row the caller may read raw names its session, turn, commit and time; a reader reads the turn's records from session.<session> between stream_offset_from and stream_offset_to with its own Streams token. A team session's author reads them from their own personal store, and from the records they wrote to session.t.<session> before the metadata-only amendment; a teammate never reads them (team_metadata.raw)",
@@ -6558,105 +6656,609 @@ var LineFilter = class {
 
 // src/conflicts.ts
 import { execFile as execFile5 } from "node:child_process";
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 import path16 from "node:path";
 import { promisify as promisify5 } from "node:util";
 
-// src/inbox.ts
-import { execFile as execFile4 } from "node:child_process";
-import { randomUUID as randomUUID7 } from "node:crypto";
-import { appendFile, mkdir as mkdir5, open as open8, readFile as readFile9, rename as rename7, rm as rm7 } from "node:fs/promises";
-import path15 from "node:path";
-import { promisify as promisify4 } from "node:util";
-import { setTimeout as delay4 } from "node:timers/promises";
-
-// src/handoffs.ts
-async function listHandoffs(request) {
-  const data = await request("listHandoffs", {});
-  if (!Array.isArray(data)) throw new Error("The handoff list answered an invalid body.");
-  return data;
-}
-async function readHandoffEvents(request, after, wait) {
-  const answer = await request("listHandoffEvents", {
-    query: { after: String(after), wait: String(wait) }
-  });
-  if (!Array.isArray(answer?.events) || !Number.isSafeInteger(answer.next_after))
-    throw new Error("The handoff events answered an invalid body.");
-  return answer;
-}
-async function cancelHandoff(request, link3) {
-  const id = handoffId(link3);
-  const answer = await request(
-    "cancelPersonalHandoff",
-    { params: { id } }
-  );
-  if (answer.id !== id || answer.state !== "cancelled")
-    throw new Error("The handoff answered an invalid cancellation.");
-  return answer;
-}
-function handoffListLine(item, me, name) {
-  const who = (sub) => sub === me ? "you" : name(item.account_id, sub);
-  const parts = [`by ${who(item.author_sub)}`];
-  if (item.target_kind === "person" && item.target_sub) parts.push(`for ${who(item.target_sub)}`);
-  if (item.target_kind === "open") parts.push("for any member");
-  if (item.target_kind === "agent") parts.push(`for ${item.target_harness ?? "another harness"}`);
-  if (item.target_kind === "machine")
-    parts.push(`dispatched to your device on ${item.target_harness ?? "a harness"}`);
-  if (item.claimed_by_sub) parts.push(`taken by ${who(item.claimed_by_sub)}`);
-  return `${item.state.padEnd(10)} ${item.link}  ${item.task}  (${parts.join(", ")})`;
-}
-var VERBS2 = {
-  created: "created",
-  claimed: "took",
-  running: "started",
-  done: "finished",
-  need_human: "needs a human on",
-  failed: "failed",
-  returned: "returned",
-  cancelled: "cancelled"
-};
-function handoffEventLine(event, me, name) {
-  const actor = !event.actor_sub ? "someone" : event.actor_sub === me ? "you" : name(event.account_id, event.actor_sub);
-  return `#${event.seq} ${event.at} ${actor} ${VERBS2[event.kind] ?? event.kind} ${event.link}  ${event.task}`;
-}
+// src/device-conflicts.ts
+import { createHash as createHash7 } from "node:crypto";
 
-// src/inbox.ts
-var InboxStore = class {
-  constructor(directory2 = stateDirectory()) {
-    this.directory = directory2;
-  }
-  file(name) {
-    return path15.join(this.directory, name);
-  }
-  /** Appends messages to the spool (the daemon). */
-  async append(messages) {
-    if (!messages.length) return;
-    await mkdir5(this.directory, { recursive: true, mode: 448 });
-    await appendFile(
-      this.file("inbox.jsonl"),
-      messages.map((message3) => `${JSON.stringify(message3)}
-`).join(""),
-      { mode: 384 }
-    );
-  }
-  /** Every message, oldest first, each once; a torn last line is skipped. */
-  async messages() {
-    const text3 = await readFile9(this.file("inbox.jsonl"), "utf8").catch(() => "");
-    const seen = /* @__PURE__ */ new Map();
-    for (const line of text3.split("\n")) {
-      if (!line.trim()) continue;
-      try {
-        const message3 = JSON.parse(line);
-        if (typeof message3?.id === "string" && !seen.has(message3.id)) seen.set(message3.id, message3);
-      } catch {
+// src/generated/machine.ts
+var machineRegisterDefs = {
+  "byoc_arch": {
+    "description": "A `byoc` device's architecture; grows only by a contract change. The regional machine_byoc_arches() equals it.",
+    "enum": [
+      "arm64",
+      "amd64"
+    ]
+  },
+  "byoc_client": {
+    "description": "The client that registered a `byoc` device; grows only by a contract change. The regional machine_byoc_clients() equals it.",
+    "enum": [
+      "yield"
+    ]
+  },
+  "byoc_client_version": {
+    "description": "The client's version, a semantic version of at most 64 octets.",
+    "type": "string",
+    "maxLength": 64,
+    "pattern": "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)(-[0-9A-Za-z-]+(\\.[0-9A-Za-z-]+)*)?(\\+[0-9A-Za-z-]+(\\.[0-9A-Za-z-]+)*)?$"
+  },
+  "byoc_harness": {
+    "description": "An agent harness `yield` captures on a `byoc` device: a key of contracts/sessions/capture-v1.json `sources`, its one authority, which automation/tests/test_machines_machine_v2_contract.py holds this enum equal to. The regional machine_byoc_harnesses() equals it.",
+    "enum": [
+      "claude-code",
+      "codex"
+    ]
+  },
+  "byoc_harnesses": {
+    "description": "The harnesses installed on the device that its client captures, without duplicates.",
+    "type": "array",
+    "uniqueItems": true,
+    "items": {
+      "$ref": "#/$defs/byoc_harness"
+    }
+  },
+  "byoc_hostname": {
+    "description": "The device's hostname as the client reports it, at most 253 octets (the database counts octets). Personal data, answered to the device's owner only (machine-v2.json `byoc.visibility`).",
+    "type": "string",
+    "minLength": 1,
+    "maxLength": 253
+  },
+  "byoc_os": {
+    "description": "A `byoc` device's operating system family; grows only by a contract change. The regional machine_byoc_oses() equals it.",
+    "enum": [
+      "darwin",
+      "linux"
+    ]
+  },
+  "name": {
+    "description": "A Machine name: the Agent name grammar (contracts/agents/agent-name-v1.json `$defs.name`, the same pattern and lengths, which the contract test holds equal) without its reserved-name list, which a Machine label cannot collide with (machine-v2.json `names`); 1-40 characters, no `--` and no `.`. Unique within its account across both kinds (ADR-0015 Q5); `<name>-<account>` must also pass the label rule of machine-v2.json `hostnames` for a managed Machine. `self` is reserved, so `/v1/machines/self` never names a Machine; global machine_name_valid follows this definition verbatim.",
+    "type": "string",
+    "minLength": 1,
+    "maxLength": 40,
+    "pattern": "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$",
+    "not": {
+      "const": "self"
+    }
+  },
+  "register": {
+    "description": "The body of `PUT /v1/machines/self` (machine-v2.json `actions` `register`, ADR-0015 `Registration`), signed by the CLI login key of the computer it registers. It has no `kind`: the server derives `byoc`, and a `kind` is refused as an unknown field. `name` is read only by the registration that creates the device; a device that exists keeps its name.",
+    "type": "object",
+    "additionalProperties": false,
+    "required": [
+      "device_id",
+      "hostname",
+      "os",
+      "arch",
+      "client",
+      "client_version",
+      "harnesses"
+    ],
+    "properties": {
+      "device_id": {
+        "$ref": "#/$defs/uuid"
+      },
+      "hostname": {
+        "$ref": "#/$defs/byoc_hostname"
+      },
+      "os": {
+        "$ref": "#/$defs/byoc_os"
+      },
+      "arch": {
+        "$ref": "#/$defs/byoc_arch"
+      },
+      "client": {
+        "$ref": "#/$defs/byoc_client"
+      },
+      "client_version": {
+        "$ref": "#/$defs/byoc_client_version"
+      },
+      "harnesses": {
+        "$ref": "#/$defs/byoc_harnesses"
+      },
+      "name": {
+        "$ref": "#/$defs/name"
       }
     }
-    return [...seen.values()];
-  }
-  async cursor() {
-    return readJson(this.file("inbox-cursor.json"));
+  },
+  "uuid": {
+    "description": "A lowercase canonical UUID.",
+    "type": "string",
+    "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"
   }
-  async saveCursor(cursor) {
+};
+var byocPresence = {
+  "heartbeat": {
+    "interval_seconds": 300,
+    "jitter_seconds": 30
+  },
+  "online_window_seconds": 900
+};
+var byocRetryable = [
+  "device_registration_conflict",
+  "device_report_throttled"
+];
+
+// src/devices.ts
+async function listDevices(list2) {
+  const devices = [];
+  const unavailable = /* @__PURE__ */ new Set();
+  let cursor;
+  for (; ; ) {
+    const page = await list2(cursor ? { cursor } : {});
+    devices.push(
+      ...page.data.filter((machine) => machine.kind === "byoc")
+    );
+    for (const region of page.unavailable_regions ?? []) unavailable.add(region);
+    if (!page.next_cursor || page.next_cursor === cursor) break;
+    cursor = page.next_cursor;
+  }
+  return { devices, unavailableRegions: [...unavailable] };
+}
+var DISPATCHABLE = /* @__PURE__ */ new Set(["claude-code", "codex"]);
+function isOnline(lastSeen, now) {
+  const seen = Date.parse(lastSeen);
+  return Number.isFinite(seen) && now - seen <= byocPresence.online_window_seconds * 1e3;
+}
+function deviceRows(devices, device, now) {
+  return devices.map((machine) => ({
+    dispatch_target: machine.byoc.device_id !== device && machine.byoc.key_state === "active" && isOnline(machine.byoc.last_seen, now) && machine.byoc.harnesses.some((harness) => DISPATCHABLE.has(harness)),
+    name: machine.name,
+    os: machine.byoc.os,
+    arch: machine.byoc.arch,
+    harnesses: machine.byoc.harnesses,
+    client_version: machine.byoc.client_version,
+    last_seen: machine.byoc.last_seen,
+    online: isOnline(machine.byoc.last_seen, now),
+    key_state: machine.byoc.key_state,
+    this_device: machine.byoc.device_id === device,
+    device_id: machine.byoc.device_id ?? null,
+    hostname: machine.byoc.hostname ?? null
+  })).sort((a, b) => Number(b.this_device) - Number(a.this_device) || a.name.localeCompare(b.name));
+}
+
+// src/recall.ts
+var str = (value) => typeof value === "string" ? value : null;
+var num = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var flag = (value) => value === true || value === 1;
+function rowsOf(body) {
+  const record3 = body && typeof body === "object" ? body : null;
+  const rows = Array.isArray(body) ? body : record3?.data ?? record3?.rows ?? record3?.files;
+  if (!Array.isArray(rows)) throw new Error("The recall answer holds no rows.");
+  return rows.filter((row) => !!row && typeof row === "object");
+}
+function parseFileTurns(body) {
+  return rowsOf(body).flatMap((row) => {
+    const session = str(row.session);
+    const turn = num(row.turn);
+    const commit = str(row.commit);
+    const at = num(row.at_ms);
+    if (!session || turn === null || !commit || at === null) return [];
+    return [
+      {
+        repo: str(row.repo) ?? "",
+        path: str(row.path) ?? "",
+        change: str(row.change) ?? "?",
+        direct: flag(row.direct),
+        session,
+        turn,
+        src: str(row.src),
+        device: str(row.device),
+        sub: str(row.sub),
+        commit,
+        base: str(row.base),
+        at_ms: at,
+        cwd: str(row.cwd),
+        git_branch: str(row.git_branch),
+        stream_offset_from: str(row.stream_offset_from),
+        stream_offset_to: str(row.stream_offset_to)
+      }
+    ];
+  });
+}
+function parseSessionFiles(body) {
+  return rowsOf(body).flatMap((row) => {
+    const turn = num(row.turn);
+    const path34 = str(row.path);
+    const at = num(row.at_ms);
+    if (turn === null || !path34 || at === null) return [];
+    return [
+      {
+        repo: str(row.repo) ?? "",
+        path: path34,
+        change: str(row.change) ?? "?",
+        direct: flag(row.direct),
+        turn,
+        commit: str(row.commit) ?? "",
+        at_ms: at
+      }
+    ];
+  });
+}
+function parseRepoSessions(body) {
+  return rowsOf(body).flatMap((row) => {
+    const session = str(row.session);
+    if (!session) return [];
+    return [
+      {
+        session,
+        src: str(row.src),
+        device: str(row.device),
+        sub: str(row.sub),
+        cwd: str(row.cwd),
+        git_branch: str(row.git_branch),
+        started_ms: num(row.started_ms),
+        last_turn: num(row.last_turn),
+        last_ms: num(row.last_ms)
+      }
+    ];
+  });
+}
+function parseCatalog(body) {
+  return rowsOf(body).flatMap((row) => {
+    const session = str(row.session);
+    if (!session) return [];
+    const strings = (value) => (Array.isArray(value) ? value : []).filter(
+      (path34) => typeof path34 === "string"
+    );
+    return [
+      {
+        session,
+        src: str(row.src),
+        device: str(row.device),
+        cwd: str(row.cwd),
+        git_root: str(row.git_root),
+        git_branch: str(row.git_branch),
+        started_ms: num(row.started_ms),
+        last_turn: num(row.last_turn),
+        last_ms: num(row.last_ms),
+        state: str(row.state),
+        state_ms: num(row.state_ms),
+        paths_written: strings(row.paths_written),
+        paths_inferred: strings(row.paths_inferred),
+        device_handle: str(row.device_handle),
+        author: str(row.author),
+        project_id: str(row.project_id),
+        turns: (Array.isArray(row.turns) ? row.turns : []).flatMap((value) => {
+          const entry = value && typeof value === "object" ? value : {};
+          const turn = num(entry.turn);
+          const at = num(entry.at_ms);
+          return turn === null || at === null ? [] : [{ turn, at_ms: at, paths_written: strings(entry.paths_written) }];
+        })
+      }
+    ];
+  });
+}
+function indexUnavailableReason(status, body) {
+  const record3 = body && typeof body === "object" ? body : {};
+  if (status !== 503 || record3.code !== "index_unavailable") return null;
+  const index = record3.index && typeof record3.index === "object" ? record3.index : {};
+  const phase = str(index.phase);
+  const kind = str(index.kind) ?? (num(index.kind) === null ? null : String(index.kind));
+  const since = str(index.since);
+  const time2 = since && Number.isFinite(Date.parse(since)) ? since.slice(11, 16) : null;
+  const where = [phase && kind ? `${phase}: ${kind}` : phase, time2 && `since ${time2} UTC`].filter(Boolean).join(" ");
+  return `the index is not open yet${where ? ` (${where})` : ""}`;
+}
+function recallLimit(limit = RECALL_DEFAULT_LIMIT) {
+  return Math.max(1, Math.min(RECALL_MAX_LIMIT, Math.floor(limit)));
+}
+var RecallClient = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async files(repo, path34, limit) {
+    return parseFileTurns(
+      await this.get("/files", { repo, path: path34, limit: String(recallLimit(limit)) })
+    );
+  }
+  async sessionFiles(session, limit) {
+    return parseSessionFiles(
+      await this.get(`/sessions/${encodeURIComponent(session)}/files`, {
+        limit: String(recallLimit(limit))
+      })
+    );
+  }
+  async sessions(repo, limit) {
+    return parseRepoSessions(
+      await this.get("/sessions", { repo, limit: String(recallLimit(limit)) })
+    );
+  }
+  /** The catalog: the caller's sessions of the index, most recent activity
+   * first; `team`, every author's (recall-v1 `GET /sessions?scope=team`). */
+  async catalog(limit, options = {}) {
+    return parseCatalog(
+      await this.get("/sessions", {
+        ...options.team ? { scope: "team" } : {},
+        limit: String(recallLimit(limit))
+      })
+    );
+  }
+  async get(path34, query) {
+    const { fetch: fetcher, tokens: tokens2, key, origin, workspace } = this.options;
+    const url = `${recallBase(origin, workspace)}${path34}?${new URLSearchParams(query)}`;
+    const response = await tokens2.send(
+      key,
+      (token) => fetcher(url, {
+        redirect: "manual",
+        signal: AbortSignal.timeout(3e4),
+        headers: { authorization: `Bearer ${token}`, accept: "application/json" }
+      })
+    );
+    const body = await response.json().catch(() => null);
+    if (response.ok) return body;
+    const record3 = body && typeof body === "object" ? body : {};
+    const detail = indexUnavailableReason(response.status, body) ?? str(record3.detail) ?? str(record3.title) ?? str(record3.error);
+    throw new HttpError(
+      response.status === 404 ? "The recall API answered 404: it is not available for this workspace yet." : `The recall API answered ${response.status}${detail ? `: ${detail}` : "."}`,
+      response.status,
+      body,
+      response.headers.get("x-request-id")
+    );
+  }
+};
+
+// src/team-conflicts.ts
+import { createHash as createHash6 } from "node:crypto";
+var TEAM_POLL_MS = 6e4;
+var NAMES_KEPT_MS = 10 * 6e4;
+function liveRow(row, now) {
+  const [shown] = psRows([row], { device: "", now, all: true });
+  return ["running", "waiting", "idle"].includes(shown?.shown_state ?? "");
+}
+function teamConflicts(mine, catalog, options) {
+  const found = [];
+  for (const row of catalog.rows) {
+    if (!row.author || row.author === catalog.me || !liveRow(row, options.now)) continue;
+    const theirs = /* @__PURE__ */ new Set();
+    for (const turn of row.turns)
+      if (options.now - turn.at_ms < CONFLICT_WINDOW_MS) {
+        for (const file of turn.paths_written) if (!ignoredPath(file)) theirs.add(file);
+      }
+    if (!theirs.size) continue;
+    for (const own of mine) {
+      const pair = `t ${own.session} ${row.session}`;
+      if (options.alerted(pair)) continue;
+      const files = Object.entries(own.paths).filter(([file, ms]) => options.now - ms < CONFLICT_WINDOW_MS && theirs.has(file)).map(([file]) => file).sort();
+      if (files.length)
+        found.push({
+          pair,
+          session: own.session,
+          teammate: row.session,
+          author: row.author,
+          files
+        });
+    }
+  }
+  return found;
+}
+function teamConflictMessage(conflict, name, now) {
+  const shown = conflict.files.slice(0, 3).join(", ") + (conflict.files.length > 3 ? `, +${conflict.files.length - 3}` : "");
+  const who = name ?? `teammate ${conflict.author.slice(0, 8)}`;
+  return {
+    id: `c${createHash6("sha256").update(conflict.pair).digest("hex").slice(0, 10)}`,
+    kind: "conflict",
+    at: new Date(now).toISOString(),
+    recipient: { kind: "session", id: conflict.session },
+    reason: "a teammate's live session wrote the same file",
+    source: { kind: "local", detail: conflict.teammate },
+    content: `${who}'s session ${conflict.teammate.slice(0, 8)} in this team Project also wrote ${shown} in the last 2 h`,
+    notify: true
+  };
+}
+function teamCatalogReader(options) {
+  const people = /* @__PURE__ */ new Map();
+  return async (accountId) => {
+    const file = await options.credentials.load();
+    const login = file ? accountLogins(file).find(
+      (entry) => entry.account_id === accountId && entry.kind !== "user" && !isExpiredLogin(entry)
+    ) : void 0;
+    if (!login) throw new Error(`no current login of organization ${accountId}`);
+    let known = people.get(accountId);
+    if (!known || known.key !== login.key || Date.now() - known.at > NAMES_KEPT_MS) {
+      const [account, members, store] = await Promise.all([
+        options.api.getAccount(login.key),
+        options.api.page(
+          "listMembers",
+          login.key,
+          { limit: 100 }
+        ),
+        getSessionsStore(options.fetch, options.apiOrigin, login.key, { team: true })
+      ]);
+      known = {
+        at: Date.now(),
+        key: login.key,
+        me: account.member.subject,
+        workspace: workspaceHex(store.workspace_id),
+        names: new Map(
+          members.data.map((member2) => [
+            member2.subject,
+            member2.display_name ?? member2.name ?? member2.subject
+          ])
+        )
+      };
+      people.set(accountId, known);
+    }
+    const recall = new RecallClient({
+      fetch: options.fetch,
+      tokens: options.gitTokens,
+      key: login.key,
+      origin: gitOrigin(options.apiOrigin),
+      workspace: known.workspace
+    });
+    return { me: known.me, names: known.names, rows: await recall.catalog(100, { team: true }) };
+  };
+}
+
+// src/device-conflicts.ts
+function deviceConflicts(mine, rows, options) {
+  const found = [];
+  for (const row of rows) {
+    if (!row.device || row.device === options.device || !row.project_id || !row.git_root) continue;
+    if (!liveRow(row, options.now)) continue;
+    const theirs = /* @__PURE__ */ new Set();
+    for (const turn of row.turns)
+      if (options.now - turn.at_ms < CONFLICT_WINDOW_MS) {
+        for (const file of turn.paths_written) if (!ignoredPath(file)) theirs.add(file);
+      }
+    if (!theirs.size) continue;
+    for (const own of mine) {
+      if (own.project !== row.project_id) continue;
+      const pair = `d ${own.session} ${row.session}`;
+      if (options.alerted(pair)) continue;
+      const files = Object.entries(own.paths).filter(([file, ms]) => options.now - ms < CONFLICT_WINDOW_MS && theirs.has(file)).map(([file]) => file).sort();
+      if (files.length) found.push({ pair, session: own.session, other: row, files });
+    }
+  }
+  return found;
+}
+function deviceConflictMessage(conflict, names, now, home) {
+  const shown = conflict.files.slice(0, 3).join(", ") + (conflict.files.length > 3 ? `, +${conflict.files.length - 3}` : "");
+  const { other } = conflict;
+  const device = other.device;
+  const on = names.get(device) ?? `device ${device.slice(0, 8)}`;
+  const where = other.git_root ? ` in ${tilde(other.git_root, home)}` : "";
+  return {
+    id: `c${createHash7("sha256").update(conflict.pair).digest("hex").slice(0, 10)}`,
+    kind: "conflict",
+    at: new Date(now).toISOString(),
+    recipient: { kind: "session", id: conflict.session },
+    reason: "your session on another device wrote the same file",
+    source: { kind: "local", detail: other.session },
+    content: `your ${other.src ?? "agent"} session ${other.session.slice(0, 8)} on ${on}${where} also wrote ${shown} in the last 2 h`,
+    notify: true
+  };
+}
+var KEPT_MS = 10 * 6e4;
+function ownCatalogReader(options) {
+  const now = options.now ?? (() => Date.now());
+  let known = null;
+  return async () => {
+    const key = await options.key();
+    if (!key) throw new Error("no current personal login");
+    if (!known || known.key !== key || now() - known.at > KEPT_MS) {
+      const [store, { devices }] = await Promise.all([
+        getSessionsStore(options.fetch, options.apiOrigin, key),
+        listDevices((page) => options.api.listMachines(key, page))
+      ]);
+      known = {
+        at: now(),
+        key,
+        workspace: workspaceHex(store.workspace_id),
+        names: new Map(
+          devices.flatMap(
+            (machine) => machine.byoc.device_id ? [[machine.byoc.device_id, machine.name]] : []
+          )
+        )
+      };
+    }
+    const recall = new RecallClient({
+      fetch: options.fetch,
+      tokens: options.gitTokens,
+      key,
+      origin: gitOrigin(options.apiOrigin),
+      workspace: known.workspace
+    });
+    return { rows: await recall.catalog(100), names: known.names };
+  };
+}
+
+// src/inbox.ts
+import { execFile as execFile4 } from "node:child_process";
+import { randomUUID as randomUUID7 } from "node:crypto";
+import { appendFile, mkdir as mkdir5, open as open8, readFile as readFile9, rename as rename7, rm as rm7 } from "node:fs/promises";
+import path15 from "node:path";
+import { promisify as promisify4 } from "node:util";
+import { setTimeout as delay4 } from "node:timers/promises";
+
+// src/handoffs.ts
+async function listHandoffs(request) {
+  const data = await request("listHandoffs", {});
+  if (!Array.isArray(data)) throw new Error("The handoff list answered an invalid body.");
+  return data;
+}
+async function readHandoffEvents(request, after, wait) {
+  const answer = await request("listHandoffEvents", {
+    query: { after: String(after), wait: String(wait) }
+  });
+  if (!Array.isArray(answer?.events) || !Number.isSafeInteger(answer.next_after))
+    throw new Error("The handoff events answered an invalid body.");
+  return answer;
+}
+async function cancelHandoff(request, link3) {
+  const id = handoffId(link3);
+  const answer = await request(
+    "cancelPersonalHandoff",
+    { params: { id } }
+  );
+  if (answer.id !== id || answer.state !== "cancelled")
+    throw new Error("The handoff answered an invalid cancellation.");
+  return answer;
+}
+function handoffListLine(item, me, name) {
+  const who = (sub) => sub === me ? "you" : name(item.account_id, sub);
+  const parts = [`by ${who(item.author_sub)}`];
+  if (item.target_kind === "person" && item.target_sub) parts.push(`for ${who(item.target_sub)}`);
+  if (item.target_kind === "open") parts.push("for any member");
+  if (item.target_kind === "agent") parts.push(`for ${item.target_harness ?? "another harness"}`);
+  if (item.target_kind === "machine")
+    parts.push(`dispatched to your device on ${item.target_harness ?? "a harness"}`);
+  if (item.claimed_by_sub) parts.push(`taken by ${who(item.claimed_by_sub)}`);
+  return `${item.state.padEnd(10)} ${item.link}  ${item.task}  (${parts.join(", ")})`;
+}
+var VERBS2 = {
+  created: "created",
+  claimed: "took",
+  running: "started",
+  done: "finished",
+  need_human: "needs a human on",
+  failed: "failed",
+  returned: "returned",
+  cancelled: "cancelled"
+};
+function handoffEventLine(event, me, name) {
+  const actor = !event.actor_sub ? "someone" : event.actor_sub === me ? "you" : name(event.account_id, event.actor_sub);
+  return `#${event.seq} ${event.at} ${actor} ${VERBS2[event.kind] ?? event.kind} ${event.link}  ${event.task}`;
+}
+
+// src/inbox.ts
+var InboxStore = class {
+  constructor(directory2 = stateDirectory()) {
+    this.directory = directory2;
+  }
+  file(name) {
+    return path15.join(this.directory, name);
+  }
+  /** Appends messages to the spool (the daemon). */
+  async append(messages) {
+    if (!messages.length) return;
+    await mkdir5(this.directory, { recursive: true, mode: 448 });
+    await appendFile(
+      this.file("inbox.jsonl"),
+      messages.map((message3) => `${JSON.stringify(message3)}
+`).join(""),
+      { mode: 384 }
+    );
+  }
+  /** Every message, oldest first, each once; a torn last line is skipped. */
+  async messages() {
+    const text3 = await readFile9(this.file("inbox.jsonl"), "utf8").catch(() => "");
+    const seen = /* @__PURE__ */ new Map();
+    for (const line of text3.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const message3 = JSON.parse(line);
+        if (typeof message3?.id === "string" && !seen.has(message3.id)) seen.set(message3.id, message3);
+      } catch {
+      }
+    }
+    return [...seen.values()];
+  }
+  async cursor() {
+    return readJson(this.file("inbox-cursor.json"));
+  }
+  async saveCursor(cursor) {
     await writeJson(this.directory, this.file("inbox-cursor.json"), cursor);
   }
   async marks() {
@@ -6736,7 +7338,7 @@ function messageFor(event, me, actorName) {
       return null;
     case "claimed":
       if (!author || byMe) return null;
-      return make("claimed", "you gave this handoff", false, `${actor} took ${event.link}`);
+      return make("claimed", "you gave this handoff", true, `${actor} took ${event.link}`);
     case "done":
     case "failed":
     case "returned": {
@@ -6879,305 +7481,31 @@ function inboxPoll(options) {
           names: new Map(
             data.map((member2) => [
               member2.subject,
-              member2.display_name ?? member2.name ?? member2.subject
-            ])
-          )
-        };
-        names.set(accountId, entry);
-      }
-      return entry.names.get(sub) ?? null;
-    }
-  };
-}
-function inboxLine(message3, status) {
-  return `${status.padEnd(11)} ${message3.id}  ${message3.at}  ${message3.content}  (${message3.reason})`;
-}
-async function ackHandoff(store, handoffId2) {
-  try {
-    const marks = await store.marks();
-    const ids = (await store.messages()).filter(
-      (message3) => message3.source.kind === "handoff" && message3.source.handoff_id === handoffId2 && unread(statusOf(marks, message3.id))
-    ).map((message3) => message3.id);
-    if (!ids.length) return;
-    const at = (/* @__PURE__ */ new Date()).toISOString();
-    for (const id of ids) marks.marks[id] = { ...marks.marks[id], status: "read", at };
-    await store.saveMarks(marks);
-  } catch {
-  }
-}
-
-// src/team-conflicts.ts
-import { createHash as createHash6 } from "node:crypto";
-
-// src/recall.ts
-var str = (value) => typeof value === "string" ? value : null;
-var num = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
-var flag = (value) => value === true || value === 1;
-function rowsOf(body) {
-  const record3 = body && typeof body === "object" ? body : null;
-  const rows = Array.isArray(body) ? body : record3?.data ?? record3?.rows ?? record3?.files;
-  if (!Array.isArray(rows)) throw new Error("The recall answer holds no rows.");
-  return rows.filter((row) => !!row && typeof row === "object");
-}
-function parseFileTurns(body) {
-  return rowsOf(body).flatMap((row) => {
-    const session = str(row.session);
-    const turn = num(row.turn);
-    const commit = str(row.commit);
-    const at = num(row.at_ms);
-    if (!session || turn === null || !commit || at === null) return [];
-    return [
-      {
-        repo: str(row.repo) ?? "",
-        path: str(row.path) ?? "",
-        change: str(row.change) ?? "?",
-        direct: flag(row.direct),
-        session,
-        turn,
-        src: str(row.src),
-        device: str(row.device),
-        sub: str(row.sub),
-        commit,
-        base: str(row.base),
-        at_ms: at,
-        cwd: str(row.cwd),
-        git_branch: str(row.git_branch),
-        stream_offset_from: str(row.stream_offset_from),
-        stream_offset_to: str(row.stream_offset_to)
-      }
-    ];
-  });
-}
-function parseSessionFiles(body) {
-  return rowsOf(body).flatMap((row) => {
-    const turn = num(row.turn);
-    const path34 = str(row.path);
-    const at = num(row.at_ms);
-    if (turn === null || !path34 || at === null) return [];
-    return [
-      {
-        repo: str(row.repo) ?? "",
-        path: path34,
-        change: str(row.change) ?? "?",
-        direct: flag(row.direct),
-        turn,
-        commit: str(row.commit) ?? "",
-        at_ms: at
-      }
-    ];
-  });
-}
-function parseRepoSessions(body) {
-  return rowsOf(body).flatMap((row) => {
-    const session = str(row.session);
-    if (!session) return [];
-    return [
-      {
-        session,
-        src: str(row.src),
-        device: str(row.device),
-        sub: str(row.sub),
-        cwd: str(row.cwd),
-        git_branch: str(row.git_branch),
-        started_ms: num(row.started_ms),
-        last_turn: num(row.last_turn),
-        last_ms: num(row.last_ms)
-      }
-    ];
-  });
-}
-function parseCatalog(body) {
-  return rowsOf(body).flatMap((row) => {
-    const session = str(row.session);
-    if (!session) return [];
-    const strings = (value) => (Array.isArray(value) ? value : []).filter(
-      (path34) => typeof path34 === "string"
-    );
-    return [
-      {
-        session,
-        src: str(row.src),
-        device: str(row.device),
-        cwd: str(row.cwd),
-        git_root: str(row.git_root),
-        git_branch: str(row.git_branch),
-        started_ms: num(row.started_ms),
-        last_turn: num(row.last_turn),
-        last_ms: num(row.last_ms),
-        state: str(row.state),
-        state_ms: num(row.state_ms),
-        paths_written: strings(row.paths_written),
-        paths_inferred: strings(row.paths_inferred),
-        device_handle: str(row.device_handle),
-        author: str(row.author),
-        turns: (Array.isArray(row.turns) ? row.turns : []).flatMap((value) => {
-          const entry = value && typeof value === "object" ? value : {};
-          const turn = num(entry.turn);
-          const at = num(entry.at_ms);
-          return turn === null || at === null ? [] : [{ turn, at_ms: at, paths_written: strings(entry.paths_written) }];
-        })
-      }
-    ];
-  });
-}
-function indexUnavailableReason(status, body) {
-  const record3 = body && typeof body === "object" ? body : {};
-  if (status !== 503 || record3.code !== "index_unavailable") return null;
-  const index = record3.index && typeof record3.index === "object" ? record3.index : {};
-  const phase = str(index.phase);
-  const kind = str(index.kind) ?? (num(index.kind) === null ? null : String(index.kind));
-  const since = str(index.since);
-  const time2 = since && Number.isFinite(Date.parse(since)) ? since.slice(11, 16) : null;
-  const where = [phase && kind ? `${phase}: ${kind}` : phase, time2 && `since ${time2} UTC`].filter(Boolean).join(" ");
-  return `the index is not open yet${where ? ` (${where})` : ""}`;
-}
-function recallLimit(limit = RECALL_DEFAULT_LIMIT) {
-  return Math.max(1, Math.min(RECALL_MAX_LIMIT, Math.floor(limit)));
-}
-var RecallClient = class {
-  constructor(options) {
-    this.options = options;
-  }
-  async files(repo, path34, limit) {
-    return parseFileTurns(
-      await this.get("/files", { repo, path: path34, limit: String(recallLimit(limit)) })
-    );
-  }
-  async sessionFiles(session, limit) {
-    return parseSessionFiles(
-      await this.get(`/sessions/${encodeURIComponent(session)}/files`, {
-        limit: String(recallLimit(limit))
-      })
-    );
-  }
-  async sessions(repo, limit) {
-    return parseRepoSessions(
-      await this.get("/sessions", { repo, limit: String(recallLimit(limit)) })
-    );
-  }
-  /** The catalog: the caller's sessions of the index, most recent activity
-   * first; `team`, every author's (recall-v1 `GET /sessions?scope=team`). */
-  async catalog(limit, options = {}) {
-    return parseCatalog(
-      await this.get("/sessions", {
-        ...options.team ? { scope: "team" } : {},
-        limit: String(recallLimit(limit))
-      })
-    );
-  }
-  async get(path34, query) {
-    const { fetch: fetcher, tokens: tokens2, key, origin, workspace } = this.options;
-    const url = `${recallBase(origin, workspace)}${path34}?${new URLSearchParams(query)}`;
-    const response = await tokens2.send(
-      key,
-      (token) => fetcher(url, {
-        redirect: "manual",
-        signal: AbortSignal.timeout(3e4),
-        headers: { authorization: `Bearer ${token}`, accept: "application/json" }
-      })
-    );
-    const body = await response.json().catch(() => null);
-    if (response.ok) return body;
-    const record3 = body && typeof body === "object" ? body : {};
-    const detail = indexUnavailableReason(response.status, body) ?? str(record3.detail) ?? str(record3.title) ?? str(record3.error);
-    throw new HttpError(
-      response.status === 404 ? "The recall API answered 404: it is not available for this workspace yet." : `The recall API answered ${response.status}${detail ? `: ${detail}` : "."}`,
-      response.status,
-      body,
-      response.headers.get("x-request-id")
-    );
-  }
-};
-
-// src/team-conflicts.ts
-var TEAM_POLL_MS = 6e4;
-var NAMES_KEPT_MS = 10 * 6e4;
-function liveTeammate(row, now) {
-  const [shown] = psRows([row], { device: "", now, all: true });
-  return ["running", "waiting", "idle"].includes(shown?.shown_state ?? "");
-}
-function teamConflicts(mine, catalog, options) {
-  const found = [];
-  for (const row of catalog.rows) {
-    if (!row.author || row.author === catalog.me || !liveTeammate(row, options.now)) continue;
-    const theirs = /* @__PURE__ */ new Set();
-    for (const turn of row.turns)
-      if (options.now - turn.at_ms < CONFLICT_WINDOW_MS) {
-        for (const file of turn.paths_written) if (!ignoredPath(file)) theirs.add(file);
-      }
-    if (!theirs.size) continue;
-    for (const own of mine) {
-      const pair = `t ${own.session} ${row.session}`;
-      if (options.alerted(pair)) continue;
-      const files = Object.entries(own.paths).filter(([file, ms]) => options.now - ms < CONFLICT_WINDOW_MS && theirs.has(file)).map(([file]) => file).sort();
-      if (files.length)
-        found.push({
-          pair,
-          session: own.session,
-          teammate: row.session,
-          author: row.author,
-          files
-        });
+              member2.display_name ?? member2.name ?? member2.subject
+            ])
+          )
+        };
+        names.set(accountId, entry);
+      }
+      return entry.names.get(sub) ?? null;
     }
-  }
-  return found;
-}
-function teamConflictMessage(conflict, name, now) {
-  const shown = conflict.files.slice(0, 3).join(", ") + (conflict.files.length > 3 ? `, +${conflict.files.length - 3}` : "");
-  const who = name ?? `teammate ${conflict.author.slice(0, 8)}`;
-  return {
-    id: `c${createHash6("sha256").update(conflict.pair).digest("hex").slice(0, 10)}`,
-    kind: "conflict",
-    at: new Date(now).toISOString(),
-    recipient: { kind: "session", id: conflict.session },
-    reason: "a teammate's live session wrote the same file",
-    source: { kind: "local", detail: conflict.teammate },
-    content: `${who}'s session ${conflict.teammate.slice(0, 8)} in this team Project also wrote ${shown} in the last 2 h`,
-    notify: true
   };
 }
-function teamCatalogReader(options) {
-  const people = /* @__PURE__ */ new Map();
-  return async (accountId) => {
-    const file = await options.credentials.load();
-    const login = file ? accountLogins(file).find(
-      (entry) => entry.account_id === accountId && entry.kind !== "user" && !isExpiredLogin(entry)
-    ) : void 0;
-    if (!login) throw new Error(`no current login of organization ${accountId}`);
-    let known = people.get(accountId);
-    if (!known || known.key !== login.key || Date.now() - known.at > NAMES_KEPT_MS) {
-      const [account, members, store] = await Promise.all([
-        options.api.getAccount(login.key),
-        options.api.page(
-          "listMembers",
-          login.key,
-          { limit: 100 }
-        ),
-        getSessionsStore(options.fetch, options.apiOrigin, login.key, { team: true })
-      ]);
-      known = {
-        at: Date.now(),
-        key: login.key,
-        me: account.member.subject,
-        workspace: workspaceHex(store.workspace_id),
-        names: new Map(
-          members.data.map((member2) => [
-            member2.subject,
-            member2.display_name ?? member2.name ?? member2.subject
-          ])
-        )
-      };
-      people.set(accountId, known);
-    }
-    const recall = new RecallClient({
-      fetch: options.fetch,
-      tokens: options.gitTokens,
-      key: login.key,
-      origin: gitOrigin(options.apiOrigin),
-      workspace: known.workspace
-    });
-    return { me: known.me, names: known.names, rows: await recall.catalog(100, { team: true }) };
-  };
+function inboxLine(message3, status) {
+  return `${status.padEnd(11)} ${message3.id}  ${message3.at}  ${message3.content}  (${message3.reason})`;
+}
+async function ackHandoff(store, handoffId2) {
+  try {
+    const marks = await store.marks();
+    const ids = (await store.messages()).filter(
+      (message3) => message3.source.kind === "handoff" && message3.source.handoff_id === handoffId2 && unread(statusOf(marks, message3.id))
+    ).map((message3) => message3.id);
+    if (!ids.length) return;
+    const at = (/* @__PURE__ */ new Date()).toISOString();
+    for (const id of ids) marks.marks[id] = { ...marks.marks[id], status: "read", at };
+    await store.saveMarks(marks);
+  } catch {
+  }
 }
 
 // src/conflicts.ts
@@ -7301,7 +7629,7 @@ function conflictMessages(state, conflict, now, home) {
     const theirs = state.sessions[other];
     const where = theirs.cwd ? ` in ${tilde(theirs.cwd, home)}` : "";
     return {
-      id: `c${createHash7("sha256").update(`${conflict.pair} ${me}`).digest("hex").slice(0, 10)}`,
+      id: `c${createHash8("sha256").update(`${conflict.pair} ${me}`).digest("hex").slice(0, 10)}`,
       kind: "conflict",
       at: new Date(now).toISOString(),
       recipient: { kind: "session", id: me },
@@ -7338,6 +7666,8 @@ var ConflictWatch = class {
   capped = "";
   polled = /* @__PURE__ */ new Map();
   failing = /* @__PURE__ */ new Map();
+  projects = /* @__PURE__ */ new Map();
+  ownPolled = 0;
   /** A turn's writes, which its end clears from the session's state before
    * the next pass sees them. */
   turnEnded(writes) {
@@ -7387,7 +7717,10 @@ var ConflictWatch = class {
           }
         }
         const repository = await this.repository(write.cwd);
-        if (repository) remember(state, { ...write, repository });
+        if (!repository) continue;
+        remember(state, { ...write, repository });
+        const project = place ? null : await this.project(write.cwd);
+        if (project) state.sessions[write.session].project = project;
       }
       prune(state, now);
       const live = (session) => liveEntry(entries.get(session));
@@ -7402,10 +7735,23 @@ var ConflictWatch = class {
         now
       );
       await this.teammates(state, live, now);
+      await this.devices(state, live, now);
     } catch (error) {
       log("warn", `conflicts: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
+  /** A personal cwd's Project, looked up again after TEAM_POLL_MS. */
+  project(cwd) {
+    const lookup = this.options.devices?.project;
+    if (!lookup) return Promise.resolve(null);
+    const now = this.options.now();
+    let cached = this.projects.get(cwd);
+    if (!cached || now - cached.at >= TEAM_POLL_MS) {
+      cached = { at: now, found: lookup(cwd).catch(() => null) };
+      this.projects.set(cwd, cached);
+    }
+    return cached.found;
+  }
   /** How many of `found` pairs today's cap still lets alert. */
   room(state, found) {
     const room = Math.max(0, CONFLICT_DAILY_CAP - state.day.count);
@@ -7464,124 +7810,49 @@ var ConflictWatch = class {
       );
     }
   }
-};
-
-// src/generated/machine.ts
-var machineRegisterDefs = {
-  "byoc_arch": {
-    "description": "A `byoc` device's architecture; grows only by a contract change. The regional machine_byoc_arches() equals it.",
-    "enum": [
-      "arm64",
-      "amd64"
-    ]
-  },
-  "byoc_client": {
-    "description": "The client that registered a `byoc` device; grows only by a contract change. The regional machine_byoc_clients() equals it.",
-    "enum": [
-      "yield"
-    ]
-  },
-  "byoc_client_version": {
-    "description": "The client's version, a semantic version of at most 64 octets.",
-    "type": "string",
-    "maxLength": 64,
-    "pattern": "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)(-[0-9A-Za-z-]+(\\.[0-9A-Za-z-]+)*)?(\\+[0-9A-Za-z-]+(\\.[0-9A-Za-z-]+)*)?$"
-  },
-  "byoc_harness": {
-    "description": "An agent harness `yield` captures on a `byoc` device: a key of contracts/sessions/capture-v1.json `sources`, its one authority, which automation/tests/test_machines_machine_v2_contract.py holds this enum equal to. The regional machine_byoc_harnesses() equals it.",
-    "enum": [
-      "claude-code",
-      "codex"
-    ]
-  },
-  "byoc_harnesses": {
-    "description": "The harnesses installed on the device that its client captures, without duplicates.",
-    "type": "array",
-    "uniqueItems": true,
-    "items": {
-      "$ref": "#/$defs/byoc_harness"
-    }
-  },
-  "byoc_hostname": {
-    "description": "The device's hostname as the client reports it, at most 253 octets (the database counts octets). Personal data, answered to the device's owner only (machine-v2.json `byoc.visibility`).",
-    "type": "string",
-    "minLength": 1,
-    "maxLength": 253
-  },
-  "byoc_os": {
-    "description": "A `byoc` device's operating system family; grows only by a contract change. The regional machine_byoc_oses() equals it.",
-    "enum": [
-      "darwin",
-      "linux"
-    ]
-  },
-  "name": {
-    "description": "A Machine name: the Agent name grammar (contracts/agents/agent-name-v1.json `$defs.name`, the same pattern and lengths, which the contract test holds equal) without its reserved-name list, which a Machine label cannot collide with (machine-v2.json `names`); 1-40 characters, no `--` and no `.`. Unique within its account across both kinds (ADR-0015 Q5); `<name>-<account>` must also pass the label rule of machine-v2.json `hostnames` for a managed Machine. `self` is reserved, so `/v1/machines/self` never names a Machine; global machine_name_valid follows this definition verbatim.",
-    "type": "string",
-    "minLength": 1,
-    "maxLength": 40,
-    "pattern": "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$",
-    "not": {
-      "const": "self"
-    }
-  },
-  "register": {
-    "description": "The body of `PUT /v1/machines/self` (machine-v2.json `actions` `register`, ADR-0015 `Registration`), signed by the CLI login key of the computer it registers. It has no `kind`: the server derives `byoc`, and a `kind` is refused as an unknown field. `name` is read only by the registration that creates the device; a device that exists keeps its name.",
-    "type": "object",
-    "additionalProperties": false,
-    "required": [
-      "device_id",
-      "hostname",
-      "os",
-      "arch",
-      "client",
-      "client_version",
-      "harnesses"
-    ],
-    "properties": {
-      "device_id": {
-        "$ref": "#/$defs/uuid"
-      },
-      "hostname": {
-        "$ref": "#/$defs/byoc_hostname"
-      },
-      "os": {
-        "$ref": "#/$defs/byoc_os"
-      },
-      "arch": {
-        "$ref": "#/$defs/byoc_arch"
-      },
-      "client": {
-        "$ref": "#/$defs/byoc_client"
-      },
-      "client_version": {
-        "$ref": "#/$defs/byoc_client_version"
-      },
-      "harnesses": {
-        "$ref": "#/$defs/byoc_harnesses"
-      },
-      "name": {
-        "$ref": "#/$defs/name"
+  /** Compares my live personal sessions' writes here with my live sessions
+   * of the same Project on my other devices, from my personal catalog, read
+   * at most each TEAM_POLL_MS and only while one of them has writes in the
+   * window. */
+  async devices(state, live, now) {
+    const own = this.options.devices;
+    if (!own) return;
+    const mine = [];
+    for (const [session, entry] of Object.entries(state.sessions)) {
+      if (!entry.project || !live(session)) continue;
+      const paths = {};
+      for (const [key, ms] of Object.entries(entry.paths)) {
+        const file = key.slice(key.indexOf("\n") + 1);
+        paths[file] = Math.max(paths[file] ?? 0, ms);
       }
-    }
-  },
-  "uuid": {
-    "description": "A lowercase canonical UUID.",
-    "type": "string",
-    "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"
+      mine.push({ session, project: entry.project, paths });
+    }
+    if (!mine.length || now - this.ownPolled < TEAM_POLL_MS) return;
+    this.ownPolled = now;
+    const catalog = await own.read().catch((error) => {
+      const reason = error instanceof Error ? error.message : String(error);
+      if (this.failing.get("") !== reason)
+        this.options.log("warn", `conflicts across devices: ${reason}`);
+      this.failing.set("", reason);
+      return null;
+    });
+    if (!catalog) return;
+    this.failing.delete("");
+    const found = deviceConflicts(mine, catalog.rows, {
+      device: own.device,
+      now,
+      alerted: (pair) => pair in state.pairs
+    });
+    await this.alert(
+      state,
+      found.slice(0, this.room(state, found.length)).map((conflict) => ({
+        pair: conflict.pair,
+        messages: [deviceConflictMessage(conflict, catalog.names, now, this.options.home)]
+      })),
+      now
+    );
   }
 };
-var byocPresence = {
-  "heartbeat": {
-    "interval_seconds": 300,
-    "jitter_seconds": 30
-  },
-  "online_window_seconds": 900
-};
-var byocRetryable = [
-  "device_registration_conflict",
-  "device_report_throttled"
-];
 
 // src/register.ts
 import { existsSync as existsSync2, readFileSync } from "node:fs";
@@ -7873,7 +8144,7 @@ function message(error) {
 }
 
 // src/snapshot.ts
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 import { lstat as lstat4, mkdir as mkdir6, realpath as realpath5 } from "node:fs/promises";
 import path19 from "node:path";
 var MAX_SNAPSHOT_FILE_BYTES = 100 * 1024 * 1024;
@@ -8135,7 +8406,7 @@ var Snapshots = class {
     const index = path19.join(
       this.deps.directory,
       "index",
-      createHash8("sha256").update(folder).digest("hex").slice(0, 32)
+      createHash9("sha256").update(folder).digest("hex").slice(0, 32)
     );
     await mkdir6(path19.dirname(index), { recursive: true, mode: 448 });
     const env = { GIT_INDEX_FILE: index };
@@ -8595,7 +8866,18 @@ async function runDaemon(options, signal) {
       fetch: options.fetch ?? fetch,
       apiOrigin: options.apiOrigin,
       gitTokens: options.gitTokens
-    }) : void 0
+    }) : void 0,
+    devices: options.apiOrigin && router ? {
+      device,
+      project: async (cwd) => (await router.project(cwd))?.project_id ?? null,
+      read: ownCatalogReader({
+        key: async () => (await captureLogin(options.credentials).catch(() => null))?.key ?? null,
+        api: new ManagementApi(options.fetch ?? fetch, options.apiOrigin),
+        fetch: options.fetch ?? fetch,
+        apiOrigin: options.apiOrigin,
+        gitTokens: options.gitTokens
+      })
+    } : void 0
   }) : void 0;
   const registration = registerOnHeartbeat(options, device, signal);
   const inbox = options.inbox && options.apiOrigin ? pollInbox(
@@ -9136,7 +9418,7 @@ async function acquireLock(filename) {
 
 // src/device.ts
 import { execFile as execFile6 } from "node:child_process";
-import { createHash as createHash9, randomUUID as randomUUID9 } from "node:crypto";
+import { createHash as createHash10, randomUUID as randomUUID9 } from "node:crypto";
 import { link, mkdir as mkdir8, open as open10, readFile as readFile12, rename as rename8, rm as rm9 } from "node:fs/promises";
 import path23 from "node:path";
 import { promisify as promisify6 } from "node:util";
@@ -9159,7 +9441,7 @@ async function readMachineId(platform = process.platform) {
   return null;
 }
 function machineIdHash(machineId) {
-  return createHash9("sha256").update(machineId).digest("hex");
+  return createHash10("sha256").update(machineId).digest("hex");
 }
 var DeviceStore = class {
   constructor(filename = path23.join(stateDirectory(), "device.json"), machineId = readMachineId) {
@@ -9712,44 +9994,6 @@ async function directHandoff(deps, target, options = {}) {
   }
 }
 
-// src/devices.ts
-async function listDevices(list2) {
-  const devices = [];
-  const unavailable = /* @__PURE__ */ new Set();
-  let cursor;
-  for (; ; ) {
-    const page = await list2(cursor ? { cursor } : {});
-    devices.push(
-      ...page.data.filter((machine) => machine.kind === "byoc")
-    );
-    for (const region of page.unavailable_regions ?? []) unavailable.add(region);
-    if (!page.next_cursor || page.next_cursor === cursor) break;
-    cursor = page.next_cursor;
-  }
-  return { devices, unavailableRegions: [...unavailable] };
-}
-var DISPATCHABLE = /* @__PURE__ */ new Set(["claude-code", "codex"]);
-function isOnline(lastSeen, now) {
-  const seen = Date.parse(lastSeen);
-  return Number.isFinite(seen) && now - seen <= byocPresence.online_window_seconds * 1e3;
-}
-function deviceRows(devices, device, now) {
-  return devices.map((machine) => ({
-    dispatch_target: machine.byoc.device_id !== device && machine.byoc.key_state === "active" && isOnline(machine.byoc.last_seen, now) && machine.byoc.harnesses.some((harness) => DISPATCHABLE.has(harness)),
-    name: machine.name,
-    os: machine.byoc.os,
-    arch: machine.byoc.arch,
-    harnesses: machine.byoc.harnesses,
-    client_version: machine.byoc.client_version,
-    last_seen: machine.byoc.last_seen,
-    online: isOnline(machine.byoc.last_seen, now),
-    key_state: machine.byoc.key_state,
-    this_device: machine.byoc.device_id === device,
-    device_id: machine.byoc.device_id ?? null,
-    hostname: machine.byoc.hostname ?? null
-  })).sort((a, b) => Number(b.this_device) - Number(a.this_device) || a.name.localeCompare(b.name));
-}
-
 // src/dispatch.ts
 import { spawn } from "node:child_process";
 import { realpathSync } from "node:fs";
@@ -10720,7 +10964,7 @@ async function thisMachine(options, key) {
 }
 
 // src/pull.ts
-import { createHash as createHash10, randomUUID as randomUUID12 } from "node:crypto";
+import { createHash as createHash11, randomUUID as randomUUID12 } from "node:crypto";
 import { open as open13, readFile as readFile16 } from "node:fs/promises";
 import path28 from "node:path";
 var SHA15 = /^[0-9a-f]{40}$/;
@@ -10759,7 +11003,7 @@ async function pullHandoff(deps, link3, cwd = process.cwd(), asPatch = false) {
       if (marker2.patch_file !== path28.basename(patchFile()) || !/^[0-9a-f]{64}$/.test(marker2.patch_sha256 ?? ""))
         throw new Error("The local patch marker is corrupt; no release was acknowledged.");
       const content = await readFile16(patchFile());
-      if (createHash10("sha256").update(content).digest("hex") !== marker2.patch_sha256)
+      if (createHash11("sha256").update(content).digest("hex") !== marker2.patch_sha256)
         throw new Error("The pulled patch changed; no release was acknowledged.");
     } else {
       if (marker2.branch !== branch())
@@ -10867,7 +11111,7 @@ async function pullHandoff(deps, link3, cwd = process.cwd(), asPatch = false) {
     handoff_id: id,
     commit: fetched,
     patch_file: path28.basename(patchFile()),
-    patch_sha256: createHash10("sha256").update(await readFile16(patchFile())).digest("hex")
+    patch_sha256: createHash11("sha256").update(await readFile16(patchFile())).digest("hex")
   } : { handoff_id: id, commit: fetched, branch: branch() };
   const file = await open13(markerFile(), "wx", 384);
   try {
@@ -10903,7 +11147,7 @@ async function pullHandoff(deps, link3, cwd = process.cwd(), asPatch = false) {
 }
 
 // src/give.ts
-import { createHash as createHash11, randomUUID as randomUUID13 } from "node:crypto";
+import { createHash as createHash12, randomUUID as randomUUID13 } from "node:crypto";
 import { mkdir as mkdir11, open as open14, readFile as readFile17 } from "node:fs/promises";
 import path29 from "node:path";
 var UUID11 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
@@ -10990,7 +11234,7 @@ async function giveHandoff(deps, target, session, task, assignment = OPEN) {
     target.folder,
     pushEnv
   );
-  const requestHash = createHash11("sha256").update(
+  const requestHash = createHash12("sha256").update(
     JSON.stringify(
       assignment.kind === "open" ? { task, target_kind: "open" } : {
         task,
@@ -11510,7 +11754,7 @@ function handoffLines(view, names = /* @__PURE__ */ new Map()) {
 }
 
 // src/skills.ts
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 import { mkdir as mkdir13, readFile as readFile18, rm as rm13, rmdir, writeFile as writeFile5 } from "node:fs/promises";
 import os10 from "node:os";
 import path31 from "node:path";
@@ -11520,7 +11764,7 @@ var tonboSkill = "---\nname: tonbo\ndescription: Recall the captured agent sessi
 
 // src/skills.ts
 var SKILL_NAME = "tonbo";
-var sha256 = (value) => createHash12("sha256").update(value).digest("hex");
+var sha256 = (value) => createHash13("sha256").update(value).digest("hex");
 function skillPaths(home = os10.homedir(), env = process.env) {
   const claude = env.CLAUDE_CONFIG_DIR || path31.join(home, ".claude");
   const codex = env.CODEX_HOME || path31.join(home, ".codex");
@@ -12374,19 +12618,27 @@ function createProgram(dependencies = createDependencies) {
   program.command("login").description("sign in through the browser; shared with the tonbo CLI").option("--account <name>", "the account to log in to; defaults to your personal account").option(
     "--name <name>",
     "the name this computer registers under the first time; <os>-<n> by default"
-  ).option("--no-daemon", "only sign in; do not install and start capture on this computer").action(async (options) => {
-    const deps = dependencies();
-    const login = await loginCommand(deps, { account: options.account });
-    if (login.kind === "organization") return;
-    await registerThisComputer(deps, options.name);
-    if (!options.daemon) return;
-    try {
-      deps.output((await installCapture()).join("\n"));
-      deps.output("Capture is on. `yield status` checks it; `yield ps` lists your sessions.");
-    } catch (error) {
-      deps.output(error instanceof Error ? error.message : String(error));
+  ).option("--no-daemon", "only sign in; do not install and start capture on this computer").option(
+    "--device",
+    "approve with a code in a browser on any computer, as over SSH without a display"
+  ).action(
+    async (options) => {
+      const deps = dependencies();
+      const login = await loginCommand(deps, {
+        account: options.account,
+        device: options.device
+      });
+      if (login.kind === "organization") return;
+      await registerThisComputer(deps, options.name);
+      if (!options.daemon) return;
+      try {
+        deps.output((await installCapture()).join("\n"));
+        deps.output("Capture is on. `yield status` checks it; `yield ps` lists your sessions.");
+      } catch (error) {
+        deps.output(error instanceof Error ? error.message : String(error));
+      }
     }
-  });
+  );
   program.command("give").description("push the latest captured snapshot of a session and create a handoff").argument("<session>", "full captured session id").requiredOption("--task <text>", "what the next person or harness should do").option(
     "--to <who>",
     "a teammate in a team Project (name or subject), claude-code or codex for yourself, or <device>:<harness> for another of your computers"