@saadnvd1/agent-os 0.3.700 → 0.3.715

package/lib/orchestrator/conditions.ts

@@ -10,6 +10,8 @@
 import { runForSession } from "../recipes/store";
 import { db, type StackItemStatus, type StackStatus } from "../db";
 import { isFinished, type TaskPR } from "../tasks/state";
+import { eventLine } from "../claims/overlapText";
+import type { SessionOverlap } from "../claims/mine";
 import { ciWord } from "./describe";
 import type { SessionFacts } from "./facts";
 import { untrusted } from "./untrusted";
@@ -192,6 +194,29 @@ function stackConditions(s: StackFacts): Condition[] {
   return out;
 }
 
+// A strong overlap between a session here and other work, anywhere. Held
+// until it ends, so it goes through the events' two-diff damping and
+// REFIRE_MS, and an overlap that only flickers is dropped.
+function overlapConditions(
+  facts: SessionFacts[],
+  overlaps: SessionOverlap[]
+): Condition[] {
+  const names = new Map(facts.map((f) => [f.id, f.name]));
+  return overlaps.flatMap((o) => {
+    const name = names.get(o.sessionId);
+    if (!name) return [];
+    return [
+      {
+        key: conditionKey(`overlap:${o.pairKey}`, o.sessionId),
+        subject: o.sessionId,
+        line: eventLine(o, name),
+        sticky: false,
+        low: true,
+      },
+    ];
+  });
+}
+
 // Sessions the orchestrator itself messaged this recently don't raise
 // "needs input": that's most likely it waiting on its own question.
 export const QUIET_AFTER_MESSAGE_MS = 2 * 60 * 1000;
@@ -200,11 +225,13 @@ export function conditionsFor(
   facts: SessionFacts[],
   stacks: StackFacts[],
   now = Date.now(),
-  quiet: ReadonlySet<string> = new Set()
+  quiet: ReadonlySet<string> = new Set(),
+  overlaps: SessionOverlap[] = []
 ): Condition[] {
   return [
     ...facts.flatMap((f) => sessionConditions(f, now, quiet.has(f.id))),
     ...stacks.flatMap(stackConditions),
+    ...overlapConditions(facts, overlaps),
   ];
 }
 

package/lib/orchestrator/describe.ts

@@ -37,6 +37,7 @@ function sessionLine(f: SessionFacts): string {
       task += `, BLOCKED: ${untrusted(f.name, f.task.blocked)}`;
     parts.push(task);
   }
