@spencerboucher/switchyard 0.7.0 → 0.8.0

package/dist/switchyard.mjs

@@ -380,7 +380,8 @@ var SessionModel = z3.object({
 var SlashCommand = z3.object({
   name: z3.string().min(1),
   description: z3.string().nullable(),
-  source: z3.enum(["extension", "prompt", "skill"])
+  source: z3.enum(["extension", "prompt", "skill"]),
+  argumentHint: z3.string().nullable().optional()
 });
 var ContextUsage = z3.object({
   /** Estimated tokens in context; null right after compaction until the next reply. */
@@ -921,6 +922,51 @@ var SetThinkingRequest = z4.object({ level: ThinkingLevel });
 var CompactRequest = z4.object({ instructions: z4.string().max(4e3).optional() });
 var SessionModelsResult = z4.object({ models: z4.array(SessionModel) });
 var SessionCommandsResult = z4.object({ commands: z4.array(SlashCommand) });
+var CompleteRequest = z4.object({ text: z4.string().min(1).max(500) });
+var CompletionItem = z4.object({
+  value: z4.string(),
+  label: z4.string(),
+  description: z4.string().nullable()
+});
+var SessionCompleteResult = z4.object({
+  items: z4.array(CompletionItem).max(50),
+  prefix: z4.string()
+});
+var TreeRow = z4.object({
+  entryId: z4.string(),
+  parentId: z4.string().nullable(),
+  depth: z4.number().int(),
+  role: z4.enum(["user", "assistant"]),
+  text: z4.string(),
+  activeBranch: z4.boolean(),
+  leaf: z4.boolean(),
+  label: z4.string().nullable(),
+  at: z4.string().nullable()
+});
+var SessionTreeResult = z4.object({ rows: z4.array(TreeRow) });
+var BranchRequest = z4.object({
+  entryId: z4.string().nullable(),
+  fork: z4.boolean().default(false)
+});
+var HostBranchResult = z4.object({
+  sessionFile: z4.string().nullable(),
+  prefill: z4.string().nullable()
+});
+var BranchResult = z4.object({
+  session: Session.nullable(),
+  prefill: z4.string().nullable()
+});
+var SessionExportResult = z4.object({ fileName: z4.string(), content: z4.string() });
+var CommandViewAction = z4.object({
+  label: z4.string().min(1).max(80),
+  command: z4.string().startsWith("/").max(500),
+  tone: z4.enum(["default", "primary", "danger"]).optional()
+});
+var CommandView = z4.object({
+  title: z4.string().min(1).max(200),
+  body: UINodeSchema,
+  actions: z4.array(CommandViewAction).max(30).default([])
+});
 var ModelStateResult = z4.object({
   model: SessionModel.nullable(),
   thinking: ThinkingLevel.nullable()
@@ -1321,6 +1367,20 @@ var HostCommand = z8.discriminatedUnion("type", [
   z8.object({ type: z8.literal("session.snapshot"), sessionId: z8.string() }),
   z8.object({ type: z8.literal("session.models"), sessionId: z8.string() }),
   z8.object({ type: z8.literal("session.commands"), sessionId: z8.string() }),
+  z8.object({
+    type: z8.literal("session.complete"),
+    sessionId: z8.string(),
+    text: z8.string().max(500)
+  }),
+  z8.object({ type: z8.literal("session.tree"), sessionId: z8.string() }),
+  z8.object({
+    type: z8.literal("session.branch"),
+    sessionId: z8.string(),
+    entryId: z8.string().nullable(),
+    fork: z8.boolean()
+  }),
+  z8.object({ type: z8.literal("session.reload"), sessionId: z8.string() }),
+  z8.object({ type: z8.literal("session.export"), sessionId: z8.string() }),
   z8.object({
     type: z8.literal("session.setModel"),
     sessionId: z8.string(),
@@ -2505,7 +2565,7 @@ function trimUrl(url) {
 
 // packages/cli/dist/commands/up.js
 import { spawn as spawn4 } from "node:child_process";
-import { existsSync as existsSync14 } from "node:fs";
+import { existsSync as existsSync15 } from "node:fs";
 import { hostname as hostname2 } from "node:os";
 
 // packages/coordinator/dist/attention/router.js
@@ -9361,49 +9421,20 @@ function registerSessionRoutes(app, ctx) {
       where.push("archived_at IS NULL");
     return ctx.store.sessions.list(where.join(" AND ") || void 0, params, "last_activity_at DESC");
   });
-  app.get("/api/sessions/importable", async (req) => {
-    const q = parse(ImportableQuery, req.query, "query");
-    requireConnected(ctx, q.hostId);
-    const list = normalizeImportable(await ctx.hostHub.request(q.hostId, { type: "session.importable" }));
-    return list.map((s) => ({
-      ...s,
-      importedSessionId: ctx.store.sessionByNativeFile(q.hostId, s.sessionFile)?.id ?? null
-    }));
-  });
-  app.post("/api/sessions/import", async (req, reply) => {
-    const body = parse(ImportSessionRequest, req.body);
-    requireConnected(ctx, body.hostId);
-    const already = ctx.store.sessionByNativeFile(body.hostId, body.sessionFile);
-    if (already) {
-      throw new SwitchyardError("conflict", "This Pi session was already imported", {
-        sessionId: already.id
-      });
-    }
-    const list = normalizeImportable(await ctx.hostHub.request(body.hostId, { type: "session.importable" }));
-    const native = list.find((s) => s.sessionFile === body.sessionFile);
-    if (!native)
-      throw new SwitchyardError("not_found", "Pi session file not found on host");
-    if (!native.inactive) {
-      throw new SwitchyardError("conflict", "This Pi session is still active; close it in Pi before importing");
-    }
-    const rawItems = await ctx.hostHub.request(body.hostId, {
-      type: "session.readNative",
-      sessionFile: body.sessionFile
-    });
-    const ws = ctx.store.workspaceByPath(body.hostId, native.cwd);
-    const projectId = body.projectId ?? ws?.projectId ?? null;
+  function importNative(native, hostId, projectIdIn, items) {
+    const ws = ctx.store.workspaceByPath(hostId, native.cwd);
+    const projectId = projectIdIn ?? ws?.projectId ?? null;
     if (projectId)
       ctx.store.projects.require(projectId);
     const project = projectId ? ctx.store.projects.get(projectId) : null;
-    const host = ctx.store.hosts.require(body.hostId);
+    const host = ctx.store.hosts.require(hostId);
     const now = ctx.store.nowIso();
     const id = newId("ses");
-    const items = Array.isArray(rawItems) ? rawItems : rawItems?.items ?? [];
     const session = {
       id,
       title: native.name ?? native.cwd.split("/").pop() ?? "Imported session",
       subtitle: null,
-      hostId: body.hostId,
+      hostId,
       workspaceId: ws && ws.projectId === projectId ? ws.id : null,
       projectId,
       cwd: native.cwd,
@@ -9437,6 +9468,39 @@ function registerSessionRoutes(app, ctx) {
           ctx.store.upsertItem(item.data);
       });
     });
+    return session;
+  }
+  app.get("/api/sessions/importable", async (req) => {
+    const q = parse(ImportableQuery, req.query, "query");
+    requireConnected(ctx, q.hostId);
+    const list = normalizeImportable(await ctx.hostHub.request(q.hostId, { type: "session.importable" }));
+    return list.map((s) => ({
+      ...s,
+      importedSessionId: ctx.store.sessionByNativeFile(q.hostId, s.sessionFile)?.id ?? null
+    }));
+  });
+  app.post("/api/sessions/import", async (req, reply) => {
+    const body = parse(ImportSessionRequest, req.body);
+    requireConnected(ctx, body.hostId);
+    const already = ctx.store.sessionByNativeFile(body.hostId, body.sessionFile);
+    if (already) {
+      throw new SwitchyardError("conflict", "This Pi session was already imported", {
+        sessionId: already.id
+      });
+    }
+    const list = normalizeImportable(await ctx.hostHub.request(body.hostId, { type: "session.importable" }));
+    const native = list.find((s) => s.sessionFile === body.sessionFile);
+    if (!native)
+      throw new SwitchyardError("not_found", "Pi session file not found on host");
+    if (!native.inactive) {
+      throw new SwitchyardError("conflict", "This Pi session is still active; close it in Pi before importing");
+    }
+    const rawItems = await ctx.hostHub.request(body.hostId, {
+      type: "session.readNative",
+      sessionFile: body.sessionFile
+    });
+    const items = Array.isArray(rawItems) ? rawItems : rawItems?.items ?? [];
+    const session = importNative(native, body.hostId, body.projectId ?? null, items);
     return reply.code(201).send(session);
   });
   app.get("/api/sessions/:id", async (req) => get(idOf(req)));
@@ -9458,9 +9522,15 @@ function registerSessionRoutes(app, ctx) {
     return ctx.hostHub.request(s.hostId, { type: "session.snapshot", sessionId: s.id });
   });
   app.post("/api/sessions/:id/prompt", async (req) => {
-    const s = get(idOf(req));
+    let s = get(idOf(req));
     const body = parse(PromptRequest, req.body);
-    requireLiveSession(ctx, s);
+    if (!s.readOnly && !s.archivedAt && s.nativeHandle && !LIVE_RUNTIMES2.includes(s.runtime) && body.mode === "prompt") {
+      await resumeSession(s);
+      s = get(s.id);
+      requireConnected(ctx, s.hostId);
+    } else {
+      requireLiveSession(ctx, s);
+    }
     const run = ctx.store.runForSession(s);
     const result = await ctx.hostHub.request(s.hostId, {
       type: "session.prompt",
@@ -9471,6 +9541,9 @@ function registerSessionRoutes(app, ctx) {
       origin: "human",
       controlRevision: run?.controlRevision ?? 1
     });
+    const view = result?.view;
+    if (view)
+      CommandView.parse(view);
     return {
       ok: true,
       clientMessageId: body.clientMessageId ?? null,
@@ -9488,6 +9561,54 @@ function registerSessionRoutes(app, ctx) {
     requireSessionControls(ctx, s);
     return SessionCommandsResult.parse(await ctx.hostHub.request(s.hostId, { type: "session.commands", sessionId: s.id }));
   });
+  app.post("/api/sessions/:id/complete", async (req) => {
+    const s = get(idOf(req));
+    const body = parse(CompleteRequest, req.body);
+    requireSessionControls(ctx, s);
+    return SessionCompleteResult.parse(await ctx.hostHub.request(s.hostId, {
+      type: "session.complete",
+      sessionId: s.id,
+      text: body.text
+    }));
+  });
+  app.get("/api/sessions/:id/tree", async (req) => {
+    const s = get(idOf(req));
+    requireSessionControls(ctx, s);
+    return SessionTreeResult.parse(await ctx.hostHub.request(s.hostId, { type: "session.tree", sessionId: s.id }));
+  });
+  app.post("/api/sessions/:id/branch", async (req, reply) => {
+    const s = get(idOf(req));
+    const body = parse(BranchRequest, req.body);
+    requireSessionControls(ctx, s);
+    const r = HostBranchResult.parse(await ctx.hostHub.request(s.hostId, {
+      type: "session.branch",
+      sessionId: s.id,
+      entryId: body.entryId,
+      fork: body.fork
+    }));
+    if (!r.sessionFile)
+      return { session: null, prefill: r.prefill };
+    const native = await ctx.hostHub.request(s.hostId, { type: "session.readNative", sessionFile: r.sessionFile });
+    const session = importNative({
+      sessionId: native.sessionId,
+      sessionFile: r.sessionFile,
+      cwd: native.cwd,
+      name: `${native.name ?? s.title} (branch)`,
+      mtime: ctx.store.nowIso()
+    }, s.hostId, s.projectId, native.items ?? []);
+    return reply.code(201).send({ session, prefill: r.prefill });
+  });
+  app.post("/api/sessions/:id/reload", async (req) => {
+    const s = get(idOf(req));
+    requireSessionControls(ctx, s);
+    await ctx.hostHub.request(s.hostId, { type: "session.reload", sessionId: s.id });
+    return { ok: true };
+  });
+  app.get("/api/sessions/:id/export", async (req) => {
+    const s = get(idOf(req));
+    requireSessionControls(ctx, s);
+    return SessionExportResult.parse(await ctx.hostHub.request(s.hostId, { type: "session.export", sessionId: s.id }));
+  });
   app.post("/api/sessions/:id/model", async (req) => {
     const s = get(idOf(req));
     const body = parse(SetModelRequest, req.body);
@@ -9543,8 +9664,7 @@ function registerSessionRoutes(app, ctx) {
   });
   app.post("/api/sessions/:id/takeover", async (req) => takeover(ctx, idOf(req)));
   app.post("/api/sessions/:id/return-to-automation", async (req) => returnToAutomation(ctx, idOf(req)));
-  app.post("/api/sessions/:id/resume", async (req) => {
-    const s = get(idOf(req));
+  async function resumeSession(s) {
     if (!s.nativeHandle) {
       throw new SwitchyardError("native_session_missing", "This session has no native Pi session to resume");
     }
@@ -9577,6 +9697,10 @@ function registerSessionRoutes(app, ctx) {
       });
       throw err;
     }
+  }
+  app.post("/api/sessions/:id/resume", async (req) => {
+    const s = get(idOf(req));
+    await resumeSession(s);
     return get(s.id);
   });
   app.post("/api/sessions/:id/rename", async (req) => {
@@ -12807,7 +12931,7 @@ function toErrorBody(err) {
 function queueKey(command) {
   if (command.type === "checks.run")
     return `checks:${command.sessionId}`;
-  if (command.type === "session.answer" || command.type === "session.abort" || command.type === "session.setControl" || command.type === "session.adapterAction" || command.type === "session.snapshot" || command.type === "session.models" || command.type === "session.commands") {
+  if (command.type === "session.answer" || command.type === "session.abort" || command.type === "session.setControl" || command.type === "session.adapterAction" || command.type === "session.snapshot" || command.type === "session.models" || command.type === "session.commands" || command.type === "session.complete" || command.type === "session.tree" || command.type === "session.export" || command.type === "session.reload") {
     return `control:${command.sessionId}`;
   }
   if ("sessionId" in command && typeof command.sessionId === "string") {
@@ -12966,6 +13090,16 @@ var CommandRouter = class {
         return sup.models(c.sessionId);
       case "session.commands":
         return sup.commands(c.sessionId);
+      case "session.complete":
+        return sup.complete(c.sessionId, c.text);
+      case "session.tree":
+        return sup.tree(c.sessionId);
+      case "session.branch":
+        return sup.branch(c.sessionId, c.entryId, c.fork);
+      case "session.reload":
+        return sup.reload(c.sessionId);
+      case "session.export":
+        return sup.exportSession(c.sessionId);
       case "session.setModel":
         return sup.setModel(c.sessionId, c.provider, c.modelId);
       case "session.setThinking":
@@ -14568,18 +14702,121 @@ function writeJsonl(stream, value) {
   });
 }
 
+// packages/pi-runtime/dist/pi-session-manager.js
+import { existsSync as existsSync9 } from "node:fs";
+import { dirname as dirname8, join as join14 } from "node:path";
+import { pathToFileURL as pathToFileURL3 } from "node:url";
+var managerPromise = null;
+function loadPiSessionManager(piBin = "pi") {
+  managerPromise ??= (async () => {
+    const root = resolvePiPackageRoot(piBin);
+    if (!root)
+      return null;
+    try {
+      const mod = await import(pathToFileURL3(join14(root, "dist", "index.js")).href);
+      return mod.SessionManager ?? null;
+    } catch {
+      return null;
+    }
+  })();
+  return managerPromise;
+}
+function messageText(message) {
+  const c = message?.content;
+  if (typeof c === "string")
+    return c;
+  if (!Array.isArray(c))
+    return "";
+  return c.filter((p) => p?.type === "text" && typeof p.text === "string").map((p) => p.text).join(" ");
+}
+var MAX_ROWS = 2e3;
+function treeRows(sm) {
+  const active = new Set((sm.getBranch() ?? []).map((e) => e.id));
+  const leafId = sm.getLeafId?.() ?? null;
+  const rows = [];
+  const walk = (nodes, depth, parentId) => {
+    for (const node of nodes) {
+      if (rows.length >= MAX_ROWS)
+        return;
+      const entry = node.entry;
+      const role = entry?.message?.role;
+      const shown = entry?.type === "message" && (role === "user" || role === "assistant");
+      if (shown) {
+        const raw = messageText(entry.message).replace(/\s+/g, " ").trim();
+        const text = raw ? raw.slice(0, 160) : role === "assistant" ? "(tool calls)" : "";
+        rows.push({
+          entryId: entry.id,
+          parentId,
+          depth,
+          role,
+          text,
+          activeBranch: active.has(entry.id),
+          leaf: entry.id === leafId,
+          label: node.label ?? null,
+          at: typeof entry.timestamp === "string" ? entry.timestamp : null
+        });
+        walk(node.children ?? [], depth + 1, entry.id);
+      } else {
+        walk(node.children ?? [], depth, parentId);
+      }
+    }
+  };
+  walk(sm.getTree() ?? [], 0, null);
+  if (!rows.some((r) => r.leaf)) {
+    const last = [...rows].reverse().find((r) => r.activeBranch);
+    if (last)
+      last.leaf = true;
+  }
+  return rows;
+}
+async function branchSession(sessionFile, entryId, fork, piBin, load = loadPiSessionManager, checkFile = true) {
+  const SM = await load(piBin);
+  if (!SM) {
+    throw new SwitchyardError("invalid_request", "Pi's SessionManager could not be loaded on this host");
+  }
+  const sm = SM.open(sessionFile, dirname8(sessionFile));
+  let target;
+  let prefill = null;
+  if (fork) {
+    const e = entryId ? sm.getEntry(entryId) : void 0;
+    if (!e || e.type !== "message" || e.message?.role !== "user") {
+      throw new SwitchyardError("invalid_request", "Pick one of your messages to fork from");
+    }
+    prefill = messageText(e.message);
+    target = e.parentId ?? null;
+    if (!target)
+      return { sessionFile: null, prefill };
+  } else {
+    target = entryId ?? sm.getLeafId();
+    if (!target) {
+      throw new SwitchyardError("invalid_request", "This session has nothing to branch yet");
+    }
+  }
+  const hasMessages = (sm.getBranch(target) ?? []).some((e) => e?.type === "message" && (e.message?.role === "user" || e.message?.role === "assistant"));
+  if (!hasMessages) {
+    if (fork)
+      return { sessionFile: null, prefill };
+    throw new SwitchyardError("invalid_request", "There is no conversation before that point");
+  }
+  const file = sm.createBranchedSession(target);
+  if (!file || checkFile && !existsSync9(file)) {
+    throw new SwitchyardError("invalid_request", "Pi did not write a branched session");
+  }
+  return { sessionFile: file, prefill };
+}
+
 // packages/pi-runtime/dist/rpc-process.js
 import { spawn as spawn2 } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { EventEmitter as EventEmitter3 } from "node:events";
-import { chmodSync as chmodSync4, existsSync as existsSync9, mkdirSync as mkdirSync6, rmSync as rmSync2 } from "node:fs";
+import { chmodSync as chmodSync4, existsSync as existsSync10, mkdirSync as mkdirSync6, rmSync as rmSync2 } from "node:fs";
 import { createServer } from "node:net";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function bridgeExtensionPath() {
   const sibling = fileURLToPath2(new URL("./bridge/switchyard-bridge.js", import.meta.url));
-  if (existsSync9(sibling))
+  if (existsSync10(sibling))
     return sibling;
   return fileURLToPath2(new URL("../dist/bridge/switchyard-bridge.js", import.meta.url));
 }
@@ -14595,11 +14832,11 @@ var MAX_SOCKET_PATH = 100;
 function shortSocketPath(runtimeDir, prefix) {
   const name = `${prefix}-${randomUUID().slice(0, 8)}.sock`;
   let dir = runtimeDir;
-  if (join14(dir, name).length > MAX_SOCKET_PATH) {
-    dir = join14("/tmp", `switchyard-${process.getuid?.() ?? "u"}`);
+  if (join15(dir, name).length > MAX_SOCKET_PATH) {
+    dir = join15("/tmp", `switchyard-${process.getuid?.() ?? "u"}`);
   }
   mkdirSync6(dir, { recursive: true, mode: 448 });
-  return join14(dir, name);
+  return join15(dir, name);
 }
 var PiRpcProcess = class _PiRpcProcess extends EventEmitter3 {
   child;
@@ -14652,7 +14889,7 @@ var PiRpcProcess = class _PiRpcProcess extends EventEmitter3 {
     let proc = null;
     const early = [];
     if (useBridge) {
-      socketPath = shortSocketPath(opts.runtimeDir ?? join14(tmpdir2(), "switchyard"), "bridge");
+      socketPath = shortSocketPath(opts.runtimeDir ?? join15(tmpdir2(), "switchyard"), "bridge");
       server = createServer((socket) => {
         if (proc)
           proc.attachBridgeSocket(socket);
@@ -14837,20 +15074,52 @@ var PiRpcProcess = class _PiRpcProcess extends EventEmitter3 {
 // packages/pi-runtime/dist/session-runtime.js
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { EventEmitter as EventEmitter5 } from "node:events";
-import { existsSync as existsSync11 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
+
+// packages/pi-runtime/dist/command-hints.js
+import { readFile as readFile7 } from "node:fs/promises";
+function parseArgumentHint(markdown) {
+  const lines = markdown.split(/\r?\n/);
+  if (lines[0] !== "---")
+    return null;
+  const end = lines.indexOf("---", 1);
+  if (end < 0)
+    return null;
+  for (const line of lines.slice(1, end)) {
+    const m = /^argument-hint:\s*(.*)$/.exec(line);
+    if (!m)
+      continue;
+    let value = (m[1] ?? "").trim();
+    const q = value[0];
+    if (value.length >= 2 && (q === '"' || q === "'") && value.endsWith(q)) {
+      value = value.slice(1, -1).trim();
+    }
+    return value ? value.slice(0, 80) : null;
+  }
+  return null;
+}
+async function readArgumentHint(path) {
+  if (!path.endsWith(".md"))
+    return null;
+  try {
+    return parseArgumentHint(await readFile7(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
 
 // packages/pi-runtime/dist/terminal-process.js
 import { spawn as spawn3 } from "node:child_process";
 import { EventEmitter as EventEmitter4 } from "node:events";
-import { closeSync, existsSync as existsSync10, mkdirSync as mkdirSync7, openSync, readFileSync as readFileSync7 } from "node:fs";
+import { closeSync, existsSync as existsSync11, mkdirSync as mkdirSync7, openSync, readFileSync as readFileSync7 } from "node:fs";
 import { createRequire } from "node:module";
 import { createConnection } from "node:net";
 import { tmpdir as tmpdir3 } from "node:os";
-import { basename as basename2, dirname as dirname8, join as join15 } from "node:path";
+import { basename as basename2, dirname as dirname9, join as join16 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function resolveDist(rel) {
   const sibling = fileURLToPath3(new URL(`./${rel}`, import.meta.url));
-  if (existsSync10(sibling))
+  if (existsSync11(sibling))
     return sibling;
   return fileURLToPath3(new URL(`../dist/${rel}`, import.meta.url));
 }
@@ -14867,7 +15136,7 @@ function terminalSupport() {
     return { ok: false, reason: `node-pty is not available: ${err.message}` };
   }
   const holder = holderScriptPath();
-  if (!existsSync10(holder))
+  if (!existsSync11(holder))
     return { ok: false, reason: `Terminal holder not built: ${holder}` };
   return { ok: true };
 }
@@ -14932,7 +15201,7 @@ var PiTerminalProcess = class _PiTerminalProcess extends EventEmitter4 {
   }
   /** Start a holder running interactive Pi and attach to it. */
   static async start(opts) {
-    const runtimeDir = opts.runtimeDir ?? join15(tmpdir3(), "switchyard");
+    const runtimeDir = opts.runtimeDir ?? join16(tmpdir3(), "switchyard");
     const socketPath = shortSocketPath(runtimeDir, "term");
     const env = {};
     for (const [k, v] of Object.entries({ ...process.env, ...opts.env ?? {} })) {
@@ -14953,8 +15222,8 @@ var PiTerminalProcess = class _PiTerminalProcess extends EventEmitter4 {
       cols: opts.cols ?? 120,
       rows: opts.rows ?? 40
     };
-    const logPath = opts.logPath ?? join15(dirname8(socketPath), `${basename2(socketPath, ".sock")}.log`);
-    mkdirSync7(dirname8(logPath), { recursive: true, mode: 448 });
+    const logPath = opts.logPath ?? join16(dirname9(socketPath), `${basename2(socketPath, ".sock")}.log`);
+    mkdirSync7(dirname9(logPath), { recursive: true, mode: 448 });
     const fd = openSync(logPath, "a", 384);
     try {
       const child = spawn3(process.execPath, [holderScriptPath()], {
@@ -15287,7 +15556,7 @@ var ManagedSession = class _ManagedSession extends EventEmitter5 {
       await this.attachTerminal(this.opts.terminalSocket);
       return;
     }
-    if (this._native && !existsSync11(this._native.sessionFile)) {
+    if (this._native && !existsSync12(this._native.sessionFile)) {
       const message = `Native session file not found: ${this._native.sessionFile}`;
       this.fail(message);
       throw new SwitchyardError("native_session_missing", message, {
@@ -15414,7 +15683,22 @@ var ManagedSession = class _ManagedSession extends EventEmitter5 {
     } else {
       data = await this.call(proc, { type: "follow_up", ...body });
     }
-    return data?.disposition ?? "started";
+    if (data?.disposition === "view") {
+      const view = CommandView.safeParse(data.view);
+      if (!view.success) {
+        throw new SwitchyardError("invalid_request", "The command returned an invalid view");
+      }
+      return { disposition: "view", view: view.data };
+    }
+    return { disposition: data?.disposition ?? "started", view: null };
+  }
+  /** Reload Pi's extensions, skills, prompts and context files (terminal sessions only). */
+  async reload() {
+    const proc = this.requireAlive();
+    if (!(proc instanceof PiTerminalProcess)) {
+      throw new SwitchyardError("invalid_request", "Reload needs a terminal session");
+    }
+    await this.call(proc, { type: "reload" }, 1e4);
   }
   /** Abort the current run; with `clearQueue`, first clear and return queued messages. */
   async abort(clearQueue = false) {
@@ -15466,19 +15750,36 @@ var ManagedSession = class _ManagedSession extends EventEmitter5 {
       type: "get_commands"
     });
     const out = [];
+    const hints = [];
     for (const c of data?.commands ?? []) {
       if (typeof c?.name !== "string" || !c.name)
         continue;
       if (c.source !== "extension" && c.source !== "prompt" && c.source !== "skill")
         continue;
-      out.push({
+      const entry = {
         name: c.name,
         description: typeof c.description === "string" ? c.description : null,
-        source: c.source
-      });
+        source: c.source,
+        argumentHint: null
+      };
+      if (c.source === "prompt" && typeof c.sourceInfo?.path === "string") {
+        hints.push(readArgumentHint(c.sourceInfo.path).then((h) => {
+          entry.argumentHint = h;
+        }));
+      }
+      out.push(entry);
     }
+    await Promise.all(hints);
     return out.sort((a, b) => a.name.localeCompare(b.name));
   }
+  /** Pi's argument completions for a draft such as `/model cl` (terminal sessions only). */
+  async complete(text) {
+    const proc = this.requireAlive();
+    if (!(proc instanceof PiTerminalProcess))
+      return { items: [], prefix: "" };
+    const data = await this.call(proc, { type: "complete", text }, 5e3);
+    return SessionCompleteResult.parse({ items: data?.items ?? [], prefix: data?.prefix ?? "" });
+  }
   async setModel(provider, modelId) {
     await this.call(this.requireAlive(), { type: "set_model", provider, modelId });
     await this.refreshModelState();
@@ -16077,8 +16378,9 @@ ${output}`.trimEnd() }));
 };
 
 // packages/host-agent/dist/supervisor.js
-import { existsSync as existsSync12, realpathSync as realpathSync2, statSync } from "node:fs";
-import { join as join16, sep as sep3 } from "node:path";
+import { existsSync as existsSync13, realpathSync as realpathSync2, statSync } from "node:fs";
+import { readFile as readFile8, stat as stat5 } from "node:fs/promises";
+import { basename as basename3, dirname as dirname10, join as join17, 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)";
@@ -16419,7 +16721,7 @@ var SessionSupervisor = class {
     if (!pi.compatible) {
       throw new SwitchyardError("pi_incompatible", pi.reason ?? "Pi is not available on this host");
     }
-    if (!existsSync12(p.workspacePath) || !statSync(p.workspacePath).isDirectory()) {
+    if (!existsSync13(p.workspacePath) || !statSync(p.workspacePath).isDirectory()) {
       throw new SwitchyardError("not_found", `Workspace ${p.workspacePath} does not exist`);
     }
     const prev = this.records.get(p.sessionId);
@@ -16434,7 +16736,7 @@ var SessionSupervisor = class {
       }
     }
     let nextOrder = prev?.nextOrder ?? 0;
-    if (!prev && nativeHandle && existsSync12(nativeHandle.sessionFile)) {
+    if (!prev && nativeHandle && existsSync13(nativeHandle.sessionFile)) {
       try {
         const native = await readNativeTranscript(nativeHandle.sessionFile, {
           piBin: this.opts.piBin
@@ -16550,8 +16852,8 @@ var SessionSupervisor = class {
   }
   async prompt(sessionId, text, images, mode) {
     const ms = this.requireLive(sessionId);
-    const disposition = await ms.prompt(text, images, mode);
-    return { disposition };
+    const { disposition, view } = await ms.prompt(text, images, mode);
+    return { disposition, view };
   }
   async abort(sessionId, clearQueue) {
     const ms = this.requireLive(sessionId);
@@ -16587,6 +16889,41 @@ var SessionSupervisor = class {
   async commands(sessionId) {
     return { commands: await this.requireLive(sessionId).commands() };
   }
+  async complete(sessionId, text) {
+    return this.requireLive(sessionId).complete(text);
+  }
+  async reload(sessionId) {
+    await this.requireLive(sessionId).reload();
+    return { ok: true };
+  }
+  piFile(sessionId) {
+    const file = this.requireRecord(sessionId).nativeHandle?.sessionFile;
+    if (!file)
+      throw new SwitchyardError("invalid_request", "This session has no Pi session file");
+    return file;
+  }
+  async tree(sessionId) {
+    const file = this.piFile(sessionId);
+    const SM = await loadPiSessionManager(this.opts.piBin);
+    if (!SM) {
+      throw new SwitchyardError("invalid_request", "Pi's SessionManager could not be loaded on this host");
+    }
+    return { rows: treeRows(SM.open(file, dirname10(file))) };
+  }
+  async branch(sessionId, entryId, fork) {
+    return branchSession(this.piFile(sessionId), entryId, fork, this.opts.piBin);
+  }
+  async exportSession(sessionId) {
+    const file = this.piFile(sessionId);
+    const info = await stat5(file).catch(() => null);
+    if (!info) {
+      throw new SwitchyardError("native_session_missing", `Native session file not found: ${file}`);
+    }
+    if (info.size > 50 * 1024 * 1024) {
+      throw new SwitchyardError("invalid_request", "Session file is too large to export (over 50 MB)");
+    }
+    return { fileName: basename3(file), content: await readFile8(file, "utf8") };
+  }
   async setModel(sessionId, provider, modelId) {
     return this.requireLive(sessionId).setModel(provider, modelId);
   }
@@ -16655,7 +16992,7 @@ var SessionSupervisor = class {
   }
   async importable() {
     const env = { ...process.env, ...this.opts.env ?? {} };
-    const root = join16(piAgentDir(env), "sessions");
+    const root = join17(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 {
@@ -16666,7 +17003,7 @@ var SessionSupervisor = class {
     };
   }
   async readNative(sessionFile) {
-    if (!existsSync12(sessionFile)) {
+    if (!existsSync13(sessionFile)) {
       throw new SwitchyardError("native_session_missing", `Native session file not found: ${sessionFile}`);
     }
     return readNativeTranscript(sessionFile, { piBin: this.opts.piBin });
@@ -17692,7 +18029,7 @@ async function runHostAgent(opts = {}) {
 }
 
 // packages/cli/dist/commands/coordinator.js
-import { existsSync as existsSync13, mkdirSync as mkdirSync8 } from "node:fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync8 } from "node:fs";
 import { resolve as resolve10 } from "node:path";
 function parseListen(v) {
   const s = v.trim();
@@ -17827,7 +18164,7 @@ function coordinatorMigrate(ctx, flags) {
     throw new CliError(`Coordinator (pid ${holder}) is running on ${dataDir}; it migrated at start`);
   }
   const path = dbPath(dataDir);
-  const existed = existsSync13(path);
+  const existed = existsSync14(path);
   mkdirSync8(dataDir, { recursive: true });
   const db = openDb(path);
   try {
@@ -17870,7 +18207,7 @@ function upOptions(flags, env) {
   };
 }
 async function ensureLocalHost(coordinator, localUrl, configPath, name, fetchImpl) {
-  if (existsSync14(configPath)) {
+  if (existsSync15(configPath)) {
     const cfg2 = loadConfig(configPath);
     const known = coordinator.store.hosts.get(cfg2.hostId);
     if (known && !known.revokedAt) {
@@ -18121,7 +18458,7 @@ async function login(ctx, flags, deps = {}) {
 
 // packages/cli/dist/commands/doctor.js
 import { execFile as execFile3 } from "node:child_process";
-import { existsSync as existsSync15, readFileSync as readFileSync9 } from "node:fs";
+import { existsSync as existsSync16, readFileSync as readFileSync9 } from "node:fs";
 function defaultDoctorDeps(ctx) {
   const dataDir = ctx.paths?.dataDir ?? defaultDataDir(ctx.env);
   return {
@@ -18129,7 +18466,7 @@ function defaultDoctorDeps(ctx) {
     detectPi: () => detectPi(ctx.env.SWITCHYARD_PI_BIN ?? "pi"),
     gitVersion: () => new Promise((resolve13) => execFile3("git", ["--version"], (err, stdout) => resolve13(err ? null : stdout.trim()))),
     hostConfigPaths: [defaultConfigPath(ctx.env), standaloneHostPaths(dataDir).configPath],
-    readFile: (p) => existsSync15(p) ? readFileSync9(p, "utf8") : null
+    readFile: (p) => existsSync16(p) ? readFileSync9(p, "utf8") : null
   };
 }
 function findHostConfig(deps) {
@@ -18282,8 +18619,8 @@ function printDoctor(ctx, results) {
 
 // packages/cli/dist/commands/herdr.js
 import { spawn as spawn5 } from "node:child_process";
-import { closeSync as closeSync2, existsSync as existsSync19, openSync as openSync2, readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join21 } from "node:path";
+import { closeSync as closeSync2, existsSync as existsSync20, openSync as openSync2, readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join22 } from "node:path";
 
 // packages/cli/dist/context.js
 function defaultCtx() {
@@ -18334,10 +18671,10 @@ function ago(iso, now = Date.now()) {
 }
 
 // packages/cli/dist/herdr/client.js
-import { existsSync as existsSync16, readdirSync } from "node:fs";
+import { existsSync as existsSync17, readdirSync } from "node:fs";
 import { createConnection as createConnection3 } from "node:net";
 import { homedir as homedir6 } from "node:os";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 var HerdrUnavailable = class extends Error {
   constructor(message) {
     super(message);
@@ -18355,15 +18692,15 @@ var HerdrError = class extends Error {
 function herdrSocketPath(env = process.env, home = homedir6()) {
   if (env.HERDR_SOCKET_PATH)
     return env.HERDR_SOCKET_PATH;
-  const base = join17(home, ".config", "herdr");
+  const base = join18(home, ".config", "herdr");
   if (env.HERDR_SESSION)
-    return join17(base, "sessions", env.HERDR_SESSION, "herdr.sock");
-  const dflt = join17(base, "herdr.sock");
-  if (existsSync16(dflt))
+    return join18(base, "sessions", env.HERDR_SESSION, "herdr.sock");
+  const dflt = join18(base, "herdr.sock");
+  if (existsSync17(dflt))
     return dflt;
   let live = [];
   try {
-    live = readdirSync(join17(base, "sessions")).map((s) => join17(base, "sessions", s, "herdr.sock")).filter((p) => existsSync16(p));
+    live = readdirSync(join18(base, "sessions")).map((s) => join18(base, "sessions", s, "herdr.sock")).filter((p) => existsSync17(p));
   } catch {
     live = [];
   }
@@ -18476,11 +18813,11 @@ function nextSeq() {
 }
 
 // packages/cli/dist/herdr/daemon.js
-import { existsSync as existsSync18, mkdirSync as mkdirSync10, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync10, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join20 } from "node:path";
 
 // packages/cli/dist/herdr/mirror.js
-import { basename as basename3 } from "node:path";
+import { basename as basename4 } from "node:path";
 var SOURCE = "switchyard";
 var PENDING_MS = 15e3;
 var NEW_SESSION_GRACE_MS = 5e3;
@@ -18512,10 +18849,10 @@ function projectOfKey(key, st) {
 function spaceLabel(key, st) {
   const w = st.workspaces.find((x) => x.id === key);
   if (w) {
-    const project2 = st.projects.find((p) => p.id === w.projectId)?.name ?? basename3(w.path);
+    const project2 = st.projects.find((p) => p.id === w.projectId)?.name ?? basename4(w.path);
     let label = project2;
     if (w.provenance !== "main")
-      label += ` \xB7 ${w.branch ?? basename3(w.path)}`;
+      label += ` \xB7 ${w.branch ?? basename4(w.path)}`;
     const hosts = new Set(st.checkouts.filter((c) => c.projectId === w.projectId).map((c) => c.hostId));
     if (hosts.size >= 2)
       label += ` \xB7 ${hostName(st, w.hostId)}`;
@@ -18524,7 +18861,7 @@ function spaceLabel(key, st) {
   const cwd = key.split(":").slice(2).join(":");
   const s = st.sessions.find((x) => spaceKey(x) === key);
   const project = s?.projectId && st.projects.find((p) => p.id === s.projectId)?.name || null;
-  return cap2(`${project ?? basename3(cwd)} \xB7 ${basename3(cwd)}`);
+  return cap2(`${project ?? basename4(cwd)} \xB7 ${basename4(cwd)}`);
 }
 function tabLabel(s, overrides = {}) {
   return cap2(overrides[s.id] ?? s.title);
@@ -18763,27 +19100,27 @@ function planMirror(st, h, mem, now) {
 }
 
 // packages/cli/dist/herdr/util.js
-import { chmodSync as chmodSync5, existsSync as existsSync17, mkdirSync as mkdirSync9, writeFileSync as writeFileSync5 } from "node:fs";
+import { chmodSync as chmodSync5, existsSync as existsSync18, mkdirSync as mkdirSync9, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 function herdrStateDir(env = process.env, home = homedir7()) {
   const xdg = env.XDG_STATE_HOME?.trim();
-  return join18(xdg || join18(home, ".local", "state"), "switchyard-herdr");
+  return join19(xdg || join19(home, ".local", "state"), "switchyard-herdr");
 }
 function sessionStateDir(env = process.env) {
-  const dir = join18(herdrStateDir(env), herdrSessionName(env));
+  const dir = join19(herdrStateDir(env), herdrSessionName(env));
   mkdirSync9(dir, { recursive: true, mode: 448 });
   return dir;
 }
 function stableLauncherPath(env = process.env) {
-  return env.SWITCHYARD_HERDR_LAUNCHER || join18(herdrStateDir(env), "switchyard-herdr");
+  return env.SWITCHYARD_HERDR_LAUNCHER || join19(herdrStateDir(env), "switchyard-herdr");
 }
 function writeStableLauncher(stateRoot, pluginRoot) {
   if (pluginRoot.includes("'") || stateRoot.includes("'")) {
     throw new CliError("Plugin path contains an apostrophe");
   }
   mkdirSync9(stateRoot, { recursive: true, mode: 448 });
-  const path = join18(stateRoot, "switchyard-herdr");
+  const path = join19(stateRoot, "switchyard-herdr");
   writeFileSync5(path, `#!/bin/sh
 exec sh '${pluginRoot}/switchyard-herdr.sh' "$@"
 `, {
@@ -18793,7 +19130,7 @@ exec sh '${pluginRoot}/switchyard-herdr.sh' "$@"
   return path;
 }
 function launcherExists(env = process.env) {
-  return existsSync17(stableLauncherPath(env));
+  return existsSync18(stableLauncherPath(env));
 }
 async function isAtShell(call, paneId) {
   const info = (await call("pane.process_info", { pane_id: paneId }))?.process_info ?? {};
@@ -18867,7 +19204,7 @@ var MirrorDaemon = class {
     return (this.deps.now ?? Date.now)();
   }
   get spacesFile() {
-    return join19(this.deps.stateDir, "spaces.json");
+    return join20(this.deps.stateDir, "spaces.json");
   }
   async start() {
     this.load();
@@ -18992,10 +19329,10 @@ var MirrorDaemon = class {
     const titleOf = (sid) => st.sessions.find((s) => s.id === sid)?.title ?? sid;
     const launcher = this.deps.launcherPath;
     const paneCmd = (sid) => launcherCommand(launcher, ["pane", sid]);
-    const exists2 = this.deps.exists ?? existsSync18;
+    const exists2 = this.deps.exists ?? existsSync19;
     const createdNow = {};
     const fallbackCwd = () => {
-      const dir = join19(this.deps.stateDir, "spaces");
+      const dir = join20(this.deps.stateDir, "spaces");
       mkdirSync10(dir, { recursive: true, mode: 448 });
       return dir;
     };
@@ -19221,7 +19558,7 @@ var MirrorDaemon = class {
 
 // packages/cli/dist/herdr/new-session.js
 import { readFileSync as readFileSync11 } from "node:fs";
-import { basename as basename4, join as join20 } from "node:path";
+import { basename as basename5, join as join21 } from "node:path";
 
 // packages/cli/dist/herdr/pane.js
 var LIVE = /* @__PURE__ */ new Set(["starting", "idle", "running", "waiting_input"]);
@@ -19848,7 +20185,7 @@ function workspaceItems(st, projectId) {
       own.length > 0 ? plural(own.length, "session") : "",
       w.git?.dirty ? "modified" : ""
     ].filter(Boolean).join(" \xB7 ");
-    const label = `${w.branch ?? basename4(w.path)}${w.provenance === "main" ? " (main checkout)" : ""}`;
+    const label = `${w.branch ?? basename5(w.path)}${w.provenance === "main" ? " (main checkout)" : ""}`;
     return {
       item: { label, detail, value: { kind: "existing", workspaceId: w.id } },
       active: latest(own.map((x) => x.lastActivityAt)),
@@ -19895,7 +20232,7 @@ async function chooseSession(st, screen, opts = {}) {
     if (pick?.kind === "existing") {
       const w = st.workspaces.find((x) => x.id === pick.workspaceId);
       if (w && w.provenance !== "main")
-        c.push(w.branch ?? basename4(w.path));
+        c.push(w.branch ?? basename5(w.path));
     } else if (pick?.kind === "new" && pick.branch) {
       c.push(pick.branch);
     }
@@ -20036,7 +20373,7 @@ async function newHere(ctx) {
   const ws = snap.focused_workspace_id;
   let key = null;
   try {
-    const raw = JSON.parse(readFileSync11(join20(sessionStateDir(ctx.env), "spaces.json"), "utf8"));
+    const raw = JSON.parse(readFileSync11(join21(sessionStateDir(ctx.env), "spaces.json"), "utf8"));
     key = ws ? raw.spaces?.[ws]?.key ?? null : null;
   } catch {
     key = null;
@@ -20067,8 +20404,8 @@ async function herdrDaemon(ctx, flags) {
   }
   const launcherPath = stableLauncherPath(env);
   const dir = sessionStateDir(env);
-  const pidFile = join21(dir, "daemon.pid");
-  const logFile = join21(dir, "daemon.log");
+  const pidFile = join22(dir, "daemon.pid");
+  const logFile = join22(dir, "daemon.log");
   const socket = herdrSocketPath(env);
   const call = (method, params) => herdrCall(method, params, socket);
   if (flags.once) {
@@ -20098,7 +20435,7 @@ async function herdrDaemon(ctx, flags) {
     }
     return;
   }
-  const running = existsSync19(pidFile) ? Number(readFileSync12(pidFile, "utf8").trim()) : 0;
+  const running = existsSync20(pidFile) ? Number(readFileSync12(pidFile, "utf8").trim()) : 0;
   if (flags.ensure) {
     if (running && pidAlive2(running))
       return;
@@ -20166,16 +20503,16 @@ async function herdrStatus(ctx, flags) {
 }
 
 // packages/cli/dist/commands/host.js
-import { existsSync as existsSync21, mkdirSync as mkdirSync12 } from "node:fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync12 } from "node:fs";
 import { hostname as hostname4 } from "node:os";
-import { dirname as dirname10, join as join23, resolve as resolve12 } from "node:path";
+import { dirname as dirname12, join as join24, 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 existsSync20, mkdirSync as mkdirSync11, readFileSync as readFileSync13, writeFileSync as writeFileSync8 } from "node:fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync11, readFileSync as readFileSync13, writeFileSync as writeFileSync8 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { dirname as dirname9, join as join22, resolve as resolve11 } from "node:path";
+import { dirname as dirname11, join as join23, resolve as resolve11 } from "node:path";
 var LAUNCHD_LABEL = "com.switchyard.host";
 var SYSTEMD_UNIT = "switchyard-host.service";
 var TEMPLATES = {
@@ -20251,8 +20588,8 @@ WantedBy=default.target
 `
 };
 var TEMPLATE_FILES = {
-  launchd: join22("launchd", `${LAUNCHD_LABEL}.plist`),
-  systemd: join22("systemd", SYSTEMD_UNIT)
+  launchd: join23("launchd", `${LAUNCHD_LABEL}.plist`),
+  systemd: join23("systemd", SYSTEMD_UNIT)
 };
 function xmlEscape(s) {
   return s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
@@ -20264,8 +20601,8 @@ function systemdEscape(s, exec = true) {
   return exec ? out.replaceAll("$", "$$$$") : out;
 }
 function loadTemplate(kind, dir = deployDir()) {
-  const p = join22(dir, TEMPLATE_FILES[kind]);
-  return existsSync20(p) ? readFileSync13(p, "utf8") : TEMPLATES[kind];
+  const p = join23(dir, TEMPLATE_FILES[kind]);
+  return existsSync21(p) ? readFileSync13(p, "utf8") : TEMPLATES[kind];
 }
 function renderService(kind, vars, template = TEMPLATES[kind]) {
   for (const [k, v] of Object.entries(vars)) {
@@ -20296,7 +20633,7 @@ function serviceNames(instance) {
 }
 function serviceFilePath(kind, home = homedir8(), instance) {
   const { label, unit } = serviceNames(instance);
-  return kind === "launchd" ? join22(home, "Library", "LaunchAgents", `${label}.plist`) : join22(home, ".config", "systemd", "user", unit);
+  return kind === "launchd" ? join23(home, "Library", "LaunchAgents", `${label}.plist`) : join23(home, ".config", "systemd", "user", unit);
 }
 function loadCommands(kind, file, uid, instance) {
   const { label, unit } = serviceNames(instance);
@@ -20309,7 +20646,7 @@ function loadCommands(kind, file, uid, instance) {
     ["systemctl", "--user", "restart", unit]
   ];
 }
-function stableNodePath(execPath, exists2 = existsSync20) {
+function stableNodePath(execPath, exists2 = existsSync21) {
   const m = execPath.match(/^(.*)\/Cellar\/node(?:@[^/]+)?\/[^/]+\/bin\/node$/);
   if (m) {
     const candidate = `${m[1]}/bin/node`;
@@ -20333,11 +20670,11 @@ async function installService(ctx, flags, deps = defaultInstallDeps()) {
     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 (!existsSync20(config) && !flags.print) {
+  if (!existsSync21(config) && !flags.print) {
     throw new CliError(`No host config at ${config}. Enroll first: switchyard host enroll --coordinator <url> --token <t>`);
   }
   const stateDir = flags.stateDir ? resolve11(flags.stateDir) : defaultStateDir(ctx.env, deps.platform, deps.home);
-  const logDir = join22(stateDir, "logs");
+  const logDir = join23(stateDir, "logs");
   const content = renderService(kind, {
     node: stableNodePath(process.execPath),
     cli: cliEntry(),
@@ -20353,7 +20690,7 @@ async function installService(ctx, flags, deps = defaultInstallDeps()) {
     ctx.out(content.trimEnd());
     return { file, content };
   }
-  mkdirSync11(dirname9(file), { recursive: true });
+  mkdirSync11(dirname11(file), { recursive: true });
   mkdirSync11(logDir, { recursive: true, mode: 448 });
   writeFileSync8(file, content, { mode: 420 });
   ctx.out(`Wrote ${file}`);
@@ -20397,7 +20734,7 @@ async function hostEnroll(ctx, flags) {
 }
 async function hostRun(ctx, flags) {
   const configPath = flags.config ?? defaultConfigPath(ctx.env);
-  if (!existsSync21(configPath)) {
+  if (!existsSync22(configPath)) {
     ctx.err(`No host config at ${configPath} yet: waiting for it (with SWITCHYARD_HOST_ENROLL_SECRET and SWITCHYARD_COORDINATOR_URL set, the host enrolls itself).`);
   }
   const agent = await runHostAgent({
@@ -20412,13 +20749,13 @@ async function hostRun(ctx, flags) {
 }
 function hostBackup(ctx, out, flags) {
   const stateDir = flags.stateDir ?? defaultStateDir(ctx.env);
-  const src = join23(stateDir, "host.db");
-  if (!existsSync21(src))
+  const src = join24(stateDir, "host.db");
+  if (!existsSync22(src))
     throw new CliError(`No host database at ${src}`);
   const dest = resolve12(out);
-  if (existsSync21(dest))
+  if (existsSync22(dest))
     throw new CliError(`${dest} already exists`);
-  mkdirSync12(dirname10(dest), { recursive: true });
+  mkdirSync12(dirname12(dest), { recursive: true });
   const db = new DatabaseSync4(src);
   try {
     db.exec("PRAGMA busy_timeout = 5000");
@@ -20433,7 +20770,7 @@ async function hostStatus(ctx, flags) {
   const configPath = flags.config ?? defaultConfigPath(ctx.env);
   const stateDir = flags.stateDir ?? defaultStateDir(ctx.env);
   const status = { configPath, stateDir };
-  if (!existsSync21(configPath)) {
+  if (!existsSync22(configPath)) {
     status.enrolled = false;
   } else {
     const cfg = loadConfig(configPath);
@@ -20466,7 +20803,7 @@ async function hostStatus(ctx, flags) {
   try {
     const kind = serviceKindFor(process.platform);
     const file = serviceFilePath(kind);
-    status.service = { kind, file, installed: existsSync21(file) };
+    status.service = { kind, file, installed: existsSync22(file) };
   } catch {
     status.service = null;
   }