usebeeline 0.0.2 → 0.0.3

package/dist/usebeeline.mjs

@@ -47718,6 +47718,13 @@ Deliver artifacts from this corner; there is no branch to land.`;
   }
   /** Human decision path retained for a named repository outside the Room binding. */
   async cornerOpenAudience(roomId, requesterPubkey) {
+    if (this.daemonApi) {
+      const authority = await this.daemonApi.execute("getRoomAuthority", {
+        roomId,
+        principalId: requesterPubkey
+      });
+      return authority.member && authority.principalKind === "human" ? [requesterPubkey] : [];
+    }
     const members = await listMembers(this.agentClientContext(), roomId);
     const candidates = members.filter((member2) => member2.pubkey === requesterPubkey || member2.role === "admin" || member2.role === "owner");
     const checked = await Promise.all(candidates.map(async (member2) => ({
@@ -47756,9 +47763,10 @@ Deliver artifacts from this corner; there is no branch to land.`;
           message: published.message
         };
       }
-      const permissionId = randomUUID5();
+      const permissionId = this.daemonApi ? createHash10("sha256").update(`corner-permission\0${input.roomId}\0${input.request.eventId}`).digest("hex") : randomUUID5();
       const repository2 = input.roomRepo ? this.repoId(input.roomRepo) : "repo-less";
-      const audience = await this.cornerOpenAudience(input.roomId, input.request.authorPubkey);
+      const principalId = input.request.delegation?.rootHumanPubkey ?? input.request.authorPubkey;
+      const audience = await this.cornerOpenAudience(input.roomId, principalId);
       if (audience.length === 0) {
         throw new AgentToolKnownFailure("approval_audience_unavailable", "No eligible human is available to decide this corner request.", true);
       }
@@ -47766,7 +47774,18 @@ Deliver artifacts from this corner; there is no branch to land.`;
       const requester = requesterAttribution?.handle ?? fallbackPersonName(input.request.authorPubkey);
       const agent = (await this.roomAuthorAttributions(input.roomId, [this.agentIdentity.publicKey])).get(this.agentIdentity.publicKey)?.name ?? fallbackAgentName(this.agentIdentity.publicKey);
       const message2 = `@${requester.replace(/^@/, "")} asked ${agent} to open a corner for: ` + input.objective;
-      const card = buildControlMessage("permission-request", input.roomId, this.agentIdentity, message2, [
+      const card = this.daemonApi ? await this.daemonApi.execute("postPermissionRequest", {
+        roomId: input.roomId,
+        principalId,
+        permissionId,
+        requestId: input.request.eventId,
+        scope: {
+          type: "operation.execute",
+          connectorId: input.tool,
+          target: repository2,
+          payloadDigest: createHash10("sha256").update(input.objective).digest("hex")
+        }
+      }) : buildControlMessage("permission-request", input.roomId, this.agentIdentity, message2, [
         ["t", WRITE_PERMISSION_REQUEST_TAG],
         ["permission", permissionId],
         ["request", input.request.eventId],
@@ -47779,7 +47798,8 @@ Deliver artifacts from this corner; there is no branch to land.`;
         ...this.delegatedReplyTags(input.request),
         ...audience.map((pubkey2) => ["p", pubkey2])
       ]);
-      await publishEvent2(card, this.agentIdentity);
+      if (!this.daemonApi)
+        await publishEvent2(card, this.agentIdentity);
       void this.finishCornerApproval({ ...input, permissionId, repository: repository2, audience }).catch((error) => console.error("[body] corner approval settlement failed:", error));
       return { request_id: permissionId, event_id: card.id, message: message2 };
     })();