+  if (f.group) parts.push(`in group "${f.group}"`);
   if (f.plan)
     parts.push(
       `${f.plan.awaiting ? "plan ready, awaiting your approve_plan" : f.plan.planned ? "planned" : "no plan"}${f.plan.reason ? `: ${untrusted(f.name, f.plan.reason)}` : ""}`
@@ -66,7 +67,8 @@ function sessionLine(f: SessionFacts): string {
 // The sessions tool's answer: one line per session, busiest news first.
 export function describeSessions(
   workspace: string,
-  facts: SessionFacts[]
+  facts: SessionFacts[],
+  groups: readonly string[] = []
 ): string {
   if (!facts.length) return `No sessions are running in ${workspace}.`;
   const rank = { waiting: 0, running: 1, idle: 2, dead: 3 };
@@ -82,5 +84,8 @@ export function describeSessions(
   return [
     `${facts.length} ${noun} in ${workspace}${summary}:`,
     ...sorted.map(sessionLine),
+    ...(groups.length
+      ? [`Saad's groups here: ${groups.map((g) => `"${g}"`).join(", ")}.`]
+      : []),
   ].join("\n");
 }

package/lib/orchestrator/facts.ts

@@ -5,6 +5,7 @@
  * read this.
  */
 
+import { groupNames } from "../session-groups/store";
 import { db, type Session, type StackItemStatus } from "../db";
 import { statusDetector } from "../status-detector";
 import { hostLink } from "../hosts/remote-api";
@@ -43,6 +44,8 @@ export interface SessionFacts {
   stalled?: Stall | null;
   // Its agent is summarising the context: not stuck, not plain work.
   compacting?: boolean;
+  // Saad's group it sits in, when it is in one.
+  group?: string | null;
   // Last sign of life, in ms.
   lastActive: number;
   // Open waits (aos send --await, aos wait): who it waits on, and who waits on it.
@@ -308,6 +311,7 @@ export async function sessionFacts(
 ): Promise<SessionFacts[]> {
   await statusDetector.refreshCache();
   const badges = waitBadges();
+  const groups = groupNames();
   return Promise.all(
     workspaceSessions(workspaceId).map(async (s) => {
       const [{ status, activity, needsInput }, task] = await Promise.all([
@@ -336,6 +340,7 @@ export async function sessionFacts(
           s.view === "chat" && !hostLink(s.host_id) ? chatStall(s.id) : null,
         compacting:
           s.view === "chat" && !hostLink(s.host_id) && !!chatCompacting(s.id),
+        group: groups.get(s.session_group_id ?? "") ?? null,
         lastActive: await lastActiveFor(s),
         branch: s.branch_name,
         quick: !!s.quick_of,

package/lib/orchestrator/serve.ts

@@ -1,6 +1,7 @@
 import { resumeOnModel } from "../models/resume";
 import { workspaceTask } from "./targets";
 import { getWorkspace } from "../workspaces";
+import { listGroups } from "../session-groups/store";
 import {
   approveTaskPlan,
   archive,
@@ -11,6 +12,7 @@ import {
   send,
   stack,
   stackStatus,
+  setGroup,
   startSession,
   startTask,
   startNow,
@@ -19,6 +21,10 @@ import {
   resumeTask,
   stop,
 } from "./act";
+import { describeClaims, liveClaims } from "../claims";
+import { repoKey } from "../git-remote";
+import { expandHome } from "../tasks/session";
+import { workspaceProjects } from "./brief";
 import { readCards } from "./cards";
 import { readLogs } from "./logs";
 import { describeSessions } from "./describe";
@@ -59,6 +65,7 @@ const ACTING = new Set<ToolName>([
   "start_task",
   "set_task_model",
   "start_session",
+  "set_group",
   "run_recipe",
   "recipe_save",
   "recipe_update",
@@ -83,6 +90,21 @@ const ACTING = new Set<ToolName>([
   "add_project",
 ]);
 
+// What live sessions on other machines claim in this workspace's repos.
+async function claimedElsewhere(w: string): Promise<string> {
+  const keys = await Promise.all(
+    workspaceProjects(w)
+      .filter((p) => !p.host_id || p.host_id === "local")
+      .map((p) => repoKey(expandHome(p.working_directory)))
+  );
+  const repos = new Set(keys.filter((k): k is string => !!k));
+  if (!repos.size) return "";
+  return describeClaims(
+    liveClaims().filter((c) => repos.has(c.repo)),
+    { onlyOthers: true }
+  );
+}
+
 // The orchestrator's tools, each scoped to its workspace and its arguments
 // validated, answered as compact text.
 export async function runTool(
@@ -97,14 +119,20 @@ export async function runTool(
   switch (tool) {
     case "sessions": {
       p(tool, raw);
-      const [facts, external] = await Promise.all([
+      const [facts, external, claimed] = await Promise.all([
         sessionFacts(w),
         externalSessions(w).catch(() => []),
+        claimedElsewhere(w).catch(() => ""),
       ]);
       resolveStaleAsks(w);
       return [
-        describeSessions(workspace.name, facts),
+        describeSessions(
+          workspace.name,
+          facts,
+          listGroups(w).map((g) => g.name)
+        ),
         describeExternal(external),
+        claimed,
       ]
         .filter(Boolean)
         .join("\n\n");
@@ -147,7 +175,9 @@ export async function runTool(
         machine: a.machine,
         now: a.now,
         nowReason: a.now_reason,
+        ignoreClaims: a.ignore_claims,
         piece: a.piece,
+        group: a.group,
       });
     }
     case "start_now": {
@@ -187,8 +217,13 @@ export async function runTool(
         name: a.name,
         view: a.view,
         model: a.model,
+        group: a.group,
       });
     }
+    case "set_group": {
+      const a = p(tool, raw);
+      return setGroup(w, a.session, a.group);
+    }
     case "quick_change": {
       const a = p(tool, raw);
       return quickChange(w, a.project, a.name);

package/lib/orchestrator/tool-names.ts

@@ -20,6 +20,7 @@ export const TOOL_NAMES = {
   start_task: name("start_task"),
   set_task_model: name("set_task_model"),
   start_session: name("start_session"),
+  set_group: name("set_group"),
   quick_change: name("quick_change"),
   quick_pr: name("quick_pr"),
   stack: name("stack"),

package/lib/orchestrator/tool-schemas.ts

@@ -22,6 +22,16 @@ const view = z
     "How its agent runs: chat (the default), or terminal only when the job needs a TUI (an interactive program, a full-screen tool)"
   );
 
+const group = z
+  .string()
+  .trim()
+  .min(1)
+  .max(60)
+  .optional()
+  .describe(
+    "One of Saad's groups in this workspace, by name (see sessions): file it there when he asked, or when it continues work already in that group. It must exist; you can't create groups"
+  );
+
 const sweepMachine = z
   .string()
   .trim()
@@ -96,6 +106,7 @@ export const TOOL_SHAPES = {
   },
   start_task: {
     project,
+    group,
     prompt: z
       .string()
       .trim()
@@ -122,7 +133,7 @@ export const TOOL_SHAPES = {
       .max(200)
       .optional()
       .describe(
-        'Queue it until this task finishes (id or name), or "any" for whichever running task finishes first'
+        'Queue it until this task finishes (id or name), or "any" for whichever running task finishes first, or "claim:<id>" for work another machine has claimed'
       ),
     priority: z
       .enum(PRIORITIES)
@@ -149,6 +160,12 @@ export const TOOL_SHAPES = {
       .max(300)
       .optional()
       .describe("With now: why it can't wait for a slot; logged for Saad"),
+    ignore_claims: z
+      .boolean()
+      .optional()
+      .describe(
+        "Don't queue it after work another session (here or on a linked machine) has claimed on the same branch or files; start it as usual. Not needed with now"
+      ),
     piece: z
       .string()
       .trim()
@@ -196,6 +213,7 @@ export const TOOL_SHAPES = {
   },
   start_session: {
     project,
+    group,
     prompt: z.string().trim().min(1).max(20000),
     name: z
       .string()
@@ -211,6 +229,18 @@ export const TOOL_SHAPES = {
         'One model for the session, "provider/model"; default: the implementation model. Opus only when the work needs deep reasoning'
       ),
   },
+  set_group: {
+    session,
+    group: z
+      .string()
+      .trim()
+      .min(1)
+      .max(60)
+      .nullable()
+      .describe(
+        "One of Saad's groups in this workspace by name, or null to take the session out of its group"
+      ),
+  },
   quick_change: {
     project,
     name: z

package/lib/orchestrator/tools.ts

@@ -126,11 +126,13 @@ const DESCRIPTIONS: Record<ToolName, string> = {
   message_orchestrator:
     "Message another workspace's orchestrator, by workspace name; never any other session there. It arrives as its next prompt, marked as from you and fenced as untrusted.",
   start_task:
-    'Start a task: an agent in its own worktree that ends in a PR. It runs as a chat unless view is terminal (only for a job that needs a TUI). priority (urgent, blocking, normal, background) says where it stands in the queue; machine "mac" pins work that needs this Mac. A busy machine holds a start and the result says why. With after (a task\'s id or name, or "any"), or over the workspace\'s running task limit, it\'s queued and starts by itself; the result says Queued (position N). Its models follow the role settings (planning, implementation, review, scope); give model only when Saad asks for one. Always state plan (true or false) and plan_reason (plan_only true plans, then stops and waits for approve_plan instead of implementing): plan true for a big, unclear or cross-cutting job, false for a small, clear one whose steps you write into the prompt. now true (with now_reason) starts it at once past the running-task limit instead of queueing for a slot, logged; not with after. piece names the waiting piece of a plan this task builds, so it is claimed and not started a second time. Refused while a brake holds.',
+    'Start a task: an agent in its own worktree that ends in a PR. It runs as a chat unless view is terminal (only for a job that needs a TUI). priority (urgent, blocking, normal, background) says where it stands in the queue; machine "mac" pins work that needs this Mac. A busy machine holds a start and the result says why. With after (a task\'s id or name, or "any"), or over the workspace\'s running task limit, it\'s queued and starts by itself; the result says Queued (position N). Its models follow the role settings (planning, implementation, review, scope); give model only when Saad asks for one. Always state plan (true or false) and plan_reason (plan_only true plans, then stops and waits for approve_plan instead of implementing): plan true for a big, unclear or cross-cutting job, false for a small, clear one whose steps you write into the prompt. now true (with now_reason) starts it at once past the running-task limit instead of queueing for a slot, logged; not with after. A strong overlap with work another session has claimed (same branch, or the same files, here or on a linked machine) queues the start after it and says so; the result also lists weaker overlaps. ignore_claims true skips that. piece names the waiting piece of a plan this task builds, so it is claimed and not started a second time. Refused while a brake holds.',
   set_task_model:
     'Resume a paused task on another model ("provider/model", or a map of role to one), keeping its conversation and worktree; it\'s told to carry on (or message). Refused mid-turn.',
   start_session:
     'Start an agent session in a project with a prompt, for work that isn\'t a PR task. It runs on the implementation model unless you give model (one "provider/model"; Opus only when the work needs deep reasoning), as a chat unless view is terminal (only for a job that needs a TUI). Refused while a brake holds.',
+  set_group:
+    "File a session of this workspace in one of Saad's groups (by name), or out of its group with null. Groups only organise his sidebar; they change nothing about the session. You can use groups that exist but can't create, rename or delete them.",
   quick_change:
     "Make a change yourself (without full access, a small low-risk one: a typo, a config value, a one-file fix): cuts a worktree and branch from the project's default branch and returns its path. Its dependencies install in the background (a note says when). You may write there (Write, Edit) and, with Orchestrator full access, run any git there; without it, only `git -C <path> ...` status, diff, add, rm, mv, restore, reset, log, show, and nowhere else in a project. Without full access, anything needing real work, tests or an investigation is a task (start_task).",
   quick_pr:

package/lib/orchestrator/watcher.ts

@@ -14,6 +14,9 @@ import { deliverEvents } from "./deliver";
 import { recordConditions } from "./events";
 import { sessionFacts, type SessionFacts } from "./facts";
 import { listOrchestrators } from "./home";
+import { claimsShared, machineId } from "../claims/machine";
+import { sessionOverlaps, type SessionOverlap } from "../claims/mine";
+import { liveClaims } from "../claims/store";
 import { BRAKE_SUBJECT, openAsks } from "./asks";
 import { settleStaleAsks } from "./ask-settle";
 import { brakesOn, liftBrake } from "./brakes";
@@ -35,6 +38,15 @@ async function settleAsks(workspaceId: string): Promise<void> {
   if (brake && !(await brakesOn(workspaceId)).length) liftBrake(workspaceId);
 }
 
+// Claims code never breaks the watcher: any error means no overlaps.
+function localOverlaps(): SessionOverlap[] {
+  try {
+    return claimsShared() ? sessionOverlaps(machineId(), liveClaims()) : [];
+  } catch {
+    return [];
+  }
+}
+
 const DELIVER_EVERY_MS = 5000;
 export const DIFF_BUSY_MS = 15 * 1000;
 export const DIFF_IDLE_MS = 60 * 1000;
@@ -58,7 +70,13 @@ export async function diffWorkspace(
   ];
   recordConditions(
     workspaceId,
-    conditionsFor(facts, stacks, now, recentlyMessaged(orchestratorId, now)),
+    conditionsFor(
+      facts,
+      stacks,
+      now,
+      recentlyMessaged(orchestratorId, now),
+      localOverlaps()
+    ),
     subjects,
     now
   );

package/lib/peer/account.ts

@@ -19,6 +19,9 @@ import {
 } from "../connect/control-api";
 import { peerHostAllowed } from "./client";
 import { rawPublic } from "./keys";
+import { cleanMachineName } from "./name";
+import { reconcilePins, type AccountSays } from "./revoke";
+import { getSetting, putSetting } from "../settings-store";
 
 export interface AccountPeer {
   id: string;
@@ -37,9 +40,15 @@ export interface AccountView {
   /** When the list was last fetched, 0 if never. */
   fetchedAt: number;
   error: string | null;
+  /** Set when the service hasn't answered for a day: since when. */
+  uncheckedSince: number | null;
 }
 
 export const LIST_MAX_AGE_MS = 60_000;
+export const UNCHECKED_NOTICE_MS = 24 * 3_600_000;
+const OK_KEY = "peer.account_ok_at";
+// The last answer is written down at most this often (it survives restarts).
+const OK_SAVE_MS = 10 * 60_000;
 // Never more often than this, whoever asks.
 const MIN_GAP_MS = 5_000;
 
@@ -52,6 +61,8 @@ interface State {
   stale: boolean;
   error: string | null;
   inflight: Promise<void> | null;
+  okAt: number;
+  okSavedAt: number;
 }
 
 export type Fetcher = () => Promise<PeerList | null>;
@@ -70,6 +81,8 @@ const fresh = (): State => ({
   stale: false,
   error: null,
   inflight: null,
+  okAt: 0,
+  okSavedAt: 0,
 });
 
 const state = () => (g.__agentosPeerAccount ??= fresh());
@@ -97,6 +110,42 @@ export function rawFromSpki(pem: string): string | null {
   }
 }
 
+/** The service answered: links can be checked against it again. */
+export function noteAccountOk(now = Date.now()) {
+  const s = state();
+  s.okAt = now;
+  if (now - s.okSavedAt < OK_SAVE_MS) return;
+  s.okSavedAt = now;
+  try {
+    putSetting(OK_KEY, String(now));
+  } catch {
+    // Bookkeeping only.
+  }
+}
+
+/** When the service last answered; a first look starts the clock. */
+function lastOk(now: number): number {
+  const s = state();
+  if (s.okAt) return s.okAt;
+  let saved = NaN;
+  try {
+    saved = Number(getSetting(OK_KEY));
+  } catch {
+    // No database: count from now.
+  }
+  if (Number.isFinite(saved) && saved > 0) return (s.okAt = saved);
+  noteAccountOk(now);
+  return now;
+}
+
+function applyToPins(says: AccountSays) {
+  try {
+    reconcilePins(says);
+  } catch (err) {
+    console.error("peer revoke:", err);
+  }
+}
+
 function adopt(list: PeerList) {
   const s = state();
   const peers: AccountPeer[] = [];
@@ -107,7 +156,7 @@ function adopt(list: PeerList) {
     if (!signPub || !peerHostAllowed(m.hostname)) continue;
     peers.push({
       id: m.id,
-      name: m.name,
+      name: cleanMachineName(m.name),
       hostname: m.hostname,
       signPub,
       lastSeenAt: m.lastSeenAt,
@@ -120,6 +169,11 @@ function adopt(list: PeerList) {
   s.fetchedAt = Date.now();
   s.stale = false;
   s.error = null;
+  noteAccountOk(s.fetchedAt);
+  applyToPins({
+    linkMachines: s.entitlements?.linkMachines ?? null,
+    listed: new Map(peers.map((p) => [p.id, p.signPub])),
+  });
 }
 
 async function refresh(): Promise<void> {
@@ -161,15 +215,19 @@ export async function accountView(
       peers: [],
       fetchedAt: 0,
       error: null,
+      uncheckedSince: null,
     };
   const s = state();
   if (s.stale || Date.now() - s.fetchedAt > maxAgeMs) await refresh();
+  const now = Date.now();
+  const ok = lastOk(now);
   return {
     enrolled: true,
     entitlements: s.entitlements,
     peers: s.peers,
     fetchedAt: s.fetchedAt,
     error: s.error,
+    uncheckedSince: now - ok > UNCHECKED_NOTICE_MS ? ok : null,
   };
 }
 
@@ -187,12 +245,26 @@ export async function linkingAllowed(): Promise<boolean | null> {
   return entitlements ? entitlements.linkMachines : null;
 }
 
-/** What a heartbeat says: the plan now, and whether the list changed. */
+/**
+ * What a heartbeat says: the service is there, the plan now, and whether the
+ * list changed, which is fetched again at once so a machine removed from the
+ * account is suspended within a beat or so.
+ */
 export function noteHeartbeat(beat: Beat) {
   const s = state();
+  noteAccountOk();
+  const plan = beat.entitlements?.linkMachines;
+  const planChanged =
+    plan !== undefined && plan !== s.entitlements?.linkMachines;
   if (beat.entitlements) s.entitlements = beat.entitlements;
   if (beat.peersEtag && beat.peersEtag !== s.etag) {
     s.etag = beat.peersEtag;
     s.stale = true;
   }
+  // A downgrade suspends now. An upgrade waits for a fresh list, so a pin
+  // whose machine left the account meanwhile isn't resumed on the way.
+  if (planChanged && plan === false)
+    applyToPins({ linkMachines: false, listed: null });
+  else if (planChanged) s.stale = true;
+  if (s.stale && enrolled()) void refresh();
 }

package/lib/peer/allowlist.ts

@@ -67,7 +67,7 @@ export const PEER_ROUTES: readonly PeerRoute[] = [
   { method: "POST", pattern: "/api/peer/unlink" },
   { method: "GET", pattern: "/api/peer/ping" },
 
-  // The work registry's exchange (not built yet: 404 until it is).
+  // The work registry's exchange.
   { method: "POST", pattern: "/api/claims/exchange" },
 ];
 

package/lib/peer/client.ts

@@ -15,7 +15,8 @@ import {
   sealRequest,
 } from "./envelope";
 import { boxPublic, currentIdentity, signPublic, type Identity } from "./keys";
-import { notePinResult } from "./links";
+import { notePinResult, unlinkedByPeer } from "./links";
+import { UNLINKED_PROOF_HEADER, verifyUnlinked } from "./unlinked-proof";
 import type { HostLink } from "../hosts/remote-api";
 import { readCappedBytes } from "../hosts/read-capped-bytes";
 
@@ -67,12 +68,15 @@ export interface ClientDeps {
   identity: () => Identity | null;
   audit: (e: AuditEntry) => void;
   noteResult: (hostId: string, error: string | null) => void;
+  /** It proved it unlinked this machine: drop the pin here too. */
+  unlinked: (hostId: string, name: string) => void;
 }
 
 const realDeps: ClientDeps = {
   identity: () => currentIdentity(),
   audit: recordPeerCall,
   noteResult: notePinResult,
+  unlinked: unlinkedByPeer,
 };
 
 export async function peerCall(
@@ -155,6 +159,27 @@ export async function peerCall(
   }
   if (res.status !== 200) {
     const text = raw.subarray(0, 64).toString("utf8").trim();
+    if (
+      res.status === 403 &&
+      text === "unknown peer" &&
+      verifyUnlinked(
+        signPublic(peer.signPub),
+        {
+          from: peer.machineId,
+          to: identity.machineId,
+          nonce: sealed.nonce.toString("base64url"),
+        },
+        res.headers.get(UNLINKED_PROOF_HEADER)
+      )
+    ) {
+      audit("unknown_peer", 403, sealed.envelope.length);
+      deps.unlinked(link.hostId, link.hostName);
+      throw new PeerCallError(
+        `${link.hostName} unlinked this machine. Link it again in Machines.`,
+        true,
+        403
+      );
+    }
     const outcome = REFUSALS[text];
     if (outcome && res.status >= 400 && res.status < 500) {
       audit(outcome, res.status, sealed.envelope.length);

package/lib/peer/link-cli.ts

@@ -100,7 +100,9 @@ async function list(io: CliIo) {
     );
   for (const r of requests)
     io.out(
-      `\n${r.name} wants to link here: agent-os link accept <the code it shows>`
+      r.state === "accepted"
+        ? `\n${r.name} is linked here. To finish, type this code on ${r.name}: ${r.confirmCode ? showCode(r.confirmCode) : "(see the browser)"}`
+        : `\n${r.name} wants to link here: agent-os link accept <the code it shows>`
     );
   if (account.machines.some((m) => !m.linkState))
     io.out("\nLink one with: agent-os link <name>");
@@ -177,7 +179,12 @@ async function answer(io: CliIo, verb: "accept" | "decline", rest: string[]) {
     io,
     "/api/peers/pending"
   );
-  const req = pick(requests, from, (r) => r.machineId, "link request");
+  const req = pick(
+    requests.filter((r) => r.state !== "accepted"),
+    from,
+    (r) => r.machineId,
+    "link request"
+  );
   if (verb === "decline") {
     await call(io, `/api/peers/pending/${req.id}/decline`, { method: "POST" });
     io.out(`Declined ${req.name}.`);
@@ -210,10 +217,18 @@ async function unlink(io: CliIo, ref: string | undefined) {
     (h) => h.id,
     "linked machine"
   );
-  await call(io, `/api/hosts/${host.id}`, { method: "DELETE" });
+  const r = await call<{ told: boolean; removed: boolean }>(
+    io,
+    `/api/peers/${host.id}`,
+    { method: "DELETE" }
+  );
   io.out(
-    `Unlinked ${host.name} here. Remove this machine from its Machines too.`
+    r.told
+      ? `Unlinked ${host.name}, on both machines.`
+      : `Unlinked ${host.name} here. It couldn't be told now; its next call here is refused and it will show as unlinked.`
   );
+  if (!r.removed)
+    io.out(`It stays in Machines while it still has projects or sessions.`);
 }
 
 /** Runs one command; returns the exit code. */