@spencerboucher/switchyard 0.3.0 → 0.4.0

package/dist/switchyard.mjs

@@ -295,6 +295,19 @@ var RuntimeCapabilities = z3.object({
   costAccounting: z3.boolean(),
   unsupported: z3.array(z3.object({ capability: z3.string(), reason: z3.string() }))
 });
+var ProjectScan = z3.object({
+  state: z3.enum(["running", "done", "failed"]),
+  startedAt: Iso,
+  finishedAt: Iso.nullable(),
+  /** Repositories found across all folders. */
+  repositories: z3.number().int(),
+  /** New projects created by this scan. */
+  projectsCreated: z3.number().int(),
+  /** New checkouts (including the ones of new projects). */
+  checkoutsAdded: z3.number().int(),
+  /** "<folder>: <message>" per folder that failed; for state "failed", the reason last. */
+  errors: z3.array(z3.string())
+});
 var Host = z3.object({
   id: Id,
   name: z3.string(),
@@ -306,7 +319,10 @@ var Host = z3.object({
   connectivity: Connectivity,
   lastSeenAt: Iso.nullable(),
   revokedAt: Iso.nullable(),
-  createdAt: Iso
+  createdAt: Iso,
+  /** Folders on the host whose git repositories become projects (absolute or ~/...). */
+  projectFolders: z3.array(z3.string()).optional(),
+  projectScan: ProjectScan.nullable().optional()
 });
 var WorktreeDir = z3.string().min(1).refine((d) => !d.startsWith("/") && !d.includes("\\"), "must be a relative path").refine((d) => !d.split("/").includes(".."), "must stay inside the repository").refine((d) => d.split("/").every((s) => s.length > 0 && s !== "."), "must be a plain relative path");
 var Project = z3.object({
@@ -817,6 +833,23 @@ var UpdateProjectRequest = z4.object({
   worktreeDir: WorktreeDir.optional()
 });
 var AddCheckoutRequest = z4.object({ hostId: z4.string(), path: z4.string().min(1) });
+function isProjectFolderPath(s) {
+  if (s.includes("\0"))
+    return false;
+  return s === "~" || s.startsWith("~/") || s.startsWith("/");
+}
+var ProjectFolder = z4.string().trim().min(1).max(1024).refine(isProjectFolderPath, "must be an absolute path or start with ~/");
+var UpdateHostRequest = z4.object({
+  projectFolders: z4.array(ProjectFolder).max(20).optional()
+});
+var ProjectScanResult = ProjectScan.extend({
+  added: z4.array(z4.object({
+    projectId: z4.string(),
+    name: z4.string(),
+    path: z4.string(),
+    newProject: z4.boolean()
+  }))
+});
 var ProfileInput = z4.object({
   name: z4.string().min(1),
   provider: z4.string().nullable().default(null),
@@ -1208,6 +1241,7 @@ var HostCommand = z7.discriminatedUnion("type", [
   z7.object({ type: z7.literal("session.readNative"), sessionFile: z7.string() }),
   z7.object({ type: z7.literal("session.snapshot"), sessionId: z7.string() }),
   z7.object({ type: z7.literal("checkout.inspect"), path: z7.string() }),
+  z7.object({ type: z7.literal("projects.scan"), folder: z7.string().min(1) }),
   z7.object({
     type: z7.literal("workspace.discover"),
     checkoutPath: z7.string(),
@@ -1297,6 +1331,12 @@ var CheckoutInfo = z7.object({
   repoIdentity: z7.string(),
   defaultBranch: z7.string()
 });
+var ScannedRepository = CheckoutInfo.extend({ name: z7.string() });
+var ProjectFolderScan = z7.object({
+  /** The folder, ~ expanded and realpath'd. */
+  folder: z7.string(),
+  repositories: z7.array(ScannedRepository)
+});
 var DiffFile = z7.object({
   path: z7.string(),
   oldPath: z7.string().nullable(),
@@ -5125,176 +5165,675 @@ function occurrenceLabel(o) {
   }
 }
 
-// packages/coordinator/dist/push.js
-import webpush from "web-push";
-var webPushSender = async (subscription, payload, vapid) => {
-  await webpush.sendNotification(subscription, JSON.stringify(payload), {
-    vapidDetails: {
-      subject: vapid.subject,
-      publicKey: vapid.publicKey,
-      privateKey: vapid.privateKey
-    },
-    TTL: 24 * 3600,
-    urgency: payload.type === "show" ? "high" : "normal"
-  });
-};
-var VAPID_KEY = "vapid";
-var SETTINGS_KEY = "notificationSettings";
-var DEFAULT_NOTIFICATION_SETTINGS = {
-  quietHours: null,
-  privatePreviews: false,
-  preferredDeviceId: null
-};
-var PushService = class {
-  ctx;
-  sender;
-  constructor(ctx, sender = webPushSender) {
-    this.ctx = ctx;
-    this.sender = sender;
-  }
-  /** VAPID keys, generated once and stored in `settings`. */
-  vapid() {
-    const existing = this.ctx.store.getSetting(VAPID_KEY, null);
-    if (existing)
-      return existing;
-    const keys = webpush.generateVAPIDKeys();
-    this.ctx.store.setSetting(VAPID_KEY, keys);
-    return keys;
-  }
-  subject() {
-    const url = this.ctx.config.publicUrl;
-    return url.startsWith("https://") ? url : "mailto:switchyard@localhost";
-  }
-  settings() {
-    return {
-      ...DEFAULT_NOTIFICATION_SETTINGS,
-      ...this.ctx.store.getSetting(SETTINGS_KEY, {})
-    };
-  }
-  updateSettings(patch) {
-    const next = NotificationSettings.parse({ ...this.settings(), ...patch });
-    if (next.quietHours) {
-      try {
-        new Intl.DateTimeFormat("en-US", { timeZone: next.quietHours.timezone });
-      } catch {
-        throw new SwitchyardError("invalid_request", `Unknown timezone "${next.quietHours.timezone}"`);
-      }
-    }
-    if (next.preferredDeviceId)
-      this.ctx.store.devices.require(next.preferredDeviceId);
-    this.ctx.store.setSetting(SETTINGS_KEY, next);
-    return next;
-  }
-  subscriptions(deviceId) {
-    return this.ctx.store.listPushSubscriptions(deviceId);
-  }
-  /** Store a browser subscription for a device and record its permission state. */
-  subscribe(deviceId, sub, permission) {
-    const { store } = this.ctx;
-    return store.tx(() => {
-      if (permission === "granted") {
-        store.upsertPushSubscription({
-          deviceId,
-          endpoint: sub.endpoint,
-          subscription: { endpoint: sub.endpoint, keys: sub.keys },
-          createdAt: store.nowIso()
-        });
-      } else {
-        store.deletePushSubscription(sub.endpoint);
-      }
-      return this.syncDevice(deviceId, permission);
-    });
-  }
-  unsubscribe(deviceId, endpoint) {
-    const { store } = this.ctx;
-    return store.tx(() => {
-      if (endpoint) {
-        const own = store.listPushSubscriptions(deviceId).some((s) => s.endpoint === endpoint);
-        if (own)
-          store.deletePushSubscription(endpoint);
-      } else {
-        store.deletePushSubscriptionsForDevice(deviceId);
-      }
-      return this.syncDevice(deviceId);
-    });
-  }
-  /** Mirror subscription presence into `device.push`. */
-  syncDevice(deviceId, permission) {
-    const { store } = this.ctx;
-    const d = store.devices.require(deviceId);
-    const push = {
-      subscribed: store.listPushSubscriptions(deviceId).length > 0,
-      permission: permission ?? d.push.permission
-    };
-    if (JSON.stringify(push) === JSON.stringify(d.push))
-      return d;
-    return store.putDevice({ ...d, push });
-  }
-  /** Send to every subscription of a device. 404/410 deletes the subscription. */
-  async sendToDevice(deviceId, payload) {
-    const subs = this.ctx.store.listPushSubscriptions(deviceId);
-    const result = { sent: 0, removed: 0, failed: 0 };
-    if (subs.length === 0)
-      return result;
-    const vapid = { ...this.vapid(), subject: this.subject() };
-    for (const s of subs) {
-      try {
-        await this.sender(s.subscription, payload, vapid);
-        result.sent++;
-      } catch (err) {
-        const status = err.statusCode;
-        if (status === 404 || status === 410) {
-          this.ctx.store.tx(() => {
-            this.ctx.store.deletePushSubscription(s.endpoint);
-            if (this.ctx.store.devices.get(deviceId))
-              this.syncDevice(deviceId);
-          });
-          result.removed++;
-        } else {
-          result.failed++;
-          this.ctx.log.warn({ err, deviceId, status }, "push delivery failed");
-        }
-      }
-    }
-    return result;
-  }
-};
-
-// packages/coordinator/dist/routes/automations.js
-import { createHash as createHash2 } from "node:crypto";
+// packages/coordinator/dist/workspaces.js
 import { z as z8 } from "zod";
-var ListQuery = z8.object({ projectId: z8.string().optional() });
-var HistoryQuery = z8.object({ limit: z8.coerce.number().int().min(1).max(1e3).default(100) });
-var WEBHOOK_BODY_LIMIT = 256 * 1024;
-function registerAutomationRoutes(app, ctx) {
-  const { store } = ctx;
-  const svc = () => requireService(ctx, "automations");
-  const idOf = (req) => req.params.id;
-  const view = (id) => {
-    const a = store.automations.require(id);
-    return { ...a, summary: svc().describe(a) };
-  };
-  app.get("/api/automations", async (req) => {
-    const q = parse(ListQuery, req.query, "query");
-    const list = q.projectId ? store.automations.list("project_id = ?", [q.projectId], "created_at") : store.automations.list(void 0, [], "created_at");
-    return list.map((a) => ({ ...a, summary: svc().describe(a) }));
+var DEFAULT_WORKTREE_DIR = ".worktrees";
+function worktreeDirOf(project) {
+  return project?.worktreeDir || DEFAULT_WORKTREE_DIR;
+}
+function predictedWorktreePath(checkout, project, branch) {
+  return `${checkout.path}/${worktreeDirOf(project)}/${branchSlug(branch)}`;
+}
+var ZERO_GIT = { dirty: false, changedFiles: 0, ahead: 0, behind: 0, unmerged: false };
+var NO_SETUP = { state: "none", log: "" };
+var SetupState2 = z8.object({
+  state: z8.enum(["none", "running", "succeeded", "failed"]),
+  log: z8.string()
+});
+function stripRef(branch) {
+  return branch?.startsWith("refs/heads/") ? branch.slice("refs/heads/".length) : branch;
+}
+async function inspectCheckout(ctx, hostId, path) {
+  const r = await ctx.hostHub.request(hostId, { type: "checkout.inspect", path });
+  return CheckoutInfo.parse(r);
+}
+function recordCreatedWorkspace(ctx, project, checkout, info) {
+  return ctx.store.tx(() => {
+    const existing = ctx.store.workspaceByPath(checkout.hostId, info.path);
+    const buffered = ctx.hostHub.takeBufferedWorkspace(checkout.hostId, info.path);
+    const git = GitState.safeParse(buffered?.git ?? info.git);
+    const setup = SetupState2.safeParse(buffered?.setup ?? info.setup);
+    const ws = {
+      id: existing?.id ?? newId("wsp"),
+      checkoutId: checkout.id,
+      projectId: project.id,
+      hostId: checkout.hostId,
+      path: info.path,
+      branch: info.branch,
+      baseBranch: info.baseBranch,
+      provenance: "managed",
+      git: git.success ? git.data : existing?.git ?? ZERO_GIT,
+      setup: setup.success ? setup.data : existing?.setup ?? NO_SETUP,
+      archivedAt: null,
+      updatedAt: ctx.store.nowIso()
+    };
+    return ctx.store.putWorkspace(ws);
   });
-  app.post("/api/automations", async (req, reply) => {
-    const a = svc().create(validated(req.body));
-    return reply.code(201).send(view(a.id));
+}
+async function refreshCheckoutWorkspaces(ctx, checkout) {
+  const raw = await ctx.hostHub.request(checkout.hostId, {
+    type: "workspace.discover",
+    checkoutPath: checkout.path,
+    worktreeDir: worktreeDirOf(ctx.store.projects.get(checkout.projectId))
   });
-  app.get("/api/automations/:id", async (req) => view(idOf(req)));
-  app.patch("/api/automations/:id", async (req) => {
-    const body = req.body ?? {};
-    if (typeof body !== "object" || Array.isArray(body)) {
-      throw new SwitchyardError("invalid_request", "Expected an object");
+  const list = DiscoveredWorktree.array().parse(Array.isArray(raw) ? raw : raw?.worktrees ?? []);
+  return ctx.store.tx(() => {
+    const now = ctx.store.nowIso();
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const wt of list) {
+      if (wt.bare || wt.prunable)
+        continue;
+      seen.add(wt.path);
+      const existing = ctx.store.workspaceByPath(checkout.hostId, wt.path);
+      const next = {
+        id: existing?.id ?? newId("wsp"),
+        checkoutId: checkout.id,
+        projectId: checkout.projectId,
+        hostId: checkout.hostId,
+        path: wt.path,
+        branch: stripRef(wt.branch),
+        baseBranch: existing?.baseBranch ?? (wt.provenance === "main" ? null : checkout.defaultBranch),
+        provenance: existing?.provenance === "managed" ? "managed" : wt.provenance,
+        git: wt.git ?? existing?.git ?? ZERO_GIT,
+        setup: existing?.setup ?? NO_SETUP,
+        archivedAt: null,
+        updatedAt: existing?.updatedAt ?? now
+      };
+      const changed = !existing || JSON.stringify({ ...existing, updatedAt: "" }) !== JSON.stringify({ ...next, updatedAt: "" });
+      out.push(changed ? ctx.store.putWorkspace({ ...next, updatedAt: now }) : existing);
     }
-    svc().update(idOf(req), body);
-    return view(idOf(req));
+    for (const ws of ctx.store.workspaces.list("checkout_id = ? AND archived_at IS NULL", [
+      checkout.id
+    ])) {
+      if (!seen.has(ws.path))
+        ctx.store.putWorkspace({ ...ws, archivedAt: now, updatedAt: now });
+    }
+    return out;
   });
-  app.delete("/api/automations/:id", async (req) => {
-    svc().delete(idOf(req));
-    return { ok: true };
+}
+async function refreshWorkspaceStatus(ctx, ws) {
+  const raw = await ctx.hostHub.request(ws.hostId, {
+    type: "workspace.status",
+    path: ws.path,
+    base: ws.baseBranch
+  });
+  const git = GitState.parse(raw?.git ?? raw);
+  return ctx.store.tx(() => {
+    const cur = ctx.store.workspaces.require(ws.id);
+    if (JSON.stringify(cur.git) === JSON.stringify(git))
+      return cur;
+    return ctx.store.putWorkspace({ ...cur, git, updatedAt: ctx.store.nowIso() });
+  });
+}
+function baseFor(ctx, ws) {
+  return ws.baseBranch ?? ctx.store.checkouts.get(ws.checkoutId)?.defaultBranch ?? null;
+}
+
+// packages/coordinator/dist/sessions/service.js
+var LIVE_RUNTIMES2 = ["starting", "idle", "running", "waiting_input"];
+function requireUsableHost(ctx, hostId) {
+  const host = ctx.store.hosts.require(hostId);
+  if (host.revokedAt)
+    throw new SwitchyardError("forbidden", `Host ${host.name} was revoked`);
+  if (!ctx.hostHub.isConnected(hostId)) {
+    throw new SwitchyardError("host_unreachable", `Host ${host.name} is offline`, { hostId });
+  }
+  if (!host.piCompatible) {
+    throw new SwitchyardError("pi_incompatible", `Pi ${host.piVersion ?? "(not found)"} on ${host.name} is outside the tested range`, { hostId });
+  }
+}
+function requireConnected(ctx, hostId) {
+  const host = ctx.store.hosts.require(hostId);
+  if (!ctx.hostHub.isConnected(hostId)) {
+    throw new SwitchyardError("host_unreachable", `Host ${host.name} is offline`, { hostId });
+  }
+}
+function resolveProfile(ctx, profileId, project) {
+  const id = profileId ?? project?.defaultProfileId ?? null;
+  if (id)
+    return ctx.store.profiles.require(id);
+  const first = ctx.store.profiles.list(void 0, [], "created_at")[0];
+  if (!first)
+    throw new SwitchyardError("invalid_request", "No Pi profile configured");
+  return first;
+}
+function titleFrom(prompt, fallback = "New session") {
+  const line = prompt.trim().split("\n")[0]?.trim() ?? "";
+  if (!line)
+    return fallback;
+  return line.length > 80 ? `${line.slice(0, 77)}...` : line;
+}
+function appendNotice(ctx, session, level, text) {
+  return ctx.store.tx(() => {
+    const item = {
+      id: newId("itm"),
+      sessionId: session.id,
+      order: ctx.store.maxItemOrder(session.id) + 1,
+      at: ctx.store.nowIso(),
+      kind: "notice",
+      data: { level, text }
+    };
+    ctx.store.upsertItem(item);
+    ctx.store.appendEvent("transcript.item", { sessionId: session.id, hostId: session.hostId, projectId: session.projectId ?? void 0 }, item);
+    return item;
+  });
+}
+function failSession(ctx, sessionId, message) {
+  ctx.store.tx(() => {
+    const s = ctx.store.sessions.get(sessionId);
+    if (!s)
+      return;
+    ctx.store.putSession({
+      ...s,
+      runtime: "failed",
+      runtimeDetail: message,
+      lastActivityAt: ctx.store.nowIso()
+    });
+    appendNotice(ctx, s, "error", message);
+  });
+}
+async function startOnHost(ctx, session, opts) {
+  const cmd = {
+    type: "session.start",
+    sessionId: session.id,
+    title: session.title,
+    workspacePath: session.cwd,
+    projectId: session.projectId,
+    profile: session.profileSnapshot,
+    nativeHandle: opts.nativeHandle,
+    initialPrompt: opts.initialPrompt,
+    dispatchKey: opts.dispatchKey ?? null,
+    controlRevision: opts.controlRevision ?? 1,
+    controlMode: opts.controlMode ?? "human",
+    origin: opts.origin ?? "human",
+    readOnly: session.readOnly
+  };
+  const result = await ctx.hostHub.request(session.hostId, cmd);
+  return ctx.store.tx(() => {
+    const s = ctx.store.sessions.require(session.id);
+    const handle = result?.nativeHandle ?? null;
+    if (handle && JSON.stringify(handle) !== JSON.stringify(s.nativeHandle)) {
+      return ctx.store.putSession({ ...s, nativeHandle: handle });
+    }
+    return s;
+  });
+}
+async function createWorkspace(ctx, project, checkout, branch, base) {
+  requireConnected(ctx, checkout.hostId);
+  const baseBranch = base ?? checkout.defaultBranch;
+  const result = await ctx.hostHub.request(checkout.hostId, {
+    type: "workspace.create",
+    checkoutPath: checkout.path,
+    branch,
+    base: baseBranch,
+    setupCommand: project.setupCommand,
+    worktreeDir: worktreeDirOf(project)
+  });
+  const predicted = predictedWorktreePath(checkout, project, branch);
+  return recordCreatedWorkspace(ctx, project, checkout, {
+    path: typeof result?.path === "string" ? result.path : predicted,
+    branch: typeof result?.branch === "string" ? result.branch : branch,
+    baseBranch,
+    git: result?.git,
+    setup: result?.setup
+  });
+}
+function createSession(ctx, input) {
+  const project = ctx.store.projects.require(input.projectId);
+  const profile = resolveProfile(ctx, input.profileId, project);
+  let hostId;
+  let workspace = null;
+  let checkout = null;
+  if ("existingId" in input.workspace) {
+    workspace = ctx.store.workspaces.require(input.workspace.existingId);
+    if (workspace.projectId !== project.id) {
+      throw new SwitchyardError("invalid_request", "Workspace belongs to another project");
+    }
+    if (workspace.archivedAt)
+      throw new SwitchyardError("conflict", "Workspace is archived");
+    hostId = workspace.hostId;
+  } else {
+    checkout = ctx.store.checkouts.require(input.workspace.checkoutId);
+    if (checkout.projectId !== project.id) {
+      throw new SwitchyardError("invalid_request", "Checkout belongs to another project");
+    }
+    hostId = checkout.hostId;
+  }
+  requireUsableHost(ctx, hostId);
+  const now = ctx.store.nowIso();
+  const host = ctx.store.hosts.require(hostId);
+  const session = {
+    id: newId("ses"),
+    title: input.title?.trim() || titleFrom(input.prompt),
+    subtitle: null,
+    hostId,
+    workspaceId: workspace?.id ?? null,
+    projectId: project.id,
+    cwd: workspace?.path ?? predictedWorktreePath(checkout, project, input.workspace.newBranch),
+    nativeHandle: null,
+    profileSnapshot: profile,
+    runtime: "starting",
+    runtimeDetail: null,
+    connectivity: host.connectivity,
+    runId: null,
+    taskId: null,
+    provenance: "created",
+    readOnly: false,
+    lastActivityAt: now,
+    archivedAt: null,
+    queue: { steering: [], followUp: [] },
+    stats: null,
+    lastAssistantText: null,
+    createdAt: now
+  };
+  ctx.store.putSession(session);
+  const choice = input.workspace;
+  const started = (async () => {
+    try {
+      let s = session;
+      if (!("existingId" in choice)) {
+        const ws = await createWorkspace(ctx, project, checkout, choice.newBranch, choice.base);
+        s = ctx.store.tx(() => {
+          const cur = ctx.store.sessions.require(session.id);
+          return ctx.store.putSession({ ...cur, workspaceId: ws.id, cwd: ws.path });
+        });
+      }
+      await startOnHost(ctx, s, {
+        initialPrompt: input.prompt.trim() ? input.prompt : null,
+        nativeHandle: null
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      ctx.log.warn({ err, sessionId: session.id }, "session start failed");
+      failSession(ctx, session.id, `Could not start the session: ${message}`);
+    }
+  })();
+  return { session, started };
+}
+
+// packages/coordinator/dist/project-folders.js
+var PROJECT_SCAN_INTERVAL_MS = 10 * 6e4;
+var PROJECT_SCAN_MIN_AGE_ON_CONNECT_MS = 6e4;
+var PROJECT_SCAN_TIMEOUT_MS = 12e4;
+function normalizeProjectFolders(list) {
+  const out = [];
+  for (const raw of list) {
+    let f = raw.trim();
+    while (f.length > 1 && f.endsWith("/"))
+      f = f.slice(0, -1);
+    if (f && !out.includes(f))
+      out.push(f);
+  }
+  return out;
+}
+function uniqueProjectName(existing, base, hostName) {
+  const taken = new Set(existing.map((n) => n.toLowerCase()));
+  if (!taken.has(base.toLowerCase()))
+    return base;
+  const withHost = `${base} (${hostName})`;
+  if (!taken.has(withHost.toLowerCase()))
+    return withHost;
+  for (let i = 2; ; i++) {
+    const candidate = `${withHost} ${i}`;
+    if (!taken.has(candidate.toLowerCase()))
+      return candidate;
+  }
+}
+function newProject(input) {
+  return {
+    id: newId("prj"),
+    name: input.name,
+    repoIdentity: input.repoIdentity,
+    defaultProfileId: input.defaultProfileId ?? null,
+    defaultHostId: input.hostId,
+    maxConcurrentRuns: input.maxConcurrentRuns ?? 1,
+    automationEnabled: true,
+    setupCommand: input.setupCommand ?? null,
+    checks: input.checks ?? [],
+    workspaceSharing: "single_writer",
+    worktreeDir: input.worktreeDir ?? DEFAULT_WORKTREE_DIR,
+    createdAt: input.now,
+    updatedAt: input.now
+  };
+}
+function setScan(ctx, hostId, scan) {
+  ctx.store.tx(() => {
+    const h = ctx.store.hosts.require(hostId);
+    ctx.store.putHost({ ...h, projectScan: scan });
+  });
+}
+function isTooOld(err) {
+  return err instanceof SwitchyardError && err.code === "invalid_request" && err.message.startsWith("Invalid command");
+}
+async function scanHostProjectFolders(ctx, hostId) {
+  const host = ctx.store.hosts.require(hostId);
+  const folders = host.projectFolders ?? [];
+  if (folders.length === 0) {
+    throw new SwitchyardError("invalid_request", `${host.name} has no project folders. Add one first.`);
+  }
+  requireConnected(ctx, hostId);
+  const scan = {
+    state: "running",
+    startedAt: ctx.store.nowIso(),
+    finishedAt: null,
+    repositories: 0,
+    projectsCreated: 0,
+    checkoutsAdded: 0,
+    errors: []
+  };
+  const added = [];
+  setScan(ctx, hostId, scan);
+  try {
+    const newCheckouts = [];
+    for (const folder of folders) {
+      let result;
+      try {
+        const raw = await ctx.hostHub.request(hostId, { type: "projects.scan", folder }, { timeoutMs: PROJECT_SCAN_TIMEOUT_MS });
+        result = ProjectFolderScan.parse(raw);
+      } catch (err) {
+        if (isTooOld(err)) {
+          throw new SwitchyardError("unsupported_capability", `${host.name} runs Switchyard ${host.agentVersion}, which cannot scan project folders. Update its host agent.`);
+        }
+        if (err instanceof SwitchyardError && err.code === "host_unreachable")
+          throw err;
+        scan.errors.push(`${folder}: ${err instanceof Error ? err.message : String(err)}`);
+        continue;
+      }
+      scan.repositories += result.repositories.length;
+      for (const repo of result.repositories) {
+        const r = ctx.store.tx(() => {
+          const known = ctx.store.checkouts.list("host_id = ? AND path = ?", [
+            hostId,
+            repo.root
+          ])[0];
+          if (known)
+            return null;
+          const now = ctx.store.nowIso();
+          let project = ctx.store.projects.list("repo_identity = ?", [repo.repoIdentity])[0];
+          let created = false;
+          if (!project) {
+            const names = ctx.store.projects.list().map((p) => p.name);
+            project = ctx.store.putProject(newProject({
+              name: uniqueProjectName(names, repo.name, host.name),
+              repoIdentity: repo.repoIdentity,
+              hostId,
+              now
+            }));
+            created = true;
+          }
+          const checkout = ctx.store.putCheckout({
+            id: newId("chk"),
+            projectId: project.id,
+            hostId,
+            path: repo.root,
+            commonDir: repo.commonDir,
+            defaultBranch: repo.defaultBranch,
+            createdAt: now
+          });
+          return { project, checkout, created };
+        });
+        if (!r)
+          continue;
+        scan.checkoutsAdded++;
+        if (r.created)
+          scan.projectsCreated++;
+        newCheckouts.push(r.checkout);
+        added.push({
+          projectId: r.project.id,
+          name: r.project.name,
+          path: repo.root,
+          newProject: r.created
+        });
+      }
+    }
+    for (const checkout of newCheckouts) {
+      try {
+        await refreshCheckoutWorkspaces(ctx, checkout);
+      } catch (err) {
+        ctx.log.warn({ err, checkoutId: checkout.id }, "workspace discovery failed");
+      }
+    }
+    const done = { ...scan, state: "done", finishedAt: ctx.store.nowIso() };
+    setScan(ctx, hostId, done);
+    return { ...done, added };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    setScan(ctx, hostId, {
+      ...scan,
+      state: "failed",
+      finishedAt: ctx.store.nowIso(),
+      errors: [...scan.errors, message]
+    });
+    throw err;
+  }
+}
+var ProjectFolderService = class {
+  ctx;
+  opts;
+  inflight = /* @__PURE__ */ new Map();
+  timer = null;
+  onConnected = ({ hostId }) => {
+    const host = this.ctx.store.hosts.get(hostId);
+    if (!host || host.revokedAt || !(host.projectFolders ?? []).length)
+      return;
+    const last = host.projectScan?.startedAt ? Date.parse(host.projectScan.startedAt) : null;
+    const now = Date.parse(this.ctx.store.nowIso());
+    if (last !== null && now - last < PROJECT_SCAN_MIN_AGE_ON_CONNECT_MS)
+      return;
+    this.background(hostId);
+  };
+  constructor(ctx, opts) {
+    this.ctx = ctx;
+    this.opts = opts;
+  }
+  /** Scan a host now; joins a scan already running for it. */
+  scan(hostId) {
+    const running = this.inflight.get(hostId);
+    if (running)
+      return running;
+    const p = scanHostProjectFolders(this.ctx, hostId).finally(() => this.inflight.delete(hostId));
+    this.inflight.set(hostId, p);
+    return p;
+  }
+  /** Scan without waiting; failures are logged (and recorded on the host). */
+  background(hostId) {
+    this.scan(hostId).catch((err) => this.ctx.log.warn({ err, hostId }, "project folder scan failed"));
+  }
+  start() {
+    this.ctx.hub.on("host.connected", this.onConnected);
+    if (this.opts.intervalMs > 0) {
+      this.timer = setInterval(() => this.tick(), this.opts.intervalMs);
+      this.timer.unref();
+    }
+  }
+  stop() {
+    if (this.timer)
+      clearInterval(this.timer);
+    this.timer = null;
+    this.ctx.hub.off("host.connected", this.onConnected);
+  }
+  tick() {
+    for (const h of this.ctx.store.hosts.list()) {
+      if (h.revokedAt || !(h.projectFolders ?? []).length)
+        continue;
+      if (!this.ctx.hostHub.isConnected(h.id))
+        continue;
+      this.background(h.id);
+    }
+  }
+};
+
+// packages/coordinator/dist/push.js
+import webpush from "web-push";
+var webPushSender = async (subscription, payload, vapid) => {
+  await webpush.sendNotification(subscription, JSON.stringify(payload), {
+    vapidDetails: {
+      subject: vapid.subject,
+      publicKey: vapid.publicKey,
+      privateKey: vapid.privateKey
+    },
+    TTL: 24 * 3600,
+    urgency: payload.type === "show" ? "high" : "normal"
+  });
+};
+var VAPID_KEY = "vapid";
+var SETTINGS_KEY = "notificationSettings";
+var DEFAULT_NOTIFICATION_SETTINGS = {
+  quietHours: null,
+  privatePreviews: false,
+  preferredDeviceId: null
+};
+var PushService = class {
+  ctx;
+  sender;
+  constructor(ctx, sender = webPushSender) {
+    this.ctx = ctx;
+    this.sender = sender;
+  }
+  /** VAPID keys, generated once and stored in `settings`. */
+  vapid() {
+    const existing = this.ctx.store.getSetting(VAPID_KEY, null);
+    if (existing)
+      return existing;
+    const keys = webpush.generateVAPIDKeys();
+    this.ctx.store.setSetting(VAPID_KEY, keys);
+    return keys;
+  }
+  subject() {
+    const url = this.ctx.config.publicUrl;
+    return url.startsWith("https://") ? url : "mailto:switchyard@localhost";
+  }
+  settings() {
+    return {
+      ...DEFAULT_NOTIFICATION_SETTINGS,
+      ...this.ctx.store.getSetting(SETTINGS_KEY, {})
+    };
+  }
+  updateSettings(patch) {
+    const next = NotificationSettings.parse({ ...this.settings(), ...patch });
+    if (next.quietHours) {
+      try {
+        new Intl.DateTimeFormat("en-US", { timeZone: next.quietHours.timezone });
+      } catch {
+        throw new SwitchyardError("invalid_request", `Unknown timezone "${next.quietHours.timezone}"`);
+      }
+    }
+    if (next.preferredDeviceId)
+      this.ctx.store.devices.require(next.preferredDeviceId);
+    this.ctx.store.setSetting(SETTINGS_KEY, next);
+    return next;
+  }
+  subscriptions(deviceId) {
+    return this.ctx.store.listPushSubscriptions(deviceId);
+  }
+  /** Store a browser subscription for a device and record its permission state. */
+  subscribe(deviceId, sub, permission) {
+    const { store } = this.ctx;
+    return store.tx(() => {
+      if (permission === "granted") {
+        store.upsertPushSubscription({
+          deviceId,
+          endpoint: sub.endpoint,
+          subscription: { endpoint: sub.endpoint, keys: sub.keys },
+          createdAt: store.nowIso()
+        });
+      } else {
+        store.deletePushSubscription(sub.endpoint);
+      }
+      return this.syncDevice(deviceId, permission);
+    });
+  }
+  unsubscribe(deviceId, endpoint) {
+    const { store } = this.ctx;
+    return store.tx(() => {
+      if (endpoint) {
+        const own = store.listPushSubscriptions(deviceId).some((s) => s.endpoint === endpoint);
+        if (own)
+          store.deletePushSubscription(endpoint);
+      } else {
+        store.deletePushSubscriptionsForDevice(deviceId);
+      }
+      return this.syncDevice(deviceId);
+    });
+  }
+  /** Mirror subscription presence into `device.push`. */
+  syncDevice(deviceId, permission) {
+    const { store } = this.ctx;
+    const d = store.devices.require(deviceId);
+    const push = {
+      subscribed: store.listPushSubscriptions(deviceId).length > 0,
+      permission: permission ?? d.push.permission
+    };
+    if (JSON.stringify(push) === JSON.stringify(d.push))
+      return d;
+    return store.putDevice({ ...d, push });
+  }
+  /** Send to every subscription of a device. 404/410 deletes the subscription. */
+  async sendToDevice(deviceId, payload) {
+    const subs = this.ctx.store.listPushSubscriptions(deviceId);
+    const result = { sent: 0, removed: 0, failed: 0 };
+    if (subs.length === 0)
+      return result;
+    const vapid = { ...this.vapid(), subject: this.subject() };
+    for (const s of subs) {
+      try {
+        await this.sender(s.subscription, payload, vapid);
+        result.sent++;
+      } catch (err) {
+        const status = err.statusCode;
+        if (status === 404 || status === 410) {
+          this.ctx.store.tx(() => {
+            this.ctx.store.deletePushSubscription(s.endpoint);
+            if (this.ctx.store.devices.get(deviceId))
+              this.syncDevice(deviceId);
+          });
+          result.removed++;
+        } else {
+          result.failed++;
+          this.ctx.log.warn({ err, deviceId, status }, "push delivery failed");
+        }
+      }
+    }
+    return result;
+  }
+};
+
+// packages/coordinator/dist/routes/automations.js
+import { createHash as createHash2 } from "node:crypto";
+import { z as z9 } from "zod";
+var ListQuery = z9.object({ projectId: z9.string().optional() });
+var HistoryQuery = z9.object({ limit: z9.coerce.number().int().min(1).max(1e3).default(100) });
+var WEBHOOK_BODY_LIMIT = 256 * 1024;
+function registerAutomationRoutes(app, ctx) {
+  const { store } = ctx;
+  const svc = () => requireService(ctx, "automations");
+  const idOf = (req) => req.params.id;
+  const view = (id) => {
+    const a = store.automations.require(id);
+    return { ...a, summary: svc().describe(a) };
+  };
+  app.get("/api/automations", async (req) => {
+    const q = parse(ListQuery, req.query, "query");
+    const list = q.projectId ? store.automations.list("project_id = ?", [q.projectId], "created_at") : store.automations.list(void 0, [], "created_at");
+    return list.map((a) => ({ ...a, summary: svc().describe(a) }));
+  });
+  app.post("/api/automations", async (req, reply) => {
+    const a = svc().create(validated(req.body));
+    return reply.code(201).send(view(a.id));
+  });
+  app.get("/api/automations/:id", async (req) => view(idOf(req)));
+  app.patch("/api/automations/:id", async (req) => {
+    const body = req.body ?? {};
+    if (typeof body !== "object" || Array.isArray(body)) {
+      throw new SwitchyardError("invalid_request", "Expected an object");
+    }
+    svc().update(idOf(req), body);
+    return view(idOf(req));
+  });
+  app.delete("/api/automations/:id", async (req) => {
+    svc().delete(idOf(req));
+    return { ok: true };
   });
   app.get("/api/automations/:id/preview", async (req) => svc().preview(store.automations.require(idOf(req))));
   app.post("/api/automations/preview", async (req) => {
@@ -5343,455 +5882,168 @@ function registerAutomationRoutes(app, ctx) {
     if (!a.enabled)
       throw new SwitchyardError("conflict", "This automation is disabled");
     const idem = headerValue(req.headers["idempotency-key"]) ?? headerValue(req.headers["x-github-delivery"]);
-    const payload = req.body ?? {};
-    const key = idem ? `hook:${idem}` : derivedWebhookKey(payload, store.now());
-    const match = filtersMatch(a.filters, payload);
-    const r = svc().fire(a.id, match.ok ? { key, scheduledFor: null, payload } : { key, scheduledFor: null, record: { state: "filtered", reason: match.reason } });
-    return reply.code(202).send({
-      occurrenceId: r.occurrence.id,
-      state: r.occurrence.state,
-      ...r.duplicate ? { duplicate: true } : {}
-    });
-  });
-}
-var WEBHOOK_DEDUPE_WINDOW_MS = 10 * 6e4;
-function derivedWebhookKey(payload, now) {
-  const bucket = Math.floor(now.getTime() / WEBHOOK_DEDUPE_WINDOW_MS);
-  const digest = createHash2("sha256").update(JSON.stringify(payload)).digest("hex");
-  return `hook:body:${digest}:${bucket}`;
-}
-function headerValue(v) {
-  const s = Array.isArray(v) ? v[0] : v;
-  return s?.trim() ? s.trim().slice(0, 200) : null;
-}
-function validated(body) {
-  return parse(AutomationInput, body);
-}
-
-// packages/coordinator/dist/routes/push.js
-import { z as z9 } from "zod";
-var DeleteSubscription = z9.object({ endpoint: z9.string().optional() });
-function registerPushRoutes(app, ctx) {
-  const push = () => requireService(ctx, "push");
-  app.get("/api/push/vapid-public-key", async () => ({ publicKey: push().vapid().publicKey }));
-  app.post("/api/push/subscriptions", async (req, reply) => {
-    const body = parse(PushSubscriptionRequest, req.body);
-    const device = deviceOf(req);
-    const updated = push().subscribe(device.id, { endpoint: body.endpoint, keys: body.keys }, body.permission);
-    return reply.code(201).send(updated);
-  });
-  app.delete("/api/push/subscriptions", async (req) => {
-    const body = parse(DeleteSubscription, req.body ?? {});
-    return push().unsubscribe(deviceOf(req).id, body.endpoint ?? null);
-  });
-  app.post("/api/push/test", async (req) => {
-    const device = deviceOf(req);
-    if (push().subscriptions(device.id).length === 0) {
-      throw new SwitchyardError("conflict", "This device has no push subscription");
-    }
-    const r = await push().sendToDevice(device.id, {
-      type: "show",
-      title: "Switchyard",
-      body: "Test notification from Switchyard",
-      tag: "switchyard-test",
-      url: "/settings",
-      renotify: true
-    });
-    return { ok: r.sent > 0, ...r };
-  });
-  app.get("/api/me/notification-settings", async () => push().settings());
-  app.patch("/api/me/notification-settings", async (req) => {
-    const body = parse(NotificationSettings.partial(), req.body);
-    return push().updateSettings(body);
-  });
-}
-
-// packages/coordinator/dist/routes/tasks.js
-import { z as z11 } from "zod";
-
-// packages/coordinator/dist/sessions/control.js
-function requireRun(ctx, session) {
-  const run = ctx.store.runForSession(session);
-  if (!run) {
-    throw new SwitchyardError("invalid_request", "This session is not controlled by an automation run");
-  }
-  return run;
-}
-async function setControl(ctx, sessionId, mode) {
-  const { session, run } = ctx.store.tx(() => {
-    const session2 = ctx.store.sessions.require(sessionId);
-    const run2 = requireRun(ctx, session2);
-    const now = ctx.store.nowIso();
-    const updated = ctx.store.putRun({ ...run2, controlMode: mode, controlRevision: run2.controlRevision + 1, updatedAt: now }, session2.projectId ?? void 0);
-    return { session: session2, run: updated };
-  });
-  ctx.hub.emit("control.changed", { run, session, mode });
-  if (mode === "human")
-    getService(ctx, "dispatcher")?.onTakeover(run.id);
-  if (ctx.hostHub.isConnected(session.hostId)) {
-    try {
-      await ctx.hostHub.request(session.hostId, {
-        type: "session.setControl",
-        sessionId: session.id,
-        controlRevision: run.controlRevision,
-        mode
-      });
-    } catch (err) {
-      ctx.log.warn({ err, sessionId }, "session.setControl failed");
-    }
-  }
-  return { session, run };
-}
-function takeover(ctx, sessionId) {
-  return setControl(ctx, sessionId, "human");
-}
-async function takeoverRun(ctx, runId) {
-  const run = ctx.store.runs.require(runId);
-  if (run.sessionId && ctx.store.sessions.get(run.sessionId)?.runId === run.id) {
-    return (await takeover(ctx, run.sessionId)).run;
-  }
-  const updated = ctx.store.tx(() => {
-    const cur = ctx.store.runs.require(runId);
-    const task = ctx.store.tasks.get(cur.taskId);
-    return ctx.store.putRun({
-      ...cur,
-      controlMode: "human",
-      controlRevision: cur.controlRevision + 1,
-      updatedAt: ctx.store.nowIso()
-    }, task?.projectId);
-  });
-  getService(ctx, "dispatcher")?.onTakeover(updated.id);
-  return updated;
-}
-async function returnToAutomation(ctx, sessionId) {
-  const result = await setControl(ctx, sessionId, "automation");
-  const session = ctx.store.sessions.require(sessionId);
-  if (session.runtime === "idle") {
-    const runs = getService(ctx, "runs");
-    void runs?.onSessionSettled({
-      session,
-      aborted: false,
-      lastAssistantText: session.lastAssistantText
-    }).catch((err) => ctx.log.error({ err, sessionId }, "re-evaluation failed"));
-  }
-  getService(ctx, "dispatcher")?.schedule();
-  return result;
-}
-async function stopSession(ctx, sessionId) {
-  const session = ctx.store.sessions.require(sessionId);
-  const pre = ctx.store.runForSession(session);
-  if (pre && (pre.state === "dispatching" || pre.state === "uncertain")) {
-    throw new SwitchyardError("conflict", "The launch is not confirmed yet; wait for the host or pause automation instead");
-  }
-  await ctx.hostHub.request(session.hostId, {
-    type: "session.abort",
-    sessionId,
-    clearQueue: true
-  });
-  const run = ctx.store.runForSession(session);
-  if (run && !["succeeded", "failed", "canceled", "interrupted"].includes(run.state)) {
-    ctx.store.tx(() => {
-      const now = ctx.store.nowIso();
-      ctx.store.putRun({ ...run, state: "interrupted", updatedAt: now }, session.projectId ?? void 0);
-      const task = ctx.store.tasks.get(run.taskId);
-      if (task && task.currentRunId === run.id) {
-        ctx.store.putTask({
-          ...task,
-          blocked: { reason: "Stopped by user" },
-          updatedAt: now,
-          lastActivityAt: now
-        });
-      }
-    });
-  }
-  return ctx.store.sessions.require(sessionId);
-}
-
-// packages/coordinator/dist/workspaces.js
-import { z as z10 } from "zod";
-var DEFAULT_WORKTREE_DIR = ".worktrees";
-function worktreeDirOf(project) {
-  return project?.worktreeDir || DEFAULT_WORKTREE_DIR;
-}
-function predictedWorktreePath(checkout, project, branch) {
-  return `${checkout.path}/${worktreeDirOf(project)}/${branchSlug(branch)}`;
-}
-var ZERO_GIT = { dirty: false, changedFiles: 0, ahead: 0, behind: 0, unmerged: false };
-var NO_SETUP = { state: "none", log: "" };
-var SetupState2 = z10.object({
-  state: z10.enum(["none", "running", "succeeded", "failed"]),
-  log: z10.string()
-});
-function stripRef(branch) {
-  return branch?.startsWith("refs/heads/") ? branch.slice("refs/heads/".length) : branch;
-}
-async function inspectCheckout(ctx, hostId, path) {
-  const r = await ctx.hostHub.request(hostId, { type: "checkout.inspect", path });
-  return CheckoutInfo.parse(r);
-}
-function recordCreatedWorkspace(ctx, project, checkout, info) {
-  return ctx.store.tx(() => {
-    const existing = ctx.store.workspaceByPath(checkout.hostId, info.path);
-    const buffered = ctx.hostHub.takeBufferedWorkspace(checkout.hostId, info.path);
-    const git = GitState.safeParse(buffered?.git ?? info.git);
-    const setup = SetupState2.safeParse(buffered?.setup ?? info.setup);
-    const ws = {
-      id: existing?.id ?? newId("wsp"),
-      checkoutId: checkout.id,
-      projectId: project.id,
-      hostId: checkout.hostId,
-      path: info.path,
-      branch: info.branch,
-      baseBranch: info.baseBranch,
-      provenance: "managed",
-      git: git.success ? git.data : existing?.git ?? ZERO_GIT,
-      setup: setup.success ? setup.data : existing?.setup ?? NO_SETUP,
-      archivedAt: null,
-      updatedAt: ctx.store.nowIso()
-    };
-    return ctx.store.putWorkspace(ws);
-  });
-}
-async function refreshCheckoutWorkspaces(ctx, checkout) {
-  const raw = await ctx.hostHub.request(checkout.hostId, {
-    type: "workspace.discover",
-    checkoutPath: checkout.path,
-    worktreeDir: worktreeDirOf(ctx.store.projects.get(checkout.projectId))
-  });
-  const list = DiscoveredWorktree.array().parse(Array.isArray(raw) ? raw : raw?.worktrees ?? []);
-  return ctx.store.tx(() => {
-    const now = ctx.store.nowIso();
-    const seen = /* @__PURE__ */ new Set();
-    const out = [];
-    for (const wt of list) {
-      if (wt.bare || wt.prunable)
-        continue;
-      seen.add(wt.path);
-      const existing = ctx.store.workspaceByPath(checkout.hostId, wt.path);
-      const next = {
-        id: existing?.id ?? newId("wsp"),
-        checkoutId: checkout.id,
-        projectId: checkout.projectId,
-        hostId: checkout.hostId,
-        path: wt.path,
-        branch: stripRef(wt.branch),
-        baseBranch: existing?.baseBranch ?? (wt.provenance === "main" ? null : checkout.defaultBranch),
-        provenance: existing?.provenance === "managed" ? "managed" : wt.provenance,
-        git: wt.git ?? existing?.git ?? ZERO_GIT,
-        setup: existing?.setup ?? NO_SETUP,
-        archivedAt: null,
-        updatedAt: existing?.updatedAt ?? now
-      };
-      const changed = !existing || JSON.stringify({ ...existing, updatedAt: "" }) !== JSON.stringify({ ...next, updatedAt: "" });
-      out.push(changed ? ctx.store.putWorkspace({ ...next, updatedAt: now }) : existing);
-    }
-    for (const ws of ctx.store.workspaces.list("checkout_id = ? AND archived_at IS NULL", [
-      checkout.id
-    ])) {
-      if (!seen.has(ws.path))
-        ctx.store.putWorkspace({ ...ws, archivedAt: now, updatedAt: now });
-    }
-    return out;
+    const payload = req.body ?? {};
+    const key = idem ? `hook:${idem}` : derivedWebhookKey(payload, store.now());
+    const match = filtersMatch(a.filters, payload);
+    const r = svc().fire(a.id, match.ok ? { key, scheduledFor: null, payload } : { key, scheduledFor: null, record: { state: "filtered", reason: match.reason } });
+    return reply.code(202).send({
+      occurrenceId: r.occurrence.id,
+      state: r.occurrence.state,
+      ...r.duplicate ? { duplicate: true } : {}
+    });
   });
 }
-async function refreshWorkspaceStatus(ctx, ws) {
-  const raw = await ctx.hostHub.request(ws.hostId, {
-    type: "workspace.status",
-    path: ws.path,
-    base: ws.baseBranch
-  });
-  const git = GitState.parse(raw?.git ?? raw);
-  return ctx.store.tx(() => {
-    const cur = ctx.store.workspaces.require(ws.id);
-    if (JSON.stringify(cur.git) === JSON.stringify(git))
-      return cur;
-    return ctx.store.putWorkspace({ ...cur, git, updatedAt: ctx.store.nowIso() });
-  });
+var WEBHOOK_DEDUPE_WINDOW_MS = 10 * 6e4;
+function derivedWebhookKey(payload, now) {
+  const bucket = Math.floor(now.getTime() / WEBHOOK_DEDUPE_WINDOW_MS);
+  const digest = createHash2("sha256").update(JSON.stringify(payload)).digest("hex");
+  return `hook:body:${digest}:${bucket}`;
 }
-function baseFor(ctx, ws) {
-  return ws.baseBranch ?? ctx.store.checkouts.get(ws.checkoutId)?.defaultBranch ?? null;
+function headerValue(v) {
+  const s = Array.isArray(v) ? v[0] : v;
+  return s?.trim() ? s.trim().slice(0, 200) : null;
+}
+function validated(body) {
+  return parse(AutomationInput, body);
 }
 
-// packages/coordinator/dist/sessions/service.js
-var LIVE_RUNTIMES2 = ["starting", "idle", "running", "waiting_input"];
-function requireUsableHost(ctx, hostId) {
-  const host = ctx.store.hosts.require(hostId);
-  if (host.revokedAt)
-    throw new SwitchyardError("forbidden", `Host ${host.name} was revoked`);
-  if (!ctx.hostHub.isConnected(hostId)) {
-    throw new SwitchyardError("host_unreachable", `Host ${host.name} is offline`, { hostId });
-  }
-  if (!host.piCompatible) {
-    throw new SwitchyardError("pi_incompatible", `Pi ${host.piVersion ?? "(not found)"} on ${host.name} is outside the tested range`, { hostId });
-  }
+// packages/coordinator/dist/routes/push.js
+import { z as z10 } from "zod";
+var DeleteSubscription = z10.object({ endpoint: z10.string().optional() });
+function registerPushRoutes(app, ctx) {
+  const push = () => requireService(ctx, "push");
+  app.get("/api/push/vapid-public-key", async () => ({ publicKey: push().vapid().publicKey }));
+  app.post("/api/push/subscriptions", async (req, reply) => {
+    const body = parse(PushSubscriptionRequest, req.body);
+    const device = deviceOf(req);
+    const updated = push().subscribe(device.id, { endpoint: body.endpoint, keys: body.keys }, body.permission);
+    return reply.code(201).send(updated);
+  });
+  app.delete("/api/push/subscriptions", async (req) => {
+    const body = parse(DeleteSubscription, req.body ?? {});
+    return push().unsubscribe(deviceOf(req).id, body.endpoint ?? null);
+  });
+  app.post("/api/push/test", async (req) => {
+    const device = deviceOf(req);
+    if (push().subscriptions(device.id).length === 0) {
+      throw new SwitchyardError("conflict", "This device has no push subscription");
+    }
+    const r = await push().sendToDevice(device.id, {
+      type: "show",
+      title: "Switchyard",
+      body: "Test notification from Switchyard",
+      tag: "switchyard-test",
+      url: "/settings",
+      renotify: true
+    });
+    return { ok: r.sent > 0, ...r };
+  });
+  app.get("/api/me/notification-settings", async () => push().settings());
+  app.patch("/api/me/notification-settings", async (req) => {
+    const body = parse(NotificationSettings.partial(), req.body);
+    return push().updateSettings(body);
+  });
 }
-function requireConnected(ctx, hostId) {
-  const host = ctx.store.hosts.require(hostId);
-  if (!ctx.hostHub.isConnected(hostId)) {
-    throw new SwitchyardError("host_unreachable", `Host ${host.name} is offline`, { hostId });
+
+// packages/coordinator/dist/routes/tasks.js
+import { z as z11 } from "zod";
+
+// packages/coordinator/dist/sessions/control.js
+function requireRun(ctx, session) {
+  const run = ctx.store.runForSession(session);
+  if (!run) {
+    throw new SwitchyardError("invalid_request", "This session is not controlled by an automation run");
   }
+  return run;
 }
-function resolveProfile(ctx, profileId, project) {
-  const id = profileId ?? project?.defaultProfileId ?? null;
-  if (id)
-    return ctx.store.profiles.require(id);
-  const first = ctx.store.profiles.list(void 0, [], "created_at")[0];
-  if (!first)
-    throw new SwitchyardError("invalid_request", "No Pi profile configured");
-  return first;
-}
-function titleFrom(prompt, fallback = "New session") {
-  const line = prompt.trim().split("\n")[0]?.trim() ?? "";
-  if (!line)
-    return fallback;
-  return line.length > 80 ? `${line.slice(0, 77)}...` : line;
-}
-function appendNotice(ctx, session, level, text) {
-  return ctx.store.tx(() => {
-    const item = {
-      id: newId("itm"),
-      sessionId: session.id,
-      order: ctx.store.maxItemOrder(session.id) + 1,
-      at: ctx.store.nowIso(),
-      kind: "notice",
-      data: { level, text }
-    };
-    ctx.store.upsertItem(item);
-    ctx.store.appendEvent("transcript.item", { sessionId: session.id, hostId: session.hostId, projectId: session.projectId ?? void 0 }, item);
-    return item;
+async function setControl(ctx, sessionId, mode) {
+  const { session, run } = ctx.store.tx(() => {
+    const session2 = ctx.store.sessions.require(sessionId);
+    const run2 = requireRun(ctx, session2);
+    const now = ctx.store.nowIso();
+    const updated = ctx.store.putRun({ ...run2, controlMode: mode, controlRevision: run2.controlRevision + 1, updatedAt: now }, session2.projectId ?? void 0);
+    return { session: session2, run: updated };
   });
+  ctx.hub.emit("control.changed", { run, session, mode });
+  if (mode === "human")
+    getService(ctx, "dispatcher")?.onTakeover(run.id);
+  if (ctx.hostHub.isConnected(session.hostId)) {
+    try {
+      await ctx.hostHub.request(session.hostId, {
+        type: "session.setControl",
+        sessionId: session.id,
+        controlRevision: run.controlRevision,
+        mode
+      });
+    } catch (err) {
+      ctx.log.warn({ err, sessionId }, "session.setControl failed");
+    }
+  }
+  return { session, run };
 }
-function failSession(ctx, sessionId, message) {
-  ctx.store.tx(() => {
-    const s = ctx.store.sessions.get(sessionId);
-    if (!s)
-      return;
-    ctx.store.putSession({
-      ...s,
-      runtime: "failed",
-      runtimeDetail: message,
-      lastActivityAt: ctx.store.nowIso()
-    });
-    appendNotice(ctx, s, "error", message);
-  });
+function takeover(ctx, sessionId) {
+  return setControl(ctx, sessionId, "human");
 }
-async function startOnHost(ctx, session, opts) {
-  const cmd = {
-    type: "session.start",
-    sessionId: session.id,
-    title: session.title,
-    workspacePath: session.cwd,
-    projectId: session.projectId,
-    profile: session.profileSnapshot,
-    nativeHandle: opts.nativeHandle,
-    initialPrompt: opts.initialPrompt,
-    dispatchKey: opts.dispatchKey ?? null,
-    controlRevision: opts.controlRevision ?? 1,
-    controlMode: opts.controlMode ?? "human",
-    origin: opts.origin ?? "human",
-    readOnly: session.readOnly
-  };
-  const result = await ctx.hostHub.request(session.hostId, cmd);
-  return ctx.store.tx(() => {
-    const s = ctx.store.sessions.require(session.id);
-    const handle = result?.nativeHandle ?? null;
-    if (handle && JSON.stringify(handle) !== JSON.stringify(s.nativeHandle)) {
-      return ctx.store.putSession({ ...s, nativeHandle: handle });
-    }
-    return s;
+async function takeoverRun(ctx, runId) {
+  const run = ctx.store.runs.require(runId);
+  if (run.sessionId && ctx.store.sessions.get(run.sessionId)?.runId === run.id) {
+    return (await takeover(ctx, run.sessionId)).run;
+  }
+  const updated = ctx.store.tx(() => {
+    const cur = ctx.store.runs.require(runId);
+    const task = ctx.store.tasks.get(cur.taskId);
+    return ctx.store.putRun({
+      ...cur,
+      controlMode: "human",
+      controlRevision: cur.controlRevision + 1,
+      updatedAt: ctx.store.nowIso()
+    }, task?.projectId);
   });
+  getService(ctx, "dispatcher")?.onTakeover(updated.id);
+  return updated;
 }
-async function createWorkspace(ctx, project, checkout, branch, base) {
-  requireConnected(ctx, checkout.hostId);
-  const baseBranch = base ?? checkout.defaultBranch;
-  const result = await ctx.hostHub.request(checkout.hostId, {
-    type: "workspace.create",
-    checkoutPath: checkout.path,
-    branch,
-    base: baseBranch,
-    setupCommand: project.setupCommand,
-    worktreeDir: worktreeDirOf(project)
-  });
-  const predicted = predictedWorktreePath(checkout, project, branch);
-  return recordCreatedWorkspace(ctx, project, checkout, {
-    path: typeof result?.path === "string" ? result.path : predicted,
-    branch: typeof result?.branch === "string" ? result.branch : branch,
-    baseBranch,
-    git: result?.git,
-    setup: result?.setup
-  });
+async function returnToAutomation(ctx, sessionId) {
+  const result = await setControl(ctx, sessionId, "automation");
+  const session = ctx.store.sessions.require(sessionId);
+  if (session.runtime === "idle") {
+    const runs = getService(ctx, "runs");
+    void runs?.onSessionSettled({
+      session,
+      aborted: false,
+      lastAssistantText: session.lastAssistantText
+    }).catch((err) => ctx.log.error({ err, sessionId }, "re-evaluation failed"));
+  }
+  getService(ctx, "dispatcher")?.schedule();
+  return result;
 }
-function createSession(ctx, input) {
-  const project = ctx.store.projects.require(input.projectId);
-  const profile = resolveProfile(ctx, input.profileId, project);
-  let hostId;
-  let workspace = null;
-  let checkout = null;
-  if ("existingId" in input.workspace) {
-    workspace = ctx.store.workspaces.require(input.workspace.existingId);
-    if (workspace.projectId !== project.id) {
-      throw new SwitchyardError("invalid_request", "Workspace belongs to another project");
-    }
-    if (workspace.archivedAt)
-      throw new SwitchyardError("conflict", "Workspace is archived");
-    hostId = workspace.hostId;
-  } else {
-    checkout = ctx.store.checkouts.require(input.workspace.checkoutId);
-    if (checkout.projectId !== project.id) {
-      throw new SwitchyardError("invalid_request", "Checkout belongs to another project");
-    }
-    hostId = checkout.hostId;
+async function stopSession(ctx, sessionId) {
+  const session = ctx.store.sessions.require(sessionId);
+  const pre = ctx.store.runForSession(session);
+  if (pre && (pre.state === "dispatching" || pre.state === "uncertain")) {
+    throw new SwitchyardError("conflict", "The launch is not confirmed yet; wait for the host or pause automation instead");
   }
-  requireUsableHost(ctx, hostId);
-  const now = ctx.store.nowIso();
-  const host = ctx.store.hosts.require(hostId);
-  const session = {
-    id: newId("ses"),
-    title: input.title?.trim() || titleFrom(input.prompt),
-    subtitle: null,
-    hostId,
-    workspaceId: workspace?.id ?? null,
-    projectId: project.id,
-    cwd: workspace?.path ?? predictedWorktreePath(checkout, project, input.workspace.newBranch),
-    nativeHandle: null,
-    profileSnapshot: profile,
-    runtime: "starting",
-    runtimeDetail: null,
-    connectivity: host.connectivity,
-    runId: null,
-    taskId: null,
-    provenance: "created",
-    readOnly: false,
-    lastActivityAt: now,
-    archivedAt: null,
-    queue: { steering: [], followUp: [] },
-    stats: null,
-    lastAssistantText: null,
-    createdAt: now
-  };
-  ctx.store.putSession(session);
-  const choice = input.workspace;
-  const started = (async () => {
-    try {
-      let s = session;
-      if (!("existingId" in choice)) {
-        const ws = await createWorkspace(ctx, project, checkout, choice.newBranch, choice.base);
-        s = ctx.store.tx(() => {
-          const cur = ctx.store.sessions.require(session.id);
-          return ctx.store.putSession({ ...cur, workspaceId: ws.id, cwd: ws.path });
+  await ctx.hostHub.request(session.hostId, {
+    type: "session.abort",
+    sessionId,
+    clearQueue: true
+  });
+  const run = ctx.store.runForSession(session);
+  if (run && !["succeeded", "failed", "canceled", "interrupted"].includes(run.state)) {
+    ctx.store.tx(() => {
+      const now = ctx.store.nowIso();
+      ctx.store.putRun({ ...run, state: "interrupted", updatedAt: now }, session.projectId ?? void 0);
+      const task = ctx.store.tasks.get(run.taskId);
+      if (task && task.currentRunId === run.id) {
+        ctx.store.putTask({
+          ...task,
+          blocked: { reason: "Stopped by user" },
+          updatedAt: now,
+          lastActivityAt: now
         });
       }
-      await startOnHost(ctx, s, {
-        initialPrompt: input.prompt.trim() ? input.prompt : null,
-        nativeHandle: null
-      });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      ctx.log.warn({ err, sessionId: session.id }, "session start failed");
-      failSession(ctx, session.id, `Could not start the session: ${message}`);
-    }
-  })();
-  return { session, started };
+    });
+  }
+  return ctx.store.sessions.require(sessionId);
 }
 
 // packages/coordinator/dist/routes/tasks.js
@@ -7553,13 +7805,17 @@ function installBuiltins(app, ctx, opts = {}) {
   const notifications = new NotificationRouter(ctx, push, {
     desktopRecentMs: opts.desktopRecentMs ?? 5 * 6e4
   });
+  const projectFolders = new ProjectFolderService(ctx, {
+    intervalMs: opts.projectScanIntervalMs ?? PROJECT_SCAN_INTERVAL_MS
+  });
   const services = {
     dispatcher,
     runs,
     automations,
     scheduler,
     push,
-    notifications
+    notifications,
+    projectFolders
   };
   for (const [name, svc] of Object.entries(services))
     ctx.services.set(name, svc);
@@ -7575,8 +7831,10 @@ function installBuiltins(app, ctx, opts = {}) {
       notifications.start();
       dispatcher.start();
       scheduler.start();
+      projectFolders.start();
     },
     stop() {
+      projectFolders.stop();
       scheduler.stop();
       dispatcher.stop();
       notifications.stop();
@@ -8286,12 +8544,12 @@ var HostHub = class {
     const commandId = opts.commandId ?? newId("cmd");
     const existing = this.pending.get(commandId);
     if (existing) {
-      return new Promise((resolve12, reject) => {
+      return new Promise((resolve13, reject) => {
         const prevResolve = existing.resolve;
         const prevReject = existing.reject;
         existing.resolve = (r) => {
           prevResolve(r);
-          resolve12(r);
+          resolve13(r);
         };
         existing.reject = (e) => {
           prevReject(e);
@@ -8305,7 +8563,7 @@ var HostHub = class {
       command: parsed
     });
     const timeoutMs = opts.timeoutMs ?? this.opts.commandTimeoutMs;
-    return new Promise((resolve12, reject) => {
+    return new Promise((resolve13, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(commandId);
         reject(new SwitchyardError("timeout", `Host did not answer ${parsed.type} in time`, {
@@ -8314,7 +8572,7 @@ var HostHub = class {
         }));
       }, timeoutMs);
       timer.unref();
-      this.pending.set(commandId, { hostId, frame, resolve: resolve12, reject, timer });
+      this.pending.set(commandId, { hostId, frame, resolve: resolve13, reject, timer });
       conn.socket.send(frame);
     });
   }
@@ -9719,6 +9977,31 @@ function registerHostRoutes(app, ctx) {
     const host = ctx.store.hosts.require(id);
     return { ...host, adapters: ctx.store.adaptersByHost()[id] ?? [] };
   });
+  app.patch("/api/hosts/:id", async (req) => {
+    const { id } = req.params;
+    const body = parse(UpdateHostRequest, req.body);
+    let scan = false;
+    const host = ctx.store.tx(() => {
+      const h = ctx.store.hosts.require(id);
+      if (h.revokedAt)
+        throw new SwitchyardError("forbidden", "This host was revoked");
+      const next = { ...h };
+      if (body.projectFolders !== void 0) {
+        const folders = normalizeProjectFolders(body.projectFolders);
+        scan = folders.length > 0 && JSON.stringify(folders) !== JSON.stringify(h.projectFolders ?? []);
+        next.projectFolders = folders;
+      }
+      return ctx.store.putHost(next);
+    });
+    if (scan && ctx.hostHub.isConnected(id)) {
+      requireService(ctx, "projectFolders").background(id);
+    }
+    return host;
+  });
+  app.post("/api/hosts/:id/scan-projects", async (req) => {
+    const { id } = req.params;
+    return requireService(ctx, "projectFolders").scan(id);
+  });
   const revoke = async (req) => {
     const { id } = req.params;
     const host = ctx.store.tx(() => {
@@ -9928,21 +10211,17 @@ function registerProjectRoutes(app, ctx) {
       if (dupe) {
         throw new SwitchyardError("conflict", `Project ${dupe.name} already tracks ${info.repoIdentity}; add a checkout to it instead`, { projectId: dupe.id });
       }
-      const project2 = {
-        id: newId("prj"),
+      const project2 = newProject({
         name: body.name,
         repoIdentity: info.repoIdentity,
-        defaultProfileId: body.defaultProfileId ?? null,
-        defaultHostId: body.hostId,
-        maxConcurrentRuns: body.maxConcurrentRuns ?? 1,
-        automationEnabled: true,
-        setupCommand: body.setupCommand ?? null,
-        checks: body.checks ?? [],
-        workspaceSharing: "single_writer",
-        worktreeDir: body.worktreeDir ?? DEFAULT_WORKTREE_DIR,
-        createdAt: now,
-        updatedAt: now
-      };
+        hostId: body.hostId,
+        now,
+        defaultProfileId: body.defaultProfileId,
+        setupCommand: body.setupCommand,
+        checks: body.checks,
+        maxConcurrentRuns: body.maxConcurrentRuns,
+        worktreeDir: body.worktreeDir
+      });
       const checkout2 = {
         id: newId("chk"),
         projectId: project2.id,
@@ -12563,7 +12842,7 @@ function tailBytes(text, maxBytes) {
   return buf.subarray(start).toString("utf8");
 }
 function spawnShell(cwd, cmd, opts) {
-  return new Promise((resolve12) => {
+  return new Promise((resolve13) => {
     let settled = false;
     let timedOut = false;
     let exit = null;
@@ -12581,7 +12860,7 @@ function spawnShell(cwd, cmd, opts) {
       clearTimeout(timeout);
       clearTimeout(killTimer);
       clearTimeout(closeTimer);
-      resolve12(outcome);
+      resolve13(outcome);
     };
     const timeout = setTimeout(() => {
       timedOut = true;
@@ -13306,6 +13585,81 @@ exit code ${outcome.signal ?? "null"}` : `exit code ${outcome.code ?? outcome.si
   return final;
 }
 
+// packages/host-agent/dist/project-folders.js
+import { lstat as lstat3, readdir as readdir3, realpath as realpath3, stat as stat3 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { isAbsolute as isAbsolute3, join as join11 } from "node:path";
+function expandHome2(folder, home = homedir3()) {
+  if (folder === "~")
+    return home;
+  if (folder.startsWith("~/"))
+    return join11(home, folder.slice(2));
+  return folder;
+}
+async function mapLimit(items, limit, fn) {
+  const out = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const i = next++;
+      out[i] = await fn(items[i]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+  return out;
+}
+async function isDirectory(path) {
+  try {
+    return (await stat3(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function scanProjectFolder(folder, opts = {}) {
+  const p = expandHome2(folder.trim(), opts.home);
+  if (!isAbsolute3(p)) {
+    throw new SwitchyardError("invalid_request", "Project folders must be absolute or start with ~/");
+  }
+  let st;
+  try {
+    st = await stat3(p);
+  } catch {
+    throw new SwitchyardError("not_found", `${folder} does not exist on this host`);
+  }
+  if (!st.isDirectory()) {
+    throw new SwitchyardError("invalid_request", `${folder} is not a directory`);
+  }
+  const root = await realpath3(p);
+  const entries = await readdir3(root, { withFileTypes: true });
+  const candidates = [];
+  for (const e of entries) {
+    if (e.name.startsWith("."))
+      continue;
+    if (e.isDirectory() || e.isSymbolicLink() && await isDirectory(join11(root, e.name))) {
+      candidates.push(e.name);
+    }
+  }
+  const found = await mapLimit(candidates, opts.concurrency ?? 8, async (name) => {
+    const dir = join11(root, name);
+    try {
+      await lstat3(join11(dir, ".git"));
+    } catch {
+      return null;
+    }
+    const info = await inspectCheckout2(dir).catch(() => null);
+    if (!info)
+      return null;
+    if (info.root !== await realpath3(dir).catch(() => ""))
+      return null;
+    const ownGitDir = await realpath3(join11(info.root, ".git")).catch(() => "");
+    if (info.commonDir !== ownGitDir)
+      return null;
+    return { ...info, name };
+  });
+  const repositories = found.filter((r) => r !== null).sort((a, b) => a.name.localeCompare(b.name));
+  return { folder: root, repositories };
+}
+
 // packages/host-agent/dist/commands.js
 function toErrorBody(err) {
   if (err instanceof SwitchyardError)
@@ -13478,6 +13832,8 @@ var CommandRouter = class {
         return sup.snapshot(c.sessionId);
       case "checkout.inspect":
         return inspectCheckout2(c.path);
+      case "projects.scan":
+        return scanProjectFolder(c.folder);
       case "workspace.discover":
         return {
           worktrees: await discoverWorktrees(c.checkoutPath, { worktreeDir: c.worktreeDir })
@@ -13511,8 +13867,8 @@ var CommandRouter = class {
 
 // packages/host-agent/dist/config.js
 import { chmodSync as chmodSync3, existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync5, renameSync as renameSync3, writeFileSync as writeFileSync4 } from "node:fs";
-import { homedir as homedir3, hostname as hostname2 } from "node:os";
-import { dirname as dirname5, join as join11 } from "node:path";
+import { homedir as homedir4, hostname as hostname2 } from "node:os";
+import { dirname as dirname5, join as join12 } from "node:path";
 import { z as z20 } from "zod";
 var HostConfigSchema = z20.object({
   coordinatorUrl: z20.string().min(1),
@@ -13520,28 +13876,28 @@ var HostConfigSchema = z20.object({
   credential: z20.string().min(1),
   name: z20.string().min(1)
 });
-function defaultConfigPath(env = process.env, home = homedir3()) {
+function defaultConfigPath(env = process.env, home = homedir4()) {
   const fromEnv = env.SWITCHYARD_HOST_CONFIG?.trim();
   if (fromEnv)
     return fromEnv;
   const xdg = env.XDG_CONFIG_HOME?.trim();
-  return join11(xdg || join11(home, ".config"), "switchyard", "host.json");
+  return join12(xdg || join12(home, ".config"), "switchyard", "host.json");
 }
-function defaultStateDir(env = process.env, platform = process.platform, home = homedir3()) {
+function defaultStateDir(env = process.env, platform = process.platform, home = homedir4()) {
   const fromEnv = env.SWITCHYARD_STATE_DIR?.trim();
   if (fromEnv)
     return fromEnv;
   if (platform === "darwin")
-    return join11(home, "Library", "Application Support", "switchyard");
+    return join12(home, "Library", "Application Support", "switchyard");
   const xdg = env.XDG_STATE_HOME?.trim();
-  return join11(xdg || join11(home, ".local", "state"), "switchyard");
+  return join12(xdg || join12(home, ".local", "state"), "switchyard");
 }
 function statePaths(stateDir) {
   const p = {
     root: stateDir,
-    db: join11(stateDir, "host.db"),
-    runtime: join11(stateDir, "runtime"),
-    logs: join11(stateDir, "logs")
+    db: join12(stateDir, "host.db"),
+    runtime: join12(stateDir, "runtime"),
+    logs: join12(stateDir, "logs")
   };
   for (const d of [p.root, p.runtime, p.logs])
     mkdirSync5(d, { recursive: true, mode: 448 });
@@ -14126,16 +14482,16 @@ var CoordinatorLink = class {
     this.ready = false;
     if (!ws)
       return;
-    await new Promise((resolve12) => {
+    await new Promise((resolve13) => {
       if (ws.readyState === WebSocket2.CLOSED)
-        return resolve12();
+        return resolve13();
       const timer = setTimeout(() => {
         ws.terminate();
-        resolve12();
+        resolve13();
       }, 2e3);
       ws.once("close", () => {
         clearTimeout(timer);
-        resolve12();
+        resolve13();
       });
       try {
         ws.close(1e3, "host agent stopping");
@@ -14455,7 +14811,7 @@ function isSupportedVersion(version) {
 async function detectPi(piBin = "pi", env = {}) {
   let out;
   try {
-    out = await new Promise((resolve12, reject) => {
+    out = await new Promise((resolve13, reject) => {
       execFile2(piBin, ["--version"], {
         timeout: 3e4,
         env: {
@@ -14465,7 +14821,7 @@ async function detectPi(piBin = "pi", env = {}) {
           PI_TELEMETRY: "0",
           ...env
         }
-      }, (err, stdout, stderr) => err ? reject(err) : resolve12(`${stdout}
+      }, (err, stdout, stderr) => err ? reject(err) : resolve13(`${stdout}
 ${stderr}`));
     });
   } catch (err) {
@@ -14492,9 +14848,9 @@ ${stderr}`));
 
 // packages/pi-runtime/dist/importable.js
 import { accessSync, constants, readFileSync as readFileSync6, realpathSync } from "node:fs";
-import { open, readdir as readdir3, readFile as readFile6, stat as stat3 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
-import { delimiter, dirname as dirname7, join as join12, resolve as resolve10 } from "node:path";
+import { open, readdir as readdir4, readFile as readFile6, stat as stat4 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { delimiter, dirname as dirname7, join as join13, resolve as resolve10 } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 
 // packages/pi-runtime/dist/transcript.js
@@ -14664,8 +15020,8 @@ ${output}`.trimEnd() }, at);
 // packages/pi-runtime/dist/importable.js
 var INACTIVE_AFTER_MS = 12e4;
 function defaultSessionsRoot() {
-  const agentDir = process.env.PI_CODING_AGENT_DIR ?? join12(homedir4(), ".pi", "agent");
-  return join12(agentDir, "sessions");
+  const agentDir = process.env.PI_CODING_AGENT_DIR ?? join13(homedir5(), ".pi", "agent");
+  return join13(agentDir, "sessions");
 }
 async function readFirstLine(file) {
   const fh = await open(file, "r");
@@ -14713,12 +15069,12 @@ function readSessionNameSync(file) {
 async function findJsonl(dir, depth, out) {
   let entries;
   try {
-    entries = await readdir3(dir, { withFileTypes: true });
+    entries = await readdir4(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
-    const full = join12(dir, entry.name);
+    const full = join13(dir, entry.name);
     if (entry.isDirectory() && depth > 0)
       await findJsonl(full, depth - 1, out);
     else if (entry.isFile() && entry.name.endsWith(".jsonl"))
@@ -14737,7 +15093,7 @@ async function listImportable(sessionsRoot = defaultSessionsRoot(), now = Date.n
       const header = JSON.parse(first);
       if (header?.type !== "session" || typeof header.id !== "string")
         continue;
-      const st = await stat3(file);
+      const st = await stat4(file);
       const content = await readFile6(file, "utf8");
       result.push({
         sessionFile: file,
@@ -14761,7 +15117,7 @@ function findOnPath(bin) {
   for (const dir of (process.env.PATH ?? "").split(delimiter)) {
     if (!dir)
       continue;
-    const candidate = join12(dir, bin);
+    const candidate = join13(dir, bin);
     try {
       accessSync(candidate, constants.X_OK);
       return candidate;
@@ -14794,14 +15150,14 @@ function resolvePiPackageRoot(piBin = "pi") {
     let dir = dirname7(start);
     for (let i = 0; i < 8; i++) {
       try {
-        const pkg = JSON.parse(readFileSync6(join12(dir, "package.json"), "utf8"));
+        const pkg = JSON.parse(readFileSync6(join13(dir, "package.json"), "utf8"));
         if (pkg?.name === "@earendil-works/pi-coding-agent")
           return dir;
       } catch {
       }
-      const nested = join12(dir, "lib", "node_modules", "@earendil-works", "pi-coding-agent");
+      const nested = join13(dir, "lib", "node_modules", "@earendil-works", "pi-coding-agent");
       try {
-        const pkg = JSON.parse(readFileSync6(join12(nested, "package.json"), "utf8"));
+        const pkg = JSON.parse(readFileSync6(join13(nested, "package.json"), "utf8"));
         if (pkg?.name === "@earendil-works/pi-coding-agent")
           return nested;
       } catch {
@@ -14821,7 +15177,7 @@ function loadPiEntryParser(piBin = "pi") {
     if (!root)
       return null;
     try {
-      const mod = await import(pathToFileURL2(join12(root, "dist", "index.js")).href);
+      const mod = await import(pathToFileURL2(join13(root, "dist", "index.js")).href);
       return typeof mod.parseSessionEntries === "function" ? mod.parseSessionEntries : null;
     } catch {
       return null;
@@ -14978,7 +15334,7 @@ function serializeJsonl(value) {
 `;
 }
 function writeJsonl(stream, value) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     if (stream.destroyed || stream.writableEnded) {
       reject(new Error("stream is closed"));
       return;
@@ -14994,7 +15350,7 @@ function writeJsonl(stream, value) {
       return;
     }
     if (ok) {
-      resolve12();
+      resolve13();
       return;
     }
     const cleanup = () => {
@@ -15004,7 +15360,7 @@ function writeJsonl(stream, value) {
     };
     const onDrain = () => {
       cleanup();
-      resolve12();
+      resolve13();
     };
     const onClose = () => {
       cleanup();
@@ -15023,7 +15379,7 @@ import { EventEmitter as EventEmitter3 } from "node:events";
 import { chmodSync as chmodSync4, existsSync as existsSync10, mkdirSync as mkdirSync7, rmSync as rmSync2 } from "node:fs";
 import { createServer } from "node:net";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function bridgeExtensionPath() {
   const sibling = fileURLToPath2(new URL("./bridge/switchyard-bridge.js", import.meta.url));
@@ -15043,11 +15399,11 @@ var MAX_SOCKET_PATH = 100;
 function bridgeSocketPath(runtimeDir) {
   const name = `bridge-${randomUUID().slice(0, 8)}.sock`;
   let dir = runtimeDir;
-  if (join13(dir, name).length > MAX_SOCKET_PATH) {
-    dir = join13("/tmp", `switchyard-${process.getuid?.() ?? "u"}`);
+  if (join14(dir, name).length > MAX_SOCKET_PATH) {
+    dir = join14("/tmp", `switchyard-${process.getuid?.() ?? "u"}`);
   }
   mkdirSync7(dir, { recursive: true, mode: 448 });
-  return join13(dir, name);
+  return join14(dir, name);
 }
 var PiRpcProcess = class _PiRpcProcess extends EventEmitter3 {
   child;
@@ -15067,10 +15423,10 @@ var PiRpcProcess = class _PiRpcProcess extends EventEmitter3 {
     this.child = child;
     this.server = server;
     this.bridgeSocket = socketPath;
-    this.exitPromise = new Promise((resolve12) => {
+    this.exitPromise = new Promise((resolve13) => {
       child.once("exit", (code, signal) => {
         this.exitInfo = { code, signal, requested: this.closeRequested };
-        resolve12(this.exitInfo);
+        resolve13(this.exitInfo);
       });
     });
     JsonlReader.attach(child.stdout, (record) => this.onRecord(record), (err, line) => this.emit("protocol_error", err, line));
@@ -15100,18 +15456,18 @@ var PiRpcProcess = class _PiRpcProcess extends EventEmitter3 {
     let proc = null;
     const early = [];
     if (useBridge) {
-      socketPath = bridgeSocketPath(opts.runtimeDir ?? join13(tmpdir2(), "switchyard"));
+      socketPath = bridgeSocketPath(opts.runtimeDir ?? join14(tmpdir2(), "switchyard"));
       server = createServer((socket) => {
         if (proc)
           proc.attachBridgeSocket(socket);
         else
           early.push(socket);
       });
-      await new Promise((resolve12, reject) => {
+      await new Promise((resolve13, reject) => {
         server.once("error", reject);
         server.listen(socketPath, () => {
           server.off("error", reject);
-          resolve12();
+          resolve13();
         });
       });
       try {
@@ -15137,10 +15493,10 @@ var PiRpcProcess = class _PiRpcProcess extends EventEmitter3 {
       stdio: ["pipe", "pipe", "pipe"]
     });
     try {
-      await new Promise((resolve12, reject) => {
+      await new Promise((resolve13, reject) => {
         child.once("spawn", () => {
           child.off("error", reject);
-          resolve12();
+          resolve13();
         });
         child.once("error", reject);
       });
@@ -15177,12 +15533,12 @@ var PiRpcProcess = class _PiRpcProcess extends EventEmitter3 {
       return Promise.reject(new PiRpcError(cmd.type, "Pi is not running"));
     }
     const id = `sy-${++this.nextId}`;
-    return new Promise((resolve12, reject) => {
+    return new Promise((resolve13, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(new PiRpcError(cmd.type, `Pi did not answer ${cmd.type} within ${timeoutMs} ms`));
       }, timeoutMs);
-      this.pending.set(id, { command: cmd.type, resolve: resolve12, reject, timer });
+      this.pending.set(id, { command: cmd.type, resolve: resolve13, reject, timer });
       writeJsonl(this.child.stdin, { ...cmd, id }).catch((err) => {
         const p = this.pending.get(id);
         if (!p)
@@ -15211,7 +15567,7 @@ var PiRpcProcess = class _PiRpcProcess extends EventEmitter3 {
     }
     const graceMs = opts.graceMs ?? 1e4;
     const termMs = opts.termMs ?? 3e3;
-    const timeout = (ms) => new Promise((resolve12) => setTimeout(() => resolve12(null), ms).unref());
+    const timeout = (ms) => new Promise((resolve13) => setTimeout(() => resolve13(null), ms).unref());
     let info = await Promise.race([this.exitPromise, timeout(graceMs)]);
     if (info)
       return info;
@@ -15989,7 +16345,7 @@ ${output}`.trimEnd() }));
 
 // packages/host-agent/dist/supervisor.js
 import { existsSync as existsSync12, realpathSync as realpathSync2, statSync } from "node:fs";
-import { join as join14, sep as sep3 } from "node:path";
+import { join as join15, sep as sep3 } from "node:path";
 var RESTART_NOTICE = "Host agent restarted; resume to continue";
 var QUEUED_ANSWER_SUMMARY = "Answered from your earlier form";
 var PI_CLOSED_SUMMARY = "Pi closed this question (timeout or abort)";
@@ -16447,7 +16803,7 @@ var SessionSupervisor = class {
   }
   async importable() {
     const env = { ...process.env, ...this.opts.env ?? {} };
-    const root = join14(piAgentDir(env), "sessions");
+    const root = join15(piAgentDir(env), "sessions");
     const list = await listImportable(root);
     const liveFiles = new Set([...this.live.values()].flatMap((l) => l.rec.nativeHandle ? [realpathOr2(l.rec.nativeHandle.sessionFile)] : []));
     return {
@@ -17280,7 +17636,7 @@ function defaultDoctorDeps(ctx) {
   return {
     nodeVersion: process.versions.node,
     detectPi: () => detectPi(ctx.env.SWITCHYARD_PI_BIN ?? "pi"),
-    gitVersion: () => new Promise((resolve12) => execFile3("git", ["--version"], (err, stdout) => resolve12(err ? null : stdout.trim()))),
+    gitVersion: () => new Promise((resolve13) => execFile3("git", ["--version"], (err, stdout) => resolve13(err ? null : stdout.trim()))),
     hostConfigPaths: [defaultConfigPath(ctx.env), standaloneHostPaths(dataDir).configPath],
     readFile: (p) => existsSync13(p) ? readFileSync8(p, "utf8") : null
   };
@@ -17436,14 +17792,14 @@ function printDoctor(ctx, results) {
 // packages/cli/dist/commands/host.js
 import { existsSync as existsSync15, mkdirSync as mkdirSync9 } from "node:fs";
 import { hostname as hostname3 } from "node:os";
-import { dirname as dirname9, join as join16, resolve as resolve11 } from "node:path";
+import { dirname as dirname9, join as join17, resolve as resolve12 } from "node:path";
 import { DatabaseSync as DatabaseSync4 } from "node:sqlite";
 
 // packages/cli/dist/commands/service.js
 import { execFile as execFile4 } from "node:child_process";
 import { existsSync as existsSync14, mkdirSync as mkdirSync8, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { dirname as dirname8, join as join15 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+import { dirname as dirname8, join as join16, resolve as resolve11 } from "node:path";
 var LAUNCHD_LABEL = "com.switchyard.host";
 var SYSTEMD_UNIT = "switchyard-host.service";
 var TEMPLATES = {
@@ -17453,7 +17809,7 @@ var TEMPLATES = {
 <plist version="1.0">
 <dict>
   <key>Label</key>
-  <string>com.switchyard.host</string>
+  <string>{{LABEL}}</string>
   <key>ProgramArguments</key>
   <!-- Through zsh (every Mac has /bin/zsh) so the agent and the Pi sessions it starts get the
        environment ~/.zshenv sets for a terminal, like provider settings; PATH below is the base. -->
@@ -17467,6 +17823,8 @@ var TEMPLATES = {
     <string>run</string>
     <string>--config</string>
     <string>{{CONFIG}}</string>
+    <string>--state-dir</string>
+    <string>{{STATE_DIR}}</string>
   </array>
   <key>EnvironmentVariables</key>
   <dict>
@@ -17501,7 +17859,7 @@ Wants=network-online.target
 
 [Service]
 Type=simple
-ExecStart="{{NODE}}" "{{CLI}}" host run --config "{{CONFIG}}"
+ExecStart="{{NODE}}" "{{CLI}}" host run --config "{{CONFIG}}" --state-dir "{{STATE_DIR}}"
 Environment="PATH={{PATH}}"
 WorkingDirectory={{HOME}}
 Restart=on-failure
@@ -17514,8 +17872,8 @@ WantedBy=default.target
 `
 };
 var TEMPLATE_FILES = {
-  launchd: join15("launchd", `${LAUNCHD_LABEL}.plist`),
-  systemd: join15("systemd", SYSTEMD_UNIT)
+  launchd: join16("launchd", `${LAUNCHD_LABEL}.plist`),
+  systemd: join16("systemd", SYSTEMD_UNIT)
 };
 function xmlEscape(s) {
   return s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
@@ -17527,12 +17885,12 @@ function systemdEscape(s, exec = true) {
   return exec ? out.replaceAll("$", "$$$$") : out;
 }
 function loadTemplate(kind, dir = deployDir()) {
-  const p = join15(dir, TEMPLATE_FILES[kind]);
+  const p = join16(dir, TEMPLATE_FILES[kind]);
   return existsSync14(p) ? readFileSync9(p, "utf8") : TEMPLATES[kind];
 }
 function renderService(kind, vars, template = TEMPLATES[kind]) {
   for (const [k, v] of Object.entries(vars)) {
-    if (k !== "path" && !v.startsWith("/")) {
+    if (k !== "path" && k !== "label" && !v.startsWith("/")) {
       throw new CliError(`Service file needs an absolute ${k} path, got "${v}"`);
     }
   }
@@ -17540,7 +17898,7 @@ function renderService(kind, vars, template = TEMPLATES[kind]) {
   if (kind === "systemd" && /\s/.test(vars.home)) {
     throw new CliError("The home directory path contains whitespace; edit the unit by hand");
   }
-  return template.replaceAll("{{NODE}}", esc(vars.node)).replaceAll("{{CLI}}", esc(vars.cli)).replaceAll("{{CONFIG}}", esc(vars.config)).replaceAll("{{HOME}}", kind === "launchd" ? esc(vars.home) : vars.home).replaceAll("{{PATH}}", kind === "launchd" ? esc(vars.path) : systemdEscape(vars.path, false)).replaceAll("{{LOG_DIR}}", esc(vars.logDir));
+  return template.replaceAll("{{NODE}}", esc(vars.node)).replaceAll("{{CLI}}", esc(vars.cli)).replaceAll("{{LABEL}}", esc(vars.label)).replaceAll("{{CONFIG}}", esc(vars.config)).replaceAll("{{STATE_DIR}}", esc(vars.stateDir)).replaceAll("{{HOME}}", kind === "launchd" ? esc(vars.home) : vars.home).replaceAll("{{PATH}}", kind === "launchd" ? esc(vars.path) : systemdEscape(vars.path, false)).replaceAll("{{LOG_DIR}}", esc(vars.logDir));
 }
 function serviceKindFor(platform) {
   if (platform === "darwin")
@@ -17549,17 +17907,27 @@ function serviceKindFor(platform) {
     return "systemd";
   throw new CliError(`Service install is supported on macOS and Linux, not ${platform}`);
 }
-function serviceFilePath(kind, home = homedir5()) {
-  return kind === "launchd" ? join15(home, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`) : join15(home, ".config", "systemd", "user", SYSTEMD_UNIT);
+function serviceNames(instance) {
+  if (instance === void 0)
+    return { label: LAUNCHD_LABEL, unit: SYSTEMD_UNIT };
+  if (!/^[a-z0-9][a-z0-9-]{0,31}$/.test(instance)) {
+    throw new CliError("Instance names use lowercase letters, digits and dashes (at most 32)");
+  }
+  return { label: `${LAUNCHD_LABEL}.${instance}`, unit: `switchyard-host-${instance}.service` };
+}
+function serviceFilePath(kind, home = homedir6(), instance) {
+  const { label, unit } = serviceNames(instance);
+  return kind === "launchd" ? join16(home, "Library", "LaunchAgents", `${label}.plist`) : join16(home, ".config", "systemd", "user", unit);
 }
-function loadCommands(kind, file, uid) {
+function loadCommands(kind, file, uid, instance) {
+  const { label, unit } = serviceNames(instance);
   return kind === "launchd" ? [
-    ["launchctl", "bootout", `gui/${uid}/${LAUNCHD_LABEL}`],
+    ["launchctl", "bootout", `gui/${uid}/${label}`],
     ["launchctl", "bootstrap", `gui/${uid}`, file]
   ] : [
     ["systemctl", "--user", "daemon-reload"],
-    ["systemctl", "--user", "enable", "--now", SYSTEMD_UNIT],
-    ["systemctl", "--user", "restart", SYSTEMD_UNIT]
+    ["systemctl", "--user", "enable", "--now", unit],
+    ["systemctl", "--user", "restart", unit]
   ];
 }
 function stableNodePath(execPath, exists2 = existsSync14) {
@@ -17574,27 +17942,34 @@ function stableNodePath(execPath, exists2 = existsSync14) {
 function defaultInstallDeps() {
   return {
     platform: process.platform,
-    home: homedir5(),
+    home: homedir6(),
     uid: process.getuid?.() ?? 0,
-    run: (cmd) => new Promise((resolve12) => execFile4(cmd[0], cmd.slice(1), (err, stdout, stderr) => resolve12({ ok: !err, output: `${stdout}${stderr}`.trim() })))
+    run: (cmd) => new Promise((resolve13) => execFile4(cmd[0], cmd.slice(1), (err, stdout, stderr) => resolve13({ ok: !err, output: `${stdout}${stderr}`.trim() })))
   };
 }
 async function installService(ctx, flags, deps = defaultInstallDeps()) {
   const kind = serviceKindFor(deps.platform);
+  const names = serviceNames(flags.instance);
+  if (flags.instance !== void 0 && !(flags.config && flags.stateDir)) {
+    throw new CliError("--instance needs --config and --state-dir, so the second host agent keeps its own enrollment and state");
+  }
   const config = flags.config ?? defaultConfigPath(ctx.env, deps.home);
   if (!existsSync14(config) && !flags.print) {
     throw new CliError(`No host config at ${config}. Enroll first: switchyard host enroll --coordinator <url> --token <t>`);
   }
-  const logDir = join15(defaultStateDir(ctx.env, deps.platform, deps.home), "logs");
+  const stateDir = flags.stateDir ? resolve11(flags.stateDir) : defaultStateDir(ctx.env, deps.platform, deps.home);
+  const logDir = join16(stateDir, "logs");
   const content = renderService(kind, {
     node: stableNodePath(process.execPath),
     cli: cliEntry(),
     config,
+    stateDir,
+    label: names.label,
     home: deps.home,
     path: ctx.env.PATH ?? "/usr/local/bin:/usr/bin:/bin",
     logDir
   }, loadTemplate(kind));
-  const file = serviceFilePath(kind, deps.home);
+  const file = serviceFilePath(kind, deps.home, flags.instance);
   if (flags.print) {
     ctx.out(content.trimEnd());
     return { file, content };
@@ -17605,18 +17980,22 @@ async function installService(ctx, flags, deps = defaultInstallDeps()) {
   ctx.out(`Wrote ${file}`);
   if (flags.load === false) {
     ctx.out("Not loaded (--no-load). Load it with:");
-    for (const c of loadCommands(kind, file, deps.uid).slice(1))
+    for (const c of loadCommands(kind, file, deps.uid, flags.instance).slice(1))
       ctx.out(`  ${c.join(" ")}`);
     return { file, content };
   }
-  for (const cmd of loadCommands(kind, file, deps.uid)) {
+  for (const cmd of loadCommands(kind, file, deps.uid, flags.instance)) {
     ctx.out(`$ ${cmd.join(" ")}`);
-    const r = await deps.run(cmd);
+    let r = await deps.run(cmd);
+    for (let i = 0; !r.ok && cmd[1] === "bootstrap" && i < 10; i++) {
+      await new Promise((resolve13) => setTimeout(resolve13, deps.retryDelayMs ?? 500));
+      r = await deps.run(cmd);
+    }
     if (!r.ok && cmd[1] !== "bootout") {
       throw new CliError(`${cmd.join(" ")} failed${r.output ? `: ${r.output}` : ""}`);
     }
   }
-  ctx.out(`The host agent runs as ${kind === "launchd" ? LAUNCHD_LABEL : SYSTEMD_UNIT}; logs: ${logDir}`);
+  ctx.out(`The host agent runs as ${kind === "launchd" ? names.label : names.unit}; logs: ${logDir}`);
   return { file, content };
 }
 
@@ -17654,10 +18033,10 @@ async function hostRun(ctx, flags) {
 }
 function hostBackup(ctx, out, flags) {
   const stateDir = flags.stateDir ?? defaultStateDir(ctx.env);
-  const src = join16(stateDir, "host.db");
+  const src = join17(stateDir, "host.db");
   if (!existsSync15(src))
     throw new CliError(`No host database at ${src}`);
-  const dest = resolve11(out);
+  const dest = resolve12(out);
   if (existsSync15(dest))
     throw new CliError(`${dest} already exists`);
   mkdirSync9(dirname9(dest), { recursive: true });
@@ -17731,6 +18110,161 @@ async function hostStatus(ctx, flags) {
     ctx.out(`Service:      ${svc.installed ? `installed (${svc.file})` : "not installed"}`);
 }
 
+// packages/cli/dist/context.js
+function defaultCtx() {
+  return {
+    out: (l) => process.stdout.write(`${l}
+`),
+    err: (l) => process.stderr.write(`${l}
+`),
+    env: process.env,
+    fetch: (input, init2) => fetch(input, init2)
+  };
+}
+function connect(ctx, flags) {
+  const conn = resolveConnection(flags, ctx.env, ctx.paths);
+  return {
+    conn,
+    api: new ApiClient({ coordinatorUrl: conn.url, credential: conn.credential, fetch: ctx.fetch })
+  };
+}
+function table2(headers, rows) {
+  const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)));
+  const fmt = (cells) => cells.map((c, i) => i === cells.length - 1 ? c : c.padEnd(widths[i] ?? 0)).join("  ").trimEnd();
+  return [fmt(headers), ...rows.map(fmt)];
+}
+function printList(ctx, json, data, headers, rows, empty) {
+  if (json) {
+    ctx.out(JSON.stringify(data, null, 2));
+    return;
+  }
+  if (rows.length === 0) {
+    ctx.out(empty);
+    return;
+  }
+  for (const l of table2(headers, rows))
+    ctx.out(l);
+}
+function ago(iso, now = Date.now()) {
+  if (!iso)
+    return "-";
+  const s = Math.max(0, Math.round((now - Date.parse(iso)) / 1e3));
+  if (s < 60)
+    return `${s}s ago`;
+  if (s < 3600)
+    return `${Math.round(s / 60)}m ago`;
+  if (s < 86400)
+    return `${Math.round(s / 3600)}h ago`;
+  return `${Math.round(s / 86400)}d ago`;
+}
+
+// packages/cli/dist/commands/hosts.js
+async function resolveHost(api, ref) {
+  const hosts = (await api.get("/api/hosts")).filter((h) => !h.revokedAt);
+  const exact = hosts.find((h) => h.id === ref);
+  if (exact)
+    return exact;
+  const named = hosts.filter((h) => h.name.toLowerCase() === ref.toLowerCase());
+  if (named.length === 1)
+    return named[0];
+  if (named.length > 1)
+    throw new CliError(`Several hosts are named "${ref}"; use the id`);
+  const known = hosts.map((h) => `${h.name} (${h.id})`).join(", ") || "none";
+  throw new CliError(`Unknown host "${ref}". Hosts: ${known}`);
+}
+function scanLine(scan, now = Date.now()) {
+  if (!scan)
+    return ["Not scanned yet."];
+  if (scan.state === "running")
+    return [`Scanning since ${ago(scan.startedAt, now)}.`];
+  if (scan.state === "failed") {
+    return [
+      `Last scan failed ${ago(scan.finishedAt, now)}: ${scan.errors.at(-1) ?? "unknown error"}`
+    ];
+  }
+  return [
+    `Last scanned ${ago(scan.finishedAt, now)}: ${scan.repositories} repositories, ${scan.checkoutsAdded} new checkouts, ${scan.projectsCreated} new projects.`,
+    ...scan.errors.map((e) => `! ${e}`)
+  ];
+}
+async function hostsList(ctx, flags) {
+  const { api } = connect(ctx, flags);
+  const hosts = (await api.get("/api/hosts")).filter((h) => !h.revokedAt);
+  printList(ctx, flags.json, hosts, ["ID", "NAME", "STATUS", "AGENT", "PROJECT FOLDERS"], hosts.map((h) => [
+    h.id,
+    h.name,
+    h.connectivity,
+    h.agentVersion,
+    (h.projectFolders ?? []).join(", ") || "-"
+  ]), "No hosts.");
+}
+async function hostsFolders(ctx, ref, flags) {
+  const { api } = connect(ctx, flags);
+  const changing = !!(flags.set || flags.add || flags.remove || flags.clear);
+  if (flags.set && (flags.add || flags.remove || flags.clear) || flags.clear && (flags.add || flags.remove)) {
+    throw new CliError("Use --set or --clear on its own, or --add/--remove");
+  }
+  const host = await resolveHost(api, ref);
+  const current = host.projectFolders ?? [];
+  if (!changing) {
+    if (flags.json)
+      ctx.out(JSON.stringify(host, null, 2));
+    else {
+      if (current.length === 0)
+        ctx.out("No project folders.");
+      for (const f of current)
+        ctx.out(f);
+      for (const l of scanLine(host.projectScan))
+        ctx.out(l);
+    }
+    return host;
+  }
+  let next;
+  if (flags.set)
+    next = [...flags.set];
+  else if (flags.clear)
+    next = [];
+  else {
+    next = [...current];
+    for (const f of flags.remove ?? []) {
+      if (!next.includes(f))
+        throw new CliError(`${f} is not a project folder of ${host.name}`);
+      next = next.filter((x) => x !== f);
+    }
+    for (const f of flags.add ?? [])
+      if (!next.includes(f))
+        next.push(f);
+  }
+  const updated = await api.request("PATCH", `/api/hosts/${encodeURIComponent(host.id)}`, {
+    projectFolders: next
+  });
+  if (flags.json) {
+    ctx.out(JSON.stringify(updated, null, 2));
+    return updated;
+  }
+  const folders = updated.projectFolders ?? [];
+  ctx.out(`Project folders on ${updated.name}: ${folders.join(", ") || "none"}`);
+  if (folders.length > 0 && updated.connectivity === "connected") {
+    ctx.out(`Scanning in the background; \`switchyard hosts scan ${updated.name}\` waits for the result.`);
+  }
+  return updated;
+}
+async function hostsScan(ctx, ref, flags) {
+  const { api } = connect(ctx, flags);
+  const host = await resolveHost(api, ref);
+  const r = await api.post(`/api/hosts/${encodeURIComponent(host.id)}/scan-projects`);
+  if (flags.json) {
+    ctx.out(JSON.stringify(r, null, 2));
+    return r;
+  }
+  ctx.out(`Scanned ${host.name}: ${r.repositories} repositories, ${r.checkoutsAdded} new checkouts, ${r.projectsCreated} new projects`);
+  for (const a of r.added)
+    ctx.out(`+ ${a.name}  ${a.path}${a.newProject ? " (new project)" : ""}`);
+  for (const e of r.errors)
+    ctx.out(`! ${e}`);
+  return r;
+}
+
 // packages/cli/dist/commands/up.js
 import { spawn as spawn3 } from "node:child_process";
 import { existsSync as existsSync16 } from "node:fs";
@@ -17861,54 +18395,6 @@ async function up(ctx, flags) {
   await s.stop();
 }
 
-// packages/cli/dist/context.js
-function defaultCtx() {
-  return {
-    out: (l) => process.stdout.write(`${l}
-`),
-    err: (l) => process.stderr.write(`${l}
-`),
-    env: process.env,
-    fetch: (input, init2) => fetch(input, init2)
-  };
-}
-function connect(ctx, flags) {
-  const conn = resolveConnection(flags, ctx.env, ctx.paths);
-  return {
-    conn,
-    api: new ApiClient({ coordinatorUrl: conn.url, credential: conn.credential, fetch: ctx.fetch })
-  };
-}
-function table2(headers, rows) {
-  const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)));
-  const fmt = (cells) => cells.map((c, i) => i === cells.length - 1 ? c : c.padEnd(widths[i] ?? 0)).join("  ").trimEnd();
-  return [fmt(headers), ...rows.map(fmt)];
-}
-function printList(ctx, json, data, headers, rows, empty) {
-  if (json) {
-    ctx.out(JSON.stringify(data, null, 2));
-    return;
-  }
-  if (rows.length === 0) {
-    ctx.out(empty);
-    return;
-  }
-  for (const l of table2(headers, rows))
-    ctx.out(l);
-}
-function ago(iso, now = Date.now()) {
-  if (!iso)
-    return "-";
-  const s = Math.max(0, Math.round((now - Date.parse(iso)) / 1e3));
-  if (s < 60)
-    return `${s}s ago`;
-  if (s < 3600)
-    return `${Math.round(s / 60)}m ago`;
-  if (s < 86400)
-    return `${Math.round(s / 3600)}h ago`;
-  return `${Math.round(s / 86400)}d ago`;
-}
-
 // packages/cli/dist/commands/work.js
 function byId2(list) {
   return new Map(list.map((x) => [x.id, x]));
@@ -18111,7 +18597,7 @@ function buildProgram(ctx = defaultCtx()) {
   const host = program.command("host").description("Host agent on this machine");
   host.command("enroll").description("Enroll this machine as a host (writes ~/.config/switchyard/host.json)").requiredOption("--coordinator <url>", "coordinator URL").option("--token <token>", "host enrollment token (switchyard pair --host)").option("--secret <secret>", "shared host enrollment secret (SWITCHYARD_HOST_ENROLL_SECRET)").option("--name <name>", "host name (default: hostname)").option("--config <path>", "host.json path").action((o) => hostEnroll(ctx, o));
   host.command("run").description("Run the host agent in the foreground (waits for host.json when not enrolled)").option("--config <path>", "host.json path (env SWITCHYARD_HOST_CONFIG)").option("--state-dir <dir>", "state dir (env SWITCHYARD_STATE_DIR)").action((o) => hostRun(ctx, o));
-  host.command("install-service").description("Install the host agent as a launchd agent (macOS) or systemd user unit (Linux)").option("--config <path>", "host.json path").option("--print", "print the service file without writing it").option("--no-load", "write the file but do not load it").action(async (o) => {
+  host.command("install-service").description("Install the host agent as a launchd agent (macOS) or systemd user unit (Linux)").option("--config <path>", "host.json path").option("--state-dir <dir>", "state dir (default: the platform default)").option("--instance <name>", "run a second host agent beside the default one, e.g. dev; needs --config and --state-dir").option("--print", "print the service file without writing it").option("--no-load", "write the file but do not load it").action(async (o) => {
     await installService(ctx, o);
   });
   host.command("backup <out>").description("Consistent backup of the host database").option("--state-dir <dir>", "state dir (env SWITCHYARD_STATE_DIR)").action((out, o) => hostBackup(ctx, out, o));
@@ -18131,6 +18617,21 @@ function buildProgram(ctx = defaultCtx()) {
     if (code !== 0)
       throw new CliError("doctor found failures", code);
   });
+  const hosts = program.command("hosts").description("Hosts and their project folders");
+  connectionOptions(hosts.command("list").description("List hosts")).option("--json", "JSON output").action((o) => hostsList(ctx, { ...connFlags(o), json: o.json }));
+  connectionOptions(hosts.command("folders <host>").description("Show or change a host's project folders (absolute or ~/... on the host; quote ~ so your shell does not expand it)")).option("--set <folder...>", "replace the folders").option("--add <folder...>", "add folders").option("--remove <folder...>", "remove folders").option("--clear", "remove every folder").option("--json", "JSON output").action(async (ref, o) => {
+    await hostsFolders(ctx, ref, {
+      ...connFlags(o),
+      set: o.set,
+      add: o.add,
+      remove: o.remove,
+      clear: o.clear,
+      json: o.json
+    });
+  });
+  connectionOptions(hosts.command("scan <host>").description("Scan a host's project folders now and add new repositories as projects")).option("--json", "JSON output").action(async (ref, o) => {
+    await hostsScan(ctx, ref, { ...connFlags(o), json: o.json });
+  });
   const sessions = program.command("sessions").description("Sessions");
   connectionOptions(sessions.command("list").description("List sessions")).option("--project <project>", "project id or name").option("--json", "JSON output").action((o) => sessionsList(ctx, { ...connFlags(o), json: o.json, project: o.project }));
   connectionOptions(sessions.command("import <sessionFile>").description("Import an inactive Pi session file from a host")).option("--host <hostId>", "host holding the file (default: the only host)").option("--project <project>", "project id or name").option("--json", "JSON output").action(async (file, o) => {