@@ -47792,6 +47812,8 @@ Deliver artifacts from this corner; there is no branch to land.`;
    * the signed pending card already authored for this exact member request.
    */
   async publishedCornerApproval(input) {
+    if (this.daemonApi)
+      return void 0;
     const repository2 = input.roomRepo ? this.repoId(input.roomRepo) : "repo-less";
     const events = await this.agentRelay.queryEvents([
       {
@@ -47811,9 +47833,11 @@ Deliver artifacts from this corner; there is no branch to land.`;
     return { permissionId, eventId: event.id, message: event.content, repository: repository2, audience };
   }
   async finishCornerApproval(input) {
+    const principalId = input.request.delegation?.rootHumanPubkey ?? input.request.authorPubkey;
     let deciderPubkey;
     const decision = await this.waitForWritePermissionDecision(input.roomId, input.permissionId, input.request.eventId, input.repository, 10 * 6e4, {
       allowedResponders: new Set(input.audience),
+      principalId,
       captureDecider: (pubkey2) => {
         deciderPubkey = pubkey2;
       }
@@ -47823,44 +47847,61 @@ Deliver artifacts from this corner; there is no branch to land.`;
     if (decision === "allow") {
       try {
         const info = await this.openSubchannelForRequest(input.roomId, input.roomRepo, input.objective, input.request, { objective: input.objective, suppressOpenCard: true });
-        await this.postWritePermissionStatus(input.roomId, input.permissionId, input.request.eventId, input.tool, input.repository, "allowed", `Corner approved by @${deciderHandle.replace(/^@/, "")} \u2014 view \u2192`, info.subchannelId, deciderPubkey, input.request.authorPubkey);
+        await this.postWritePermissionStatus(input.roomId, input.permissionId, input.request.eventId, input.tool, input.repository, "allowed", `Corner approved by @${deciderHandle.replace(/^@/, "")} \u2014 view \u2192`, info.subchannelId, deciderPubkey, principalId);
         this.startCornerTaskOnce(info, input.objective, cornerOpenTaskPrompt(info.taskDescription, input.objective), {
           requestId: input.request.eventId,
           originalRequestId: input.request.eventId,
           cause: "corner-opening"
         });
       } catch (error) {
-        await this.postWritePermissionStatus(input.roomId, input.permissionId, input.request.eventId, input.tool, input.repository, "failed", `Corner approved by @${deciderHandle.replace(/^@/, "")}, but it could not start: ${this.safePermissionFailure(error)}`, void 0, deciderPubkey, input.request.authorPubkey);
+        await this.postWritePermissionStatus(input.roomId, input.permissionId, input.request.eventId, input.tool, input.repository, "failed", `Corner approved by @${deciderHandle.replace(/^@/, "")}, but it could not start: ${this.safePermissionFailure(error)}`, void 0, deciderPubkey, principalId);
       }
       return;
     }
-    await this.postWritePermissionStatus(input.roomId, input.permissionId, input.request.eventId, input.tool, input.repository, decision === "deny" ? "denied" : "expired", decision === "deny" ? `Corner denied by @${deciderHandle.replace(/^@/, "")}.` : "The corner request expired without a decision.", void 0, deciderPubkey, input.request.authorPubkey);
+    await this.postWritePermissionStatus(input.roomId, input.permissionId, input.request.eventId, input.tool, input.repository, decision === "deny" ? "denied" : "expired", decision === "deny" ? `Corner denied by @${deciderHandle.replace(/^@/, "")}.` : "The corner request expired without a decision.", void 0, deciderPubkey, principalId);
   }
   async requestEditCornerApproval(input) {
     const { tlcChannelId, turn, repository: repository2, tool, objective, namedTarget, pendingMessage } = input;
-    const permissionId = randomUUID5();
-    const audience = await this.cornerOpenAudience(tlcChannelId, turn.request.authorPubkey);
+    const permissionId = this.daemonApi ? createHash10("sha256").update(`edit-permission\0${tlcChannelId}\0${turn.request.eventId}`).digest("hex") : randomUUID5();
+    const principalId = turn.request.delegation?.rootHumanPubkey ?? turn.request.authorPubkey;
+    const audience = await this.cornerOpenAudience(tlcChannelId, principalId);
     if (audience.length === 0) {
       throw new AgentToolKnownFailure("approval_audience_unavailable", "No eligible human is available to decide this corner request.", true);
     }
-    const requesterAttribution = turn.request.delegation ? (await this.roomAuthorAttributions(tlcChannelId, [turn.request.authorPubkey])).get(turn.request.authorPubkey) : turn.request.authorAttribution;
-    const requester = requesterAttribution?.handle ?? fallbackPersonName(turn.request.authorPubkey);
-    await postControlMessage("permission-request", tlcChannelId, this.agentIdentity, `@${requester.replace(/^@/, "")} asked ${this.agentIdentity.name || "the agent"} to open a corner for: ${objective || pendingMessage}`, [
-      ["t", WRITE_PERMISSION_REQUEST_TAG],
-      ["permission", permissionId],
-      ["request", turn.request.eventId],
-      ["requester", turn.request.authorPubkey],
-      ["agent", this.agentIdentity.publicKey],
-      ...audience.map((pubkey2) => ["p", pubkey2]),
-      ["tool", tool],
-      ["repo", repository2],
-      ["objective", objective],
-      ["status", "pending"],
-      ...this.delegatedReplyTags(turn.request)
-    ]);
+    const requesterAttribution = turn.request.delegation ? (await this.roomAuthorAttributions(tlcChannelId, [principalId])).get(principalId) : turn.request.authorAttribution;
+    const requester = requesterAttribution?.handle ?? fallbackPersonName(principalId);
+    if (this.daemonApi) {
+      await this.daemonApi.execute("postPermissionRequest", {
+        roomId: tlcChannelId,
+        principalId,
+        permissionId,
+        requestId: turn.request.eventId,
+        scope: {
+          type: "operation.execute",
+          connectorId: tool,
+          target: repository2,
+          payloadDigest: createHash10("sha256").update(objective || pendingMessage).digest("hex")
+        }
+      });
+    } else {
+      await postControlMessage("permission-request", tlcChannelId, this.agentIdentity, `@${requester.replace(/^@/, "")} asked ${this.agentIdentity.name || "the agent"} to open a corner for: ${objective || pendingMessage}`, [
+        ["t", WRITE_PERMISSION_REQUEST_TAG],
+        ["permission", permissionId],
+        ["request", turn.request.eventId],
+        ["requester", turn.request.authorPubkey],
+        ["agent", this.agentIdentity.publicKey],
+        ...audience.map((pubkey2) => ["p", pubkey2]),
+        ["tool", tool],
+        ["repo", repository2],
+        ["objective", objective],
+        ["status", "pending"],
+        ...this.delegatedReplyTags(turn.request)
+      ]);
+    }
     let deciderPubkey;
     const decision = await this.waitForWritePermissionDecision(tlcChannelId, permissionId, turn.request.eventId, repository2, 10 * 6e4, {
       allowedResponders: new Set(audience),
+      principalId,
       captureDecider: (pubkey2) => {
         deciderPubkey = pubkey2;
       }
@@ -47876,7 +47917,7 @@ Deliver artifacts from this corner; there is no branch to land.`;
           suppressOpenCard: true
         }) : await this.openSubchannel(tlcChannelId, boundRepo, objective, { ...turn.request, content: objective }, { objective, suppressOpenCard: true });
         turn.transitionedToCorner = true;
-        await this.postWritePermissionStatus(tlcChannelId, permissionId, turn.request.eventId, tool, repository2, "allowed", `Corner approved by @${deciderHandle.replace(/^@/, "")} \u2014 view \u2192`, info.subchannelId, deciderPubkey, turn.request.authorPubkey).catch((statusError) => console.error("[body] failed to publish direct corner navigation:", statusError));
+        await this.postWritePermissionStatus(tlcChannelId, permissionId, turn.request.eventId, tool, repository2, "allowed", `Corner approved by @${deciderHandle.replace(/^@/, "")} \u2014 view \u2192`, info.subchannelId, deciderPubkey, principalId).catch((statusError) => console.error("[body] failed to publish direct corner navigation:", statusError));
         this.startCornerTaskOnce(info, objective, cornerOpenTaskPrompt(info.taskDescription, objective), {
           requestId: turn.request.eventId,
           originalRequestId: turn.request.eventId,
@@ -47889,10 +47930,10 @@ Deliver artifacts from this corner; there is no branch to land.`;
       return;
     }
     if (decision === "deny") {
-      await this.postWritePermissionStatus(tlcChannelId, permissionId, turn.request.eventId, tool, repository2, "denied", `Corner denied by @${deciderHandle.replace(/^@/, "")}.`, void 0, deciderPubkey, turn.request.authorPubkey);
+      await this.postWritePermissionStatus(tlcChannelId, permissionId, turn.request.eventId, tool, repository2, "denied", `Corner denied by @${deciderHandle.replace(/^@/, "")}.`, void 0, deciderPubkey, principalId);
       return;
     }
-    await this.postWritePermissionStatus(tlcChannelId, permissionId, turn.request.eventId, tool, repository2, "expired", `The edit request for ${repository2} expired. The Agent remains read-only.`, void 0, void 0, turn.request.authorPubkey);
+    await this.postWritePermissionStatus(tlcChannelId, permissionId, turn.request.eventId, tool, repository2, "expired", `The edit request for ${repository2} expired. The Agent remains read-only.`, void 0, void 0, principalId);
   }
   permissionToolLabel(permission) {
     const title = permission.toolCall?.title?.trim();
@@ -48203,6 +48244,26 @@ Deliver artifacts from this corner; there is no branch to land.`;
     return summarizeGitFailure(raw).replace(/https?:\/\/\S+/gi, "the configured remote").replace(/(?:[A-Za-z0-9._~+/=-]+):(?:[A-Za-z0-9._~+/=-]+)@/g, "[credentials]@").replace(/\s+/g, " ").trim().slice(0, 240) || "the repository could not be cloned or accessed";
   }
   postWritePermissionStatus(tlcChannelId, permissionId, requestId, tool, repository2, status, message2, subchannelId, deciderPubkey, requesterPubkey) {
+    if (this.daemonApi) {
+      const publishStatus = async () => {
+        if (requesterPubkey && (status === "allowed" || status === "failed" || status === "expired")) {
+          await this.daemonApi.execute("postPermissionExecution", {
+            roomId: tlcChannelId,
+            principalId: requesterPubkey,
+            permissionId,
+            status: status === "allowed" ? "succeeded" : "failed",
+            result: message2
+          });
+        }
+        await this.daemonApi.execute("postRoomMessage", {
+          roomId: tlcChannelId,
+          requestId,
+          text: message2,
+          presentation: "system"
+        });
+      };
+      return publishStatus();
+    }
     return postControlMessage("permission-status", tlcChannelId, this.agentIdentity, message2, [
       ["t", WRITE_PERMISSION_REQUEST_TAG],
       ["permission", permissionId],
@@ -48227,6 +48288,53 @@ Deliver artifacts from this corner; there is no branch to land.`;
    * pending decision until timeout.
    */
   async waitForWritePermissionDecision(tlcChannelId, permissionId, requestId, repository2, timeoutMs = 10 * 6e4, options = {}) {
+    if (this.daemonApi) {
+      if (!options.principalId)
+        throw new Error("monolith permission wait requires a principal");
+      const deadline2 = Date.now() + timeoutMs;
+      return new Promise((resolvePromise, rejectPromise) => {
+        let settled = false;
+        let polling = false;
+        const finish = (result) => {
+          if (settled)
+            return;
+          settled = true;
+          clearTimeout(timer);
+          clearInterval(backstop);
+          resolvePromise(result);
+        };
+        const pollOnce = async () => {
+          if (settled || polling)
+            return;
+          polling = true;
+          try {
+            const authority = await this.daemonApi.execute("getPermissionAuthority", {
+              roomId: tlcChannelId,
+              principalId: options.principalId,
+              permissionId
+            });
+            if (authority.status === "authorized")
+              finish("allow");
+            if (authority.status === "denied")
+              finish("deny");
+          } catch (error) {
+            if (!isTransientPermissionPollError(error)) {
+              settled = true;
+              clearTimeout(timer);
+              clearInterval(backstop);
+              rejectPromise(error);
+            }
+          } finally {
+            polling = false;
+          }
+        };
+        const timer = setTimeout(() => finish("timeout"), Math.max(0, deadline2 - Date.now()));
+        timer.unref?.();
+        const backstop = setInterval(() => void pollOnce(), WRITE_PERMISSION_BACKSTOP_POLL_MS);
+        backstop.unref?.();
+        void pollOnce();
+      });
+    }
     const startedAt = Math.floor(Date.now() / 1e3) - 1;
     const deadline = Date.now() + timeoutMs;
     const matchingDecision = async (event) => {
@@ -51176,6 +51284,55 @@ async function assertRuntimeStorageWritable(supervisorRoot, agentPubkey) {
     await rm7(probe, { force: true }).catch(() => void 0);
   }
 }
+async function stageMonolithAgentRuntime(input) {
+  const supervisorRoot = input.supervisorRoot ? resolve28(input.supervisorRoot) : defaultSupervisorRoot(input.env);
+  const baseUrl = new URL(input.monolithBaseUrl).origin;
+  if (baseUrl !== input.monolithBaseUrl || !/^https?:$/.test(new URL(baseUrl).protocol)) {
+    throw new Error("monolith base URL must be an HTTP or HTTPS origin");
+  }
+  if (!/^bde_[A-Za-z0-9_-]{43}$/.test(input.daemonExchangeToken)) {
+    throw new Error("daemon exchange token is invalid");
+  }
+  const configPath = resolve28(runtimeDirectory(supervisorRoot, input.agentIdentity.publicKey), "runtime.json");
+  if (await agentRuntimeExists(supervisorRoot, input.agentIdentity.publicKey)) {
+    const existing = await readRuntimeRecord(configPath);
+    const transport = existing.transport;
+    const sameRuntime = existing.communityId === input.workspaceId && existing.pairedBy === input.pairedBy && existing.agent.publicKey === input.agentIdentity.publicKey && existing.agent.secretKeyHex === Buffer.from(input.agentIdentity.secretKey).toString("hex") && existing.body.publicKey === input.bodyIdentity.publicKey && transport?.kind === "monolith" && transport.baseUrl === baseUrl && ("daemonToken" in transport || transport.exchangeToken === input.daemonExchangeToken);
+    if (!sameRuntime) {
+      throw new Error(`agent identity ${input.agentIdentity.publicKey} already has another runtime`);
+    }
+    return { runtime: existing, configPath };
+  }
+  await assertRuntimeStorageWritable(supervisorRoot, input.agentIdentity.publicKey);
+  const runtime = {
+    version: 2,
+    communityId: input.workspaceId,
+    pairedBy: input.pairedBy,
+    agent: storeIdentity(input.agentIdentity, DEFAULT_AGENT_IDENTITY_NAME),
+    body: storeIdentity(input.bodyIdentity, DEFAULT_BODY_IDENTITY_NAME),
+    rooms: [],
+    supervisorRoot,
+    // Required only by legacy records. Monolith runtimes never construct a
+    // relay client, so retaining the server origin here cannot route traffic.
+    relayBaseUrl: baseUrl,
+    transport: {
+      kind: "monolith",
+      baseUrl,
+      exchangeToken: input.daemonExchangeToken
+    },
+    ...input.llmEnvFile ? { llmEnvFile: input.llmEnvFile } : {},
+    accessPolicy: DEFAULT_ACCESS_POLICY,
+    ...input.modelSelection?.model || input.modelSelection?.effort ? { modelSelection: input.modelSelection } : {},
+    agentKind: input.agentKind,
+    agentCommand: input.agentCommand,
+    agentArgs: [...input.agentArgs ?? []],
+    agentBinary: input.agentBinary,
+    mcpBinary: input.mcpBinary,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const writtenPath = await writeRuntimeRecord(runtime);
+  return { runtime, configPath: writtenPath };
+}
 async function writeRuntimePointer(gitCommonDir, agentPubkey, targetConfigPath) {
   const directory = runtimeDirectory(gitCommonDir, agentPubkey);
   const path = resolve28(directory, "runtime.json");
@@ -55703,33 +55860,49 @@ async function pairOneAgent(input) {
     throw error;
   }
 }
-async function completeDevicePairing(grant) {
-  const selectedAgent = await selectPairAgentCommand({
+async function completeDevicePairing(grant, options = {}) {
+  const selectedAgent = options.selectedAgent ?? await selectPairAgentCommand({
     explicitKind: grant.harness,
     env: process.env,
     cwd: process.cwd(),
     interactive: true,
     confirmInstall: async () => true
   });
-  const result = await pairOneAgent({
-    code: grant.pairingCode,
-    selectedAgent,
-    agentIdentity: identityFromKey(grant.agentSecretKey, grant.agentName),
-    bodyIdentity: identityFromKey(grant.bodySecretKey, DEFAULT_BODY_IDENTITY_NAME),
-    cwd: process.cwd(),
-    repo: null,
-    progressLabel: "Connecting agent\u2026",
-    progressDone: (pid) => `Connected (pid ${pid}).`,
+  const localConfig = options.localConfig ?? loadBodyConfig({
+    workspaceRoot: process.cwd(),
+    ...grant.llmEnvFile ? { llmEnvFile: grant.llmEnvFile } : {},
+    agent: selectedAgent
+  });
+  await (options.validateSelection ?? validateModelSelection)(selectedAgent, localConfig.agentEnv, {
+    model: grant.model
+  });
+  const agentIdentity = identityFromKey(grant.agentSecretKey, grant.agentName);
+  const staged = await stageMonolithAgentRuntime({
+    workspaceId: grant.workspaceId,
+    pairedBy: grant.pairedBy,
+    monolithBaseUrl: grant.monolithBaseUrl,
+    daemonExchangeToken: grant.daemonExchangeToken,
     ...grant.llmEnvFile ? { llmEnvFile: grant.llmEnvFile } : {},
-    access: "creator",
+    agentBinary: localConfig.agentBinary,
+    agentKind: selectedAgent.kind,
+    agentCommand: selectedAgent.command,
+    agentArgs: selectedAgent.args,
     modelSelection: { model: grant.model },
-    agentProfile: { displayName: grant.agentName, personality: grant.soul },
-    interactiveUi: false
+    mcpBinary: localConfig.mcpBinary,
+    agentIdentity,
+    bodyIdentity: identityFromKey(grant.bodySecretKey, DEFAULT_BODY_IDENTITY_NAME),
+    ...options.supervisorRoot ? { supervisorRoot: options.supervisorRoot } : {}
   });
-  if (result.pairing.communityId !== grant.workspaceId) {
-    throw new Error("approved Workspace did not match the pairing grant");
+  const activated = await activateDaemonTransport(staged.configPath, options.fetchImpl);
+  if (!activated)
+    throw new Error("monolith daemon transport activation failed");
+  let pid;
+  try {
+    pid = await (options.launch ?? (async (configPath, publicKey) => process.platform === "linux" && process.env.BEELINE_SYSTEMD_USER !== "0" ? installAgentService(publicKey) : launchRuntimeDaemon(configPath)))(staged.configPath, agentIdentity.publicKey);
+  } catch (error) {
+    throw new Error(`agent ${agentIdentity.publicKey} is connected, but its daemon did not start: ${error instanceof Error ? error.message : String(error)}. Run \`beeline start --agent ${agentIdentity.publicKey}\`.`, { cause: error });
   }
-  return result;
+  return { runtime: activated.runtime, configPath: staged.configPath, pid };
 }
 function printPairResult(result) {
   console.log(`[buzz] paired agent ${import_picocolors3.default.bold(result.pairing.agent.displayName)}`);
@@ -56123,7 +56296,6 @@ async function runConnectCommand(code, options = {}) {
   const llmEnvFile = await writeProviderEnv(selection, grant.agent_pubkey);
   const grantPath = resolve37(defaultSupervisorRoot(process.env), "beeline", "connect", `grant-${process.pid}-${Date.now()}.json`);
   await writePrivateJson(grantPath, {
-    pairingCode: grant.pairing_code,
     agentSecretKey: grant.agent_secret_key,
     bodySecretKey: grant.body_secret_key,
     agentName: grant.agent_name,
@@ -56132,6 +56304,9 @@ async function runConnectCommand(code, options = {}) {
     soul: grant.soul,
     workspaceId: grant.workspace_id,
     workspaceName: grant.workspace_name,
+    pairedBy: grant.paired_by,
+    monolithBaseUrl: baseUrl,
+    daemonExchangeToken: grant.daemon_exchange_token,
     ...llmEnvFile ? { llmEnvFile } : {}
   });
   await brassSpinner("Starting your agent\u2026", () => runInstalledFinish(installedBinary, grantPath));
@@ -56144,7 +56319,13 @@ function isDevicePairingGrant(value) {
   if (!value || typeof value !== "object")
     return false;
   const grant = value;
-  return typeof grant.pairingCode === "string" && typeof grant.agentSecretKey === "string" && /^[0-9a-f]{64}$/.test(grant.agentSecretKey) && typeof grant.bodySecretKey === "string" && /^[0-9a-f]{64}$/.test(grant.bodySecretKey) && typeof grant.agentName === "string" && CONNECT_HARNESSES.includes(grant.harness) && typeof grant.model === "string" && typeof grant.soul === "string" && typeof grant.workspaceId === "string" && typeof grant.workspaceName === "string";
+  let monolithOrigin = "";
+  try {
+    monolithOrigin = new URL(grant.monolithBaseUrl ?? "").origin;
+  } catch {
+    return false;
+  }
+  return typeof grant.agentSecretKey === "string" && /^[0-9a-f]{64}$/.test(grant.agentSecretKey) && typeof grant.bodySecretKey === "string" && /^[0-9a-f]{64}$/.test(grant.bodySecretKey) && typeof grant.agentName === "string" && CONNECT_HARNESSES.includes(grant.harness) && typeof grant.model === "string" && typeof grant.soul === "string" && typeof grant.workspaceId === "string" && typeof grant.workspaceName === "string" && typeof grant.pairedBy === "string" && /^[0-9a-f]{64}$/.test(grant.pairedBy) && typeof grant.monolithBaseUrl === "string" && grant.monolithBaseUrl === monolithOrigin && /^https?:$/.test(new URL(monolithOrigin).protocol) && typeof grant.daemonExchangeToken === "string" && /^bde_[A-Za-z0-9_-]{43}$/.test(grant.daemonExchangeToken);
 }
 async function runConnectFinishCommand(path) {
   if (!path)

package/package.json

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