@lesscap/baton-cli 0.9.5 → 0.9.7

package/README.md

@@ -1,7 +1,7 @@
 # @lesscap/baton-cli
 
 The baton CLI: register/run a **worker** on a machine and manage
-workspaces/projects/requirements/tasks/sessions against a baton server.
+workspaces/projects/sessions against a baton server.
 
 A worker is the thing that actually runs agent sessions: it listens to the
 server's command stream and, per session, runs Claude or Codex in the worker’s working directory.
@@ -69,7 +69,7 @@ runtime `services/` directory; the run result prints their path.
 
 ## Other commands
 
-`baton init | workspace | project | requirement | task | session` — run
+`baton init | workspace | project | host | session` — run
 `baton <command> --help` for details. The back-office management commands hit
 gated routes; set `BATON_USER` / `BATON_PASS` to log in transparently (the
 worker commands above don't need this).

package/dist/baton.mjs

@@ -5376,10 +5376,10 @@ var toJson = (data) => JSON.stringify(data, null, 2);
 var fmtWorkspace = (w) => `${w.id}  ${w.name}`;
 var fmtWorkerTemplate = (t) => `${t.id}  ${t.name}  [${t.available ? "available" : "unavailable"}]  ${t.agentKinds.join(", ")}`;
 var fmtWorkerCreation = (c) => `${c.id}  [${c.status}/${c.step ?? "pending"}]  ${c.name}  ${c.agentKind}${c.workerId === null ? "" : `  W-${c.workerId}`}${c.error ? `  ${c.error}` : ""}`;
+var fmtHost = (h) => `${h.id}  ${h.name}  [${h.online ? "online" : "offline"}]  workspaces: ${h.workspaceIds.join(",") || "-"}`;
+var fmtHostCredential = ({ host: host2, token }) => `${host2.id}  ${host2.name}
+token: ${token}`;
 var fmtProject = (p) => `${p.id}  ${p.name}`;
-var fmtRequirement = (r) => `${r.code}  [${r.status}]  ${r.title}`;
-var fmtTask = (t) => `${t.code}  [${t.status}]  ${t.title}`;
-var fmtComment = (c) => `${c.workerId !== void 0 ? `worker#${c.workerId}` : "you"}  ${c.body}`;
 var fmtSession = (s) => `${s.id}  ${s.name}  ${s.attached ? "[active]" : "[inactive]"}  ${s.cwd ?? "(pending)"}`;
 var fmtWorker = (w) => {
   const offline = w.connected === false ? "  [offline]" : "";
@@ -5509,6 +5509,15 @@ var filesClient = (baseUrl) => {
   };
 };
 
+// src/client/hosts.ts
+var hostsClient = (baseUrl) => ({
+  create: (name) => request(`${baseUrl}/hosts`, { method: "POST", body: { name } }),
+  list: () => request(`${baseUrl}/hosts`, { method: "GET" }),
+  rotate: (id) => request(`${baseUrl}/hosts/${id}/token`, { method: "POST", body: {} }),
+  assign: (id, workspaceId) => request(`${baseUrl}/hosts/${id}/workspaces/${workspaceId}`, { method: "PUT" }),
+  unassign: (id, workspaceId) => request(`${baseUrl}/hosts/${id}/workspaces/${workspaceId}`, { method: "DELETE" })
+});
+
 // src/client/loops.ts
 var loopsClient = (baseUrl) => {
   const u = (p) => `${baseUrl}${p}`;
@@ -5535,30 +5544,6 @@ var projectClient = (baseUrl) => {
   };
 };
 
-// src/client/items.ts
-var fetchItemByCode = async (baseUrl, projectId, code, expectKind) => {
-  const r = await request(
-    `${baseUrl}/projects/${projectId}/items/${encodeURIComponent(code)}`,
-    { method: "GET" }
-  );
-  if (r.kind !== expectKind) throw new Error(`expected ${expectKind} but got ${r.kind} for ${code}`);
-  return r.item;
-};
-
-// src/client/requirements.ts
-var requirementClient = (baseUrl) => {
-  const u = (p) => `${baseUrl}${p}`;
-  return {
-    create: (input) => request(u("/requirements"), { method: "POST", body: input }),
-    listByProject: (projectId) => request(u(`/projects/${projectId}/requirements`), { method: "GET" }),
-    get: (id) => request(u(`/requirements/${id}`), { method: "GET" }),
-    getByCode: (projectId, code) => fetchItemByCode(baseUrl, projectId, code, "requirement"),
-    update: (id, patch) => request(u(`/requirements/${id}`), { method: "PATCH", body: patch }),
-    setStatus: (id, status) => request(u(`/requirements/${id}`), { method: "PATCH", body: { status } }),
-    remove: (id) => request(u(`/requirements/${id}`), { method: "DELETE" })
-  };
-};
-
 // src/client/services.ts
 var servicesClient = (baseUrl) => {
   const u = (path) => `${baseUrl}${path}`;
@@ -5693,24 +5678,9 @@ var sessionsClient = (baseUrl) => {
   };
 };
 
-// src/client/tasks.ts
-var taskClient = (baseUrl) => {
-  const u = (p) => `${baseUrl}${p}`;
-  return {
-    create: (input) => request(u("/tasks"), { method: "POST", body: input }),
-    listByRequirement: (requirementId) => request(u(`/requirements/${requirementId}/tasks`), { method: "GET" }),
-    get: (id) => request(u(`/tasks/${id}`), { method: "GET" }),
-    getByCode: (projectId, code) => fetchItemByCode(baseUrl, projectId, code, "task"),
-    update: (id, patch) => request(u(`/tasks/${id}`), { method: "PATCH", body: patch }),
-    setStatus: (id, status) => request(u(`/tasks/${id}`), { method: "PATCH", body: { status } }),
-    remove: (id) => request(u(`/tasks/${id}`), { method: "DELETE" }),
-    listComments: (id) => request(u(`/tasks/${id}/comments`), { method: "GET" }),
-    addComment: (id, body, workerId) => request(u(`/tasks/${id}/comments`), { method: "POST", body: { body, workerId } })
-  };
-};
-
 // src/client/worker-creations.ts
 var workerCreationsClient = (baseUrl) => ({
+  hosts: (projectId) => request(`${baseUrl}/projects/${projectId}/hosts`, { method: "GET" }),
   templates: (projectId) => request(`${baseUrl}/projects/${projectId}/worker-templates`, { method: "GET" }),
   create: (projectId, input) => request(`${baseUrl}/projects/${projectId}/worker-creations`, { method: "POST", body: input }),
   listByProject: (projectId) => request(`${baseUrl}/projects/${projectId}/worker-creations`, { method: "GET" }),
@@ -5758,11 +5728,10 @@ var createClient = (baseUrl, opts) => {
 };
 var clientFromBase = (baseUrl) => ({
   workerCreations: workerCreationsClient(baseUrl),
+  hosts: hostsClient(baseUrl),
   artifacts: artifactsClient(baseUrl),
   workspaces: workspaceClient(baseUrl),
   projects: projectClient(baseUrl),
-  requirements: requirementClient(baseUrl),
-  tasks: taskClient(baseUrl),
   sessions: sessionsClient(baseUrl),
   services: servicesClient(baseUrl),
   files: filesClient(baseUrl),
@@ -7114,6 +7083,87 @@ var channel = defineCommand({
   }
 });
 
+// src/commands/host.ts
+var findHost = (hosts, handle) => {
+  const host2 = hosts.find((item) => item.name === handle || String(item.id) === handle);
+  if (!host2) throw new Error(`host not found: ${handle}`);
+  return host2;
+};
+var adminHost = async (c, handle) => findHost(await c.hosts.list(), handle);
+var positiveId = (raw) => {
+  const id = Number(raw);
+  if (!Number.isSafeInteger(id) || id <= 0) throw new Error("workspace must be a positive id");
+  return id;
+};
+var hostArg = {
+  host: { type: "positional", required: true, description: "host name or id" }
+};
+var workspaceArg = {
+  workspace: { type: "string", required: true, description: "workspace id" }
+};
+var host = defineCommand({
+  meta: { name: "host", description: "manage machines and which workspaces can use them (admin)" },
+  subCommands: {
+    add: defineCommand({
+      meta: { name: "add", description: "add a host; prints its Provisioner token once" },
+      args: {
+        name: { type: "positional", required: true, description: "host name" },
+        workspace: { type: "string", description: "also assign it to this workspace id" },
+        ...common
+      },
+      run: async ({ args }) => {
+        const c = clientFor(args);
+        const workspaceId = args.workspace === void 0 ? null : positiveId(args.workspace);
+        const credential = await c.hosts.create(args.name);
+        console.log(renderOne(credential, fmtHostCredential, Boolean(args.json)));
+        if (workspaceId !== null) await c.hosts.assign(credential.host.id, workspaceId);
+      }
+    }),
+    ls: defineCommand({
+      meta: {
+        name: "ls",
+        description: "list hosts, whether they are online, and their workspaces"
+      },
+      args: { ...common },
+      run: async ({ args }) => {
+        console.log(renderList(await clientFor(args).hosts.list(), fmtHost, Boolean(args.json)));
+      }
+    }),
+    assign: defineCommand({
+      meta: { name: "assign", description: "let a workspace create Workers on this host" },
+      args: { ...hostArg, ...workspaceArg, ...common },
+      run: async ({ args }) => {
+        const c = clientFor(args);
+        const { id, name } = await adminHost(c, args.host);
+        await c.hosts.assign(id, positiveId(args.workspace));
+        console.log(`assigned ${name} to workspace ${args.workspace}`);
+      }
+    }),
+    unassign: defineCommand({
+      meta: {
+        name: "unassign",
+        description: "stop new Workers on this host for a workspace; existing ones keep running"
+      },
+      args: { ...hostArg, ...workspaceArg, ...common },
+      run: async ({ args }) => {
+        const c = clientFor(args);
+        const { id, name } = await adminHost(c, args.host);
+        await c.hosts.unassign(id, positiveId(args.workspace));
+        console.log(`unassigned ${name} from workspace ${args.workspace}`);
+      }
+    }),
+    rotate: defineCommand({
+      meta: { name: "rotate", description: "replace a host token; the old one stops working" },
+      args: { ...hostArg, ...common },
+      run: async ({ args }) => {
+        const c = clientFor(args);
+        const { id } = await adminHost(c, args.host);
+        console.log(renderOne(await c.hosts.rotate(id), fmtHostCredential, Boolean(args.json)));
+      }
+    })
+  }
+});
+
 // src/commands/init.ts
 import { existsSync as existsSync2 } from "node:fs";
 import * as readline from "node:readline/promises";
@@ -7467,9 +7517,9 @@ var environment = (value) => {
 var templates = (value) => {
   if (!object(value)) throw new Error("templates must be an object");
   return Object.fromEntries(
-    WORKER_TEMPLATES.map((template) => {
+    WORKER_TEMPLATES.filter((template) => value[template.id] !== void 0).map((template) => {
       const raw = value[template.id];
-      if (!object(raw)) throw new Error(`template ${template.id} must be configured`);
+      if (!object(raw)) throw new Error(`template ${template.id} must be an object`);
       const workerEnv2 = environment(raw.workerEnv);
       if (template.id === "mini-codex") {
         if (raw.pi !== void 0) throw new Error("mini-codex does not support pi");
@@ -7563,7 +7613,7 @@ var createProvisionerClient = (config) => {
 import { execFile as execFile3 } from "node:child_process";
 import { lstat, mkdir as mkdir3, realpath, writeFile as writeFile2 } from "node:fs/promises";
 import { hostname } from "node:os";
-import { join as join5 } from "node:path";
+import { dirname as dirname2, join as join5 } from "node:path";
 import { setTimeout as setTimeout2 } from "node:timers/promises";
 import { promisify as promisify3 } from "node:util";
 
@@ -7634,11 +7684,17 @@ var startAgent = async (config, agent, signal) => {
     throw new Error(`launchd start failed; inspect ${plist} and ${agent.log}`);
   }
 };
-var launchWorkerAgent = async (config, creation, repoPath, workerEnv2, signal) => startAgent(
+var launchWorkerAgent = async (config, creation, repoPath, configPath, workerEnv2, signal) => startAgent(
   config,
   {
     label: `dev.fmap.baton-worker-creation-${creation.id}`,
-    args: [config.nodePath ?? process.execPath, config.cliPath, "worker", "run"],
+    args: [
+      config.nodePath ?? process.execPath,
+      config.cliPath,
+      "worker",
+      "run",
+      ...configPath === null ? [] : ["--config", configPath]
+    ],
     cwd: repoPath,
     env: {
       PATH: workerEnv2.PATH ?? process.env.PATH ?? "/usr/bin:/bin",
@@ -7668,12 +7724,17 @@ var installProvisionerAgent = async (config, configPath) => startAgent(config, {
 // src/provisioner/worker-template.ts
 import { mkdir as mkdir2, writeFile } from "node:fs/promises";
 import { join as join4 } from "node:path";
-var workerTemplateEnvironment = async (config, creation, state) => {
+var requireWorkerTemplate = (config, creation) => {
   if (!workerTemplateAgentKinds(creation.templateId).includes(creation.agentKind))
     throw new Error("agentKind is not supported by this template");
-  if (creation.templateId === "mini-local") return config.workerEnv;
+  if (creation.templateId === "mini-local") return null;
   const profile = config.templates[creation.templateId];
-  if (!profile) throw new Error(`template ${creation.templateId} is not configured`);
+  if (!profile) throw new Error(`template ${creation.templateId} is not configured on this host`);
+  return profile;
+};
+var workerTemplateEnvironment = async (config, creation, state) => {
+  const profile = requireWorkerTemplate(config, creation);
+  if (!profile) return config.workerEnv;
   if (creation.agentKind !== "pi") return profile.workerEnv;
   if (!profile.pi) throw new Error("Pi provider and model are not configured");
   const agentDir = join4(state, "pi");
@@ -7699,13 +7760,20 @@ var directory = async (path) => {
   const info = await lstat(path);
   if (!info.isDirectory() || info.isSymbolicLink()) throw new Error(`unsafe directory: ${path}`);
 };
-var provisionWorker = async (config, creation, client, signal) => {
-  const repoPath = join5(
-    config.projectsRoot,
-    `project-${creation.projectId}`,
-    `creation-${creation.id}`
-  );
-  const progress = (step) => client.report(creation.id, { status: "running", step, repoPath }, signal);
+var gitIn = async (config, repoPath, args, signal, failure = "Git repository initialization failed") => {
+  try {
+    const { stdout } = await promisify3(execFile3)("git", ["-C", repoPath, ...args], {
+      env: commandEnvironment(config),
+      signal,
+      timeout: 1e4
+    });
+    return stdout;
+  } catch (error) {
+    signal.throwIfAborted();
+    throw new Error(failure, { cause: error });
+  }
+};
+var initRepository = async (config, creation, repoPath, progress, signal) => {
   await progress("directory");
   signal.throwIfAborted();
   await mkdir3(config.projectsRoot, { recursive: true, mode: 448 });
@@ -7715,33 +7783,52 @@ var provisionWorker = async (config, creation, client, signal) => {
     mode: 448
   });
   await progress("git");
-  const git2 = async (args) => {
-    try {
-      await promisify3(execFile3)("git", ["-C", repoPath, ...args], {
-        env: commandEnvironment(config),
-        signal,
-        timeout: 1e4
-      });
-    } catch (error) {
-      signal.throwIfAborted();
-      throw new Error("Git repository initialization failed", { cause: error });
-    }
-  };
-  await git2(["init", "-b", "main"]);
+  await gitIn(config, repoPath, ["init", "-b", "main"], signal);
   await writeFile2(join5(repoPath, ".git/info/exclude"), "\n.baton.json\n", { flag: "a" });
-  await git2([
-    "-c",
-    "user.name=Baton",
-    "-c",
-    "user.email=baton@localhost",
-    "commit",
-    "--allow-empty",
-    "-m",
-    "chore: initialize repository"
-  ]);
+  await gitIn(
+    config,
+    repoPath,
+    [
+      "-c",
+      "user.name=Baton",
+      "-c",
+      "user.email=baton@localhost",
+      "commit",
+      "--allow-empty",
+      "-m",
+      "chore: initialize repository"
+    ],
+    signal
+  );
+};
+var adoptRepository = async (config, creation, repoPath, progress, signal) => {
+  await progress("directory");
+  signal.throwIfAborted();
+  const real = await realpath(repoPath);
+  const project2 = join5(await realpath(config.projectsRoot), `project-${creation.projectId}`);
+  if (dirname2(real) !== project2 || !(await lstat(real)).isDirectory())
+    throw new Error(`unsafe directory: ${repoPath}`);
+  await progress("git");
+  const top = await gitIn(
+    config,
+    real,
+    ["rev-parse", "--show-toplevel"],
+    signal,
+    `not a Git repository: ${repoPath}`
+  );
+  if (await realpath(top.trim()) !== real)
+    throw new Error(`not the root of a Git work tree: ${repoPath}`);
+};
+var provisionWorker = async (config, creation, client, signal) => {
+  requireWorkerTemplate(config, creation);
+  const shared = creation.repoPath !== null;
+  const repoPath = creation.repoPath ?? join5(config.projectsRoot, `project-${creation.projectId}`, `creation-${creation.id}`);
+  const progress = (step) => client.report(creation.id, { status: "running", step, repoPath }, signal);
+  await (shared ? adoptRepository : initRepository)(config, creation, repoPath, progress, signal);
   await progress("register");
   const result = await client.register(creation.id, hostname(), signal);
   const state = workerStatePath(config, creation);
+  const root = await realpath(config.projectsRoot);
   await directory(join5(root, ".worker-state"));
   await directory(join5(root, ".worker-state", `project-${creation.projectId}`));
   await mkdir3(state, { mode: 448 });
@@ -7760,15 +7847,13 @@ var provisionWorker = async (config, creation, client, signal) => {
     machineId: result.worker.machineId,
     apiToken: result.apiToken
   });
-  await writeFile2(join5(repoPath, ".baton.json"), `${JSON.stringify(cfg, null, 2)}
-`, {
-    flag: "wx",
-    mode: 384
-  });
+  const configPath = shared ? join5(state, "worker.json") : join5(repoPath, ".baton.json");
+  await writeFile2(configPath, `${JSON.stringify(cfg, null, 2)}
+`, { flag: "wx", mode: 384 });
   await progress("start");
   signal.throwIfAborted();
   const workerEnv2 = await workerTemplateEnvironment(config, creation, state);
-  await launchWorkerAgent(config, creation, repoPath, workerEnv2, signal);
+  await launchWorkerAgent(config, creation, repoPath, shared ? configPath : null, workerEnv2, signal);
   await progress("connect");
   const deadline = Date.now() + 6e4;
   while (Date.now() < deadline) {
@@ -8119,118 +8204,6 @@ var relay = defineCommand({
   subCommands: { host: hostCommand, listen: listenCommand2, send: sendCommand2 }
 });
 
-// src/commands/requirement.ts
-var createRequirement = (c, input, json) => c.requirements.create(input).then((r) => renderOne(r, fmtRequirement, json));
-var updateRequirement = (c, id, patch, json) => c.requirements.update(id, patch).then((r) => renderOne(r, fmtRequirement, json));
-var listRequirements = (c, projectId, json) => c.requirements.listByProject(projectId).then((rs) => renderList(rs, fmtRequirement, json));
-var getRequirement = (c, id, json) => c.requirements.get(id).then((r) => renderOne(r, fmtRequirement, json));
-var setRequirementStatus = (c, id, status, json) => c.requirements.setStatus(id, status).then((r) => renderOne(r, fmtRequirement, json));
-var removeRequirement = (c, id, label, json) => c.requirements.remove(id).then(() => removed("requirement", label, json));
-var resolveByCode = async (c, projectId, code) => (await c.requirements.getByCode(projectId, code)).id;
-var requirement = defineCommand({
-  meta: { name: "requirement", description: "manage requirements" },
-  subCommands: {
-    create: defineCommand({
-      meta: { name: "create", description: "create a requirement" },
-      args: {
-        title: { type: "positional", required: true },
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        desc: { type: "string", description: "description" },
-        body: { type: "string", description: "requirement body (markdown)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        console.log(
-          await createRequirement(
-            clientFor(args),
-            {
-              projectId: resolveProjectId(args),
-              title: args.title,
-              description: args.desc,
-              body: args.body
-            },
-            Boolean(args.json)
-          )
-        );
-      }
-    }),
-    update: defineCommand({
-      meta: { name: "update", description: "update a requirement title / body" },
-      args: {
-        code: { type: "positional", required: true, description: "requirement code (R-N)" },
-        title: { type: "string", description: "new title" },
-        body: { type: "string", description: "new body (markdown)" },
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        const patch = {
-          ...args.title !== void 0 ? { title: args.title } : {},
-          ...args.body !== void 0 ? { body: args.body } : {}
-        };
-        if (Object.keys(patch).length === 0) throw new Error("pass --title and/or --body");
-        const c = clientFor(args);
-        const id = await resolveByCode(c, resolveProjectId(args), args.code);
-        console.log(await updateRequirement(c, id, patch, Boolean(args.json)));
-      }
-    }),
-    ls: defineCommand({
-      meta: { name: "ls", description: "list requirements in a project" },
-      args: {
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        console.log(
-          await listRequirements(clientFor(args), resolveProjectId(args), Boolean(args.json))
-        );
-      }
-    }),
-    get: defineCommand({
-      meta: { name: "get", description: "get a requirement by code (R-N)" },
-      args: {
-        code: { type: "positional", required: true, description: "requirement code, e.g. R-1" },
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        const c = clientFor(args);
-        const id = await resolveByCode(c, resolveProjectId(args), args.code);
-        console.log(await getRequirement(c, id, Boolean(args.json)));
-      }
-    }),
-    "set-status": defineCommand({
-      meta: { name: "set-status", description: "set requirement status (active|done|cancelled)" },
-      args: {
-        code: { type: "positional", required: true, description: "requirement code (R-N)" },
-        status: { type: "positional", required: true },
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        const c = clientFor(args);
-        const id = await resolveByCode(c, resolveProjectId(args), args.code);
-        console.log(
-          await setRequirementStatus(c, id, args.status, Boolean(args.json))
-        );
-      }
-    }),
-    rm: defineCommand({
-      meta: { name: "rm", description: "delete a requirement by code" },
-      args: {
-        code: { type: "positional", required: true },
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        const c = clientFor(args);
-        const id = await resolveByCode(c, resolveProjectId(args), args.code);
-        console.log(await removeRequirement(c, id, args.code, Boolean(args.json)));
-      }
-    })
-  }
-});
-
 // src/commands/service.ts
 import { resolve as resolve2 } from "node:path";
 
@@ -9848,178 +9821,19 @@ var session = defineCommand({
   }
 });
 
-// src/commands/task.ts
-var createTask = (c, input, json) => c.tasks.create(input).then((t) => renderOne(t, fmtTask, json));
-var updateTask = (c, id, patch, json) => c.tasks.update(id, patch).then((t) => renderOne(t, fmtTask, json));
-var listTasks = (c, requirementId, json) => c.tasks.listByRequirement(requirementId).then((ts) => renderList(ts, fmtTask, json));
-var getTask = (c, id, json) => c.tasks.get(id).then((t) => renderOne(t, fmtTask, json));
-var setTaskStatus = (c, id, status, json) => c.tasks.setStatus(id, status).then((t) => renderOne(t, fmtTask, json));
-var removeTask = (c, id, label, json) => c.tasks.remove(id).then(() => removed("task", label, json));
-var addTaskComment = (c, taskId, body, workerId, json) => c.tasks.addComment(taskId, body, workerId).then((x) => renderOne(x, fmtComment, json));
-var listTaskComments = (c, taskId, json) => c.tasks.listComments(taskId).then((xs) => renderList(xs, fmtComment, json));
-var resolveReqByCode = async (c, projectId, code) => (await c.requirements.getByCode(projectId, code)).id;
-var resolveTaskByCode = async (c, projectId, code) => (await c.tasks.getByCode(projectId, code)).id;
-var task = defineCommand({
-  meta: { name: "task", description: "manage tasks" },
-  subCommands: {
-    create: defineCommand({
-      meta: { name: "create", description: "create a task" },
-      args: {
-        title: { type: "positional", required: true },
-        requirement: { type: "string", required: true, description: "requirement code (R-N)" },
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        body: { type: "string", description: "task body (markdown)" },
-        deps: { type: "string", description: "comma-separated dependency task codes (T-N,T-N)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        const c = clientFor(args);
-        const projectId = resolveProjectId(args);
-        const requirementId = await resolveReqByCode(c, projectId, args.requirement);
-        const depCodes = splitCsv(args.deps) ?? [];
-        const dependsOn = await Promise.all(
-          depCodes.map((code) => resolveTaskByCode(c, projectId, code))
-        );
-        console.log(
-          await createTask(
-            c,
-            {
-              requirementId,
-              title: args.title,
-              body: args.body,
-              dependsOn: dependsOn.length ? dependsOn : void 0
-            },
-            Boolean(args.json)
-          )
-        );
-      }
-    }),
-    update: defineCommand({
-      meta: { name: "update", description: "update a task title / body" },
-      args: {
-        code: { type: "positional", required: true, description: "task code (T-N)" },
-        title: { type: "string", description: "new title" },
-        body: { type: "string", description: "new body (markdown)" },
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        const patch = {
-          ...args.title !== void 0 ? { title: args.title } : {},
-          ...args.body !== void 0 ? { body: args.body } : {}
-        };
-        if (Object.keys(patch).length === 0) throw new Error("pass --title and/or --body");
-        const c = clientFor(args);
-        const id = await resolveTaskByCode(c, resolveProjectId(args), args.code);
-        console.log(await updateTask(c, id, patch, Boolean(args.json)));
-      }
-    }),
-    ls: defineCommand({
-      meta: { name: "ls", description: "list tasks in a requirement" },
-      args: {
-        requirement: { type: "string", required: true, description: "requirement code (R-N)" },
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        const c = clientFor(args);
-        const reqId = await resolveReqByCode(c, resolveProjectId(args), args.requirement);
-        console.log(await listTasks(c, reqId, Boolean(args.json)));
-      }
-    }),
-    get: defineCommand({
-      meta: { name: "get", description: "get a task by code (T-N)" },
-      args: {
-        code: { type: "positional", required: true },
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        const c = clientFor(args);
-        const id = await resolveTaskByCode(c, resolveProjectId(args), args.code);
-        console.log(await getTask(c, id, Boolean(args.json)));
-      }
-    }),
-    "set-status": defineCommand({
-      meta: {
-        name: "set-status",
-        description: "set task status (todo|in_progress|blocked|done|failed|cancelled)"
-      },
-      args: {
-        code: { type: "positional", required: true, description: "task code (T-N)" },
-        status: { type: "positional", required: true },
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        const c = clientFor(args);
-        const id = await resolveTaskByCode(c, resolveProjectId(args), args.code);
-        console.log(await setTaskStatus(c, id, args.status, Boolean(args.json)));
-      }
-    }),
-    rm: defineCommand({
-      meta: { name: "rm", description: "delete a task by code" },
-      args: {
-        code: { type: "positional", required: true },
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        const c = clientFor(args);
-        const id = await resolveTaskByCode(c, resolveProjectId(args), args.code);
-        console.log(await removeTask(c, id, args.code, Boolean(args.json)));
-      }
-    }),
-    comment: defineCommand({
-      meta: { name: "comment", description: "append-only task comments" },
-      subCommands: {
-        add: defineCommand({
-          meta: { name: "add", description: "add a comment to a task" },
-          args: {
-            code: { type: "positional", required: true, description: "task code (T-N)" },
-            body: { type: "positional", required: true, description: "comment text (markdown)" },
-            worker: { type: "string", description: "attribute to a worker id (omit = human)" },
-            project: { type: "string", description: "project id (overrides .baton.json)" },
-            ...common
-          },
-          run: async ({ args }) => {
-            const c = clientFor(args);
-            const id = await resolveTaskByCode(c, resolveProjectId(args), args.code);
-            const workerId = args.worker ? Number(args.worker) : void 0;
-            console.log(await addTaskComment(c, id, args.body, workerId, Boolean(args.json)));
-          }
-        }),
-        ls: defineCommand({
-          meta: { name: "ls", description: "list a task\u2019s comments in order" },
-          args: {
-            code: { type: "positional", required: true, description: "task code (T-N)" },
-            project: { type: "string", description: "project id (overrides .baton.json)" },
-            ...common
-          },
-          run: async ({ args }) => {
-            const c = clientFor(args);
-            const id = await resolveTaskByCode(c, resolveProjectId(args), args.code);
-            console.log(await listTaskComments(c, id, Boolean(args.json)));
-          }
-        })
-      }
-    })
-  }
-});
-
 // src/commands/worker/index.ts
 import { hostname as osHostname } from "node:os";
 
 // src/worker/bundled-skills.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { cpSync, existsSync as existsSync5 } from "node:fs";
-import { dirname as dirname3, join as join14 } from "node:path";
+import { dirname as dirname4, join as join14 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/worker/git-exclude.ts
 import { spawnSync } from "node:child_process";
 import { appendFileSync, existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync5 } from "node:fs";
-import { dirname as dirname2, isAbsolute as isAbsolute3, resolve as resolve3 } from "node:path";
+import { dirname as dirname3, isAbsolute as isAbsolute3, resolve as resolve3 } from "node:path";
 var ensureExcluded = (cwd, pattern) => {
   const result = spawnSync("git", ["-C", cwd, "rev-parse", "--git-path", "info/exclude"], {
     encoding: "utf8",
@@ -10034,7 +9848,7 @@ var ensureExcluded = (cwd, pattern) => {
   const path = isAbsolute3(location) ? location : resolve3(cwd, location);
   const current = existsSync4(path) ? readFileSync5(path, "utf8") : "";
   if (current.split("\n").includes(pattern)) return;
-  mkdirSync3(dirname2(path), { recursive: true });
+  mkdirSync3(dirname3(path), { recursive: true });
   appendFileSync(path, `${current && !current.endsWith("\n") ? "\n" : ""}${pattern}
 `);
 };
@@ -10043,7 +9857,7 @@ var ensureExcluded = (cwd, pattern) => {
 var SKILL_NAME = "baton-publish-artifact";
 var TARGETS = [`.claude/skills/${SKILL_NAME}`, `.agents/skills/${SKILL_NAME}`];
 var bundledSkillPath = () => {
-  const here = dirname3(fileURLToPath(import.meta.url));
+  const here = dirname4(fileURLToPath(import.meta.url));
   const candidates = [
     join14(here, "..", "skills", SKILL_NAME),
     join14(here, "..", "..", "skills", SKILL_NAME)
@@ -10651,7 +10465,7 @@ import { join as join17 } from "node:path";
 // src/worker/service-process.ts
 import { spawn as spawn3 } from "node:child_process";
 import { closeSync, existsSync as existsSync6, openSync } from "node:fs";
-import { dirname as dirname4, join as join16 } from "node:path";
+import { dirname as dirname5, join as join16 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var START_TIMEOUT_MS = 1e4;
 var isWrapperMessage = (message) => {
@@ -10661,7 +10475,7 @@ var isWrapperMessage = (message) => {
   return value.type === "error" && typeof value.error === "string";
 };
 var binPath = () => {
-  const here = dirname4(fileURLToPath2(import.meta.url));
+  const here = dirname5(fileURLToPath2(import.meta.url));
   const devShim = join16(here, "..", "..", "bin", "baton.mjs");
   return existsSync6(devShim) ? devShim : fileURLToPath2(import.meta.url);
 };
@@ -10823,7 +10637,7 @@ import { spawn as spawn4 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { existsSync as existsSync7 } from "node:fs";
 import { mkdir as mkdir6, rm as rm3, stat as stat5 } from "node:fs/promises";
-import { dirname as dirname5, join as join21 } from "node:path";
+import { dirname as dirname6, join as join21 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
 
@@ -11086,7 +10900,7 @@ var stopRecordedRunner = async (record, expected, graceMs = 5e3) => {
 
 // src/worker/session-supervisor.ts
 var binPath2 = () => {
-  const here = dirname5(fileURLToPath3(import.meta.url));
+  const here = dirname6(fileURLToPath3(import.meta.url));
   const devShim = join21(here, "..", "..", "bin", "baton.mjs");
   return existsSync7(devShim) ? devShim : fileURLToPath3(import.meta.url);
 };
@@ -11332,7 +11146,7 @@ var import_websocket_server = __toESM(require_websocket_server(), 1);
 import { existsSync as existsSync8, readdirSync as readdirSync2 } from "node:fs";
 import { createRequire as createModuleRequire } from "node:module";
 import { homedir as homedir5 } from "node:os";
-import { dirname as dirname6, join as join22 } from "node:path";
+import { dirname as dirname7, join as join22 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 var MAX_TERMINALS = 10;
 var claudePtyCommand = (agentSessionId, hasJsonl, env = process.env) => ({
@@ -11353,7 +11167,7 @@ var piPtyCommand = (agentSessionId, env = process.env) => {
   const override = env.BATON_PI_BIN?.trim();
   if (override) return { file: override, args };
   const entry = fileURLToPath4(import.meta.resolve("@earendil-works/pi-coding-agent"));
-  return { file: process.execPath, args: [join22(dirname6(entry), "bundle", "cli.js"), ...args] };
+  return { file: process.execPath, args: [join22(dirname7(entry), "bundle", "cli.js"), ...args] };
 };
 var hasSessionJsonl = (agentSessionId) => {
   const root = join22(homedir5(), ".claude", "projects");
@@ -11558,7 +11372,7 @@ var runWorkerDaemon = async (cfg, client, signal) => {
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { dirname as dirname7, join as join23 } from "node:path";
+import { dirname as dirname8, join as join23 } from "node:path";
 var machineIdPath = (env = process.env) => join23(env.XDG_DATA_HOME ?? join23(env.HOME ?? homedir6(), ".local/share"), "baton", "machine-id");
 var readOrCreateMachineId = (path = machineIdPath()) => {
   if (existsSync9(path)) {
@@ -11566,7 +11380,7 @@ var readOrCreateMachineId = (path = machineIdPath()) => {
     if (s) return s;
   }
   const id = randomUUID3();
-  mkdirSync5(dirname7(path), { recursive: true });
+  mkdirSync5(dirname8(path), { recursive: true });
   writeFileSync5(path, `${id}
 `, "utf8");
   return id;
@@ -11576,7 +11390,7 @@ var readOrCreateMachineId = (path = machineIdPath()) => {
 var projectArg = {
   project: { type: "string", description: "project id (overrides .baton.json)" }
 };
-var positiveId = (raw) => {
+var positiveId2 = (raw) => {
   const id = Number(raw);
   if (!Number.isSafeInteger(id) || id <= 0) throw new Error("positive id required");
   return id;
@@ -11585,12 +11399,12 @@ var workerTemplatesCommand = defineCommand({
   meta: { name: "templates", description: "list worker creation templates for a project" },
   args: { ...projectArg, ...common },
   run: async ({ args }) => {
-    const list = await clientFor(args).workerCreations.templates(positiveId(resolveProjectId(args)));
+    const list = await clientFor(args).workerCreations.templates(positiveId2(resolveProjectId(args)));
     console.log(renderList(list, fmtWorkerTemplate, Boolean(args.json)));
   }
 });
 var workerCreateCommand = defineCommand({
-  meta: { name: "create", description: "request a worker from the mini template (asynchronous)" },
+  meta: { name: "create", description: "request a worker from a template (asynchronous)" },
   args: {
     ...projectArg,
     ...common,
@@ -11600,7 +11414,15 @@ var workerCreateCommand = defineCommand({
       description: "mini-glm-codeplan | mini-dashscope-codeplan | mini-codex"
     },
     name: { type: "string", required: true, description: "worker name" },
-    agentKind: { type: "string", description: AGENT_KINDS.join(", ") }
+    agentKind: { type: "string", description: AGENT_KINDS.join(", ") },
+    repoPath: {
+      type: "string",
+      description: "share an existing worker's directory in this project (default: a new one)"
+    },
+    host: {
+      type: "string",
+      description: "host name or id (default: the workspace's only host)"
+    }
   },
   run: async ({ args }) => {
     if (!isWorkerTemplateId(args.template)) throw new Error("invalid worker template");
@@ -11610,14 +11432,16 @@ var workerCreateCommand = defineCommand({
       throw new Error("agentKind is not supported by this template");
     const name = args.name.trim();
     if (!name) throw new Error("worker name required");
-    const creation = await clientFor(args).workerCreations.create(
-      positiveId(resolveProjectId(args)),
-      {
-        templateId: args.template,
-        name,
-        agentKind
-      }
-    );
+    const client = clientFor(args);
+    const projectId = positiveId2(resolveProjectId(args));
+    const host2 = args.host ? findHost(await client.workerCreations.hosts(projectId), args.host) : null;
+    const creation = await client.workerCreations.create(projectId, {
+      templateId: args.template,
+      name,
+      agentKind,
+      ...args.repoPath ? { repoPath: args.repoPath } : {},
+      ...host2 ? { hostId: host2.id } : {}
+    });
     console.log(renderOne(creation, fmtWorkerCreation, Boolean(args.json)));
   }
 });
@@ -11628,7 +11452,7 @@ var workerCreationCommand = defineCommand({
       args: { ...projectArg, ...common },
       run: async ({ args }) => {
         const list = await clientFor(args).workerCreations.listByProject(
-          positiveId(resolveProjectId(args))
+          positiveId2(resolveProjectId(args))
         );
         console.log(renderList(list, fmtWorkerCreation, Boolean(args.json)));
       }
@@ -11636,7 +11460,7 @@ var workerCreationCommand = defineCommand({
     get: defineCommand({
       args: { ...common, id: { type: "positional", required: true } },
       run: async ({ args }) => {
-        const creation = await clientFor(args).workerCreations.get(positiveId(args.id));
+        const creation = await clientFor(args).workerCreations.get(positiveId2(args.id));
         console.log(renderOne(creation, fmtWorkerCreation, Boolean(args.json)));
       }
     })
@@ -11928,13 +11752,14 @@ var workspace = defineCommand({
 var main = defineCommand({
   meta: {
     name: "baton",
-    description: "baton \u2014 run a worker daemon; manage projects / requirements / tasks / sessions"
+    description: "baton \u2014 run a worker daemon; manage projects / sessions"
   },
   // Order matters: high-level verbs first so --help shows them on top.
   subCommands: {
     init,
     worker,
     provisioner,
+    host,
     session,
     service,
     artifact,
@@ -11943,9 +11768,7 @@ var main = defineCommand({
     relay,
     channel,
     workspace,
-    project,
-    requirement,
-    task
+    project
   }
 });
 runMain(main);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lesscap/baton-cli",
-  "version": "0.9.5",
+  "version": "0.9.7",
   "license": "MIT",
   "publishConfig": {
     "access": "public"