@join-pantheon/cli 0.19.1 → 0.21.0

package/dist/worker.js

@@ -10,6 +10,7 @@ import { applyAnswer, loadPolicy, mayAsk, needsSelfUpgrade, recordAsk, savePolic
 import { agentHookStates, repairHook } from "./notify.js";
 import { fence, assess } from "./untrusted.js";
 import { allowed, recordRun } from "./spend.js";
+import { loadProfile } from "./profile.js";
 import { clip, workerDoneNotice } from "./brief.js";
 import { loadPersonas, matchPersona, personaByName, personaMatches, effectivePolicy, personaBrief, describePersona, } from "./persona.js";
 import { isContinuationFor, LIMITS, shouldDeferToHuman } from "./protocol.js";
@@ -23,26 +24,64 @@ const isRepo = (cwd) => {
         return false;
     }
 };
-export function prepareWorktree(project, scratch, goal, log) {
-    const branch = `pantheon/${goal}`;
+export function prepareWorktree(project, scratch, goal, log, branch = `pantheon/${goal}`, base = null) {
     const worktree = join(scratch, goal);
-    if (existsSync(join(worktree, ".git")))
-        return { branch, worktree };
-    mkdirSync(scratch, { recursive: true });
+    const reuse = existsSync(join(worktree, ".git"));
+    if (!reuse)
+        mkdirSync(scratch, { recursive: true });
     if (!isRepo(project)) {
+        if (reuse)
+            return { branch, worktree, baseRef: "", baseSha: "" };
         mkdirSync(worktree, { recursive: true });
         log(`  scratch  ${worktree} — ${project} is not a git repo, so there is no worktree and nothing to deliver`);
-        return { branch: "", worktree };
+        return { branch: "", worktree, baseRef: "", baseSha: "" };
     }
+    if (!reuse) {
+        try {
+            git(project, "fetch", "--quiet", "origin");
+        }
+        catch { }
+    }
+    const exists = (ref) => { try {
+        git(project, "rev-parse", "--verify", "--quiet", `${ref}^{commit}`);
+        return true;
+    }
+    catch {
+        return false;
+    } };
+    const remoteHead = () => { try {
+        return git(project, "symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD");
+    }
+    catch {
+        return null;
+    } };
+    const candidates = [base ? `origin/${base}` : null, base, remoteHead()].filter((c) => !!c);
+    const baseRef = candidates.find(exists) ?? git(project, "rev-parse", "--abbrev-ref", "HEAD");
+    const baseSha = git(project, "rev-parse", baseRef);
+    if (reuse)
+        return { branch, worktree, baseRef, baseSha };
     const has = git(project, "branch", "--list", branch).length > 0;
-    const base = git(project, "rev-parse", "--abbrev-ref", "HEAD");
     if (has)
         git(project, "worktree", "add", worktree, branch);
     else
-        git(project, "worktree", "add", worktree, "-b", branch, base);
+        git(project, "worktree", "add", worktree, "-b", branch, baseRef);
     excludeRunFiles(worktree);
-    log(`  worktree ${worktree} on ${branch} (from ${base})`);
-    return { branch, worktree };
+    log(`  worktree ${worktree} on ${branch} (from ${baseRef} ${baseSha.slice(0, 7)})`);
+    return { branch, worktree, baseRef, baseSha };
+}
+export function branchName(space, goalId, title) {
+    const slug = (title ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40).replace(/-+$/, "");
+    return `pantheon/${space}/${slug ? `${slug}-${goalId.slice(-4)}` : goalId}`;
+}
+export function baseNote(baseRef, baseSha) {
+    if (!baseSha)
+        return "";
+    return `
+
+YOUR BRANCH STARTS AT ${baseSha.slice(0, 12)} (${baseRef}, fetched from origin just now).
+  Keep it to this one purpose: no unrelated commits may ride along, and never rebase it onto
+  another branch's unmerged work. When you DELIVER, name this base too (pantheon_send base=${baseSha.slice(0, 12)})
+  so your peer can check that nothing else came with it.`;
 }
 const RUN_DROPPINGS = [".pantheon-task.md", ".pantheon-run.log", ".pantheon-mcp.json", ".pantheon/"];
 export function excludeRunFiles(worktree) {
@@ -136,22 +175,50 @@ DO THIS
 There is no human in this session. Do not ask for approval; you will not get an answer.
 Act, reply if a reply is owed, then finish.`;
 }
+let fleetLock = null;
 export class Worker {
     cfg;
     opts;
     running = false;
     done = [];
     stopped = false;
+    personasOnDisk = 0;
+    personas() {
+        const all = loadPersonas(this.opts.project, this.opts.home);
+        this.personasOnDisk = all.length;
+        const mine = all.filter((p) => {
+            if (p.spaces && p.spaces.length)
+                return p.spaces.includes(this.cfg.space) || (!!this.cfg.spaceId && p.spaces.includes(this.cfg.spaceId));
+            if (p.scope === "user" && this.opts.requirePersonaSpaces)
+                return false;
+            return true;
+        });
+        for (const p of all) {
+            if (mine.includes(p) || this.warnedPersona.has(p.file))
+                continue;
+            this.warnedPersona.add(p.file);
+            this.opts.log(p.spaces?.length
+                ? `  persona ${p.name} skipped — its spaces: line does not name "${this.cfg.space}"`
+                : `  persona ${p.name} skipped — a user-scope persona on a machine in several teams needs a spaces: line`);
+        }
+        return mine;
+    }
+    warnedPersona = new Set();
     skipLogged = new Set();
     contQueue = [];
     contDone = new Set();
     failedRuns = new Map();
     lastState = "";
     busyObservedSince = null;
+    client = null;
+    lastHold = "";
     constructor(cfg, opts) {
         this.cfg = cfg;
         this.opts = opts;
     }
+    repoBase() {
+        return this.client?.repos.find((r) => r.fingerprint === this.cfg.repo)?.base ?? null;
+    }
     get jobs() {
         return this.done;
     }
@@ -160,16 +227,19 @@ export class Worker {
         if (this.runHomeDir)
             return this.runHomeDir;
         const base = this.opts.home ?? process.env.PANTHEON_HOME ?? join(homedir(), ".pantheon");
-        const dir = join(base, "run-homes", encodeURIComponent(this.cfg.space));
+        const dir = join(base, "run-homes", encodeURIComponent(this.cfg.spaceId ?? this.cfg.space));
         mkdirSync(dir, { recursive: true, mode: 0o700 });
         writeFileSync(join(dir, "config.json"), JSON.stringify(this.cfg, null, 2) + "\n", { mode: 0o600 });
         this.runHomeDir = dir;
         return dir;
     }
     selectPersona(client, o) {
-        const personas = loadPersonas(this.opts.project, this.opts.home);
-        if (!personas.length && !this.opts.persona)
-            return {};
+        const personas = this.personas();
+        if (!personas.length && !this.opts.persona) {
+            return this.personasOnDisk
+                ? { skip: `personas exist on this machine but none covers "${this.cfg.space}" — add \`spaces: ${this.cfg.space}\` to one, or pantheon persona init default in this repo` }
+                : {};
+        }
         const ctx = {
             ...(client.recentFrom(o.ref) ? { from: client.recentFrom(o.ref) } : {}),
             kind: o.kind,
@@ -193,6 +263,7 @@ export class Worker {
     async run() {
         const client = new PantheonClient(this.cfg, undefined, { role: "worker" });
         await client.connect();
+        this.client = client;
         const agentLabel = this.opts.agentCmd
             ? this.opts.agentCmd
             : (() => { try {
@@ -207,7 +278,7 @@ export class Worker {
         this.opts.log(`  scratch ${resolve(this.opts.scratch)}`);
         this.opts.log(`  agent   ${agentLabel}`);
         this.opts.log(`  policy  ${this.opts.maxRunsPerHour} runs/hour, one at a time, ${this.opts.allowBash ? "bash allowed" : "edits only (bash gated)"}`);
-        const personas = loadPersonas(this.opts.project, this.opts.home);
+        const personas = this.personas();
         if (this.opts.persona && !personaByName(personas, this.opts.persona)) {
             client.close();
             throw new Error(`persona "${this.opts.persona}" not found — create it with: pantheon persona init ${this.opts.persona}`);
@@ -236,6 +307,10 @@ export class Worker {
             await this.maintain(client, arrived);
             if (this.running)
                 continue;
+            if (fleetLock && fleetLock !== this) {
+                this.writeState("watching", `waiting: a run for "${fleetLock.cfg.space}" is in progress`);
+                continue;
+            }
             const me = client.roster.find((m) => m.id === this.cfg.member);
             const liveInteractive = me?.sessions.some((s) => s.role === "interactive") ?? false;
             const grace = liveInteractive ? this.opts.graceMs : Math.min(this.opts.graceMs, 2_000);
@@ -295,6 +370,12 @@ export class Worker {
                     : me.work?.idle_since
                         ? `your session went idle ${Math.round((Date.now() - me.work.idle_since) / 1000)}s ago (< ${Math.round(this.opts.idleMs / 1000)}s)`
                         : "you have a live session and no activity signal (no wake-up hook on this machine — pantheon hook install)";
+                const until = !me.work?.busy && me.work?.idle_since ? me.work.idle_since + this.opts.idleMs : undefined;
+                const holdKey = `${me.work?.busy ? "busy" : "idle"}:${until ?? 0}`;
+                if (this.lastHold !== holdKey) {
+                    this.lastHold = holdKey;
+                    this.client?.reportWorkerState("holding", me.work?.busy ? "a turn is in flight in their live session" : me.work?.idle_since ? `their session went idle recently; waits ${Math.round(this.opts.idleMs / 1000)}s of quiet` : "their live session gave no activity signal", until);
+                }
                 if (!this.skipLogged.has(`defer:${id}`)) {
                     this.skipLogged.add(`defer:${id}`);
                     this.opts.log(`- holding ${id}: ${why} — the human wins while present`);
@@ -349,11 +430,13 @@ export class Worker {
                 }
             }
             this.running = true;
+            fleetLock = this;
             this.writeState("running", candidate ? `${candidate.kind} ${candidate.id}` : `CONTINUE ${continuation.id}`);
             const job = candidate
                 ? await this.handle(client, candidate, persona, policy)
                 : await this.handleContinuation(client, continuation, persona, policy);
             this.done.push(job);
+            this.client?.reportWorkerState("idle");
             if (candidate && !job.ok) {
                 this.failedRuns.set(candidate.id, (this.failedRuns.get(candidate.id) ?? 0) + 1);
                 if (this.failedRuns.size > 200) {
@@ -361,6 +444,8 @@ export class Worker {
                 }
             }
             this.running = false;
+            if (fleetLock === this)
+                fleetLock = null;
             this.writeState("watching", "waiting for work");
             if (this.opts.once)
                 break;
@@ -380,6 +465,8 @@ export class Worker {
     }
     async handle(client, o, persona, policy) {
         this.opts.log(`> woken by ${o.kind} ${o.id} (${o.body})${persona ? ` — persona "${persona.name}"` : ""}`);
+        this.lastHold = "";
+        this.client?.reportWorkerState("running", `${o.kind} ${o.id}`);
         const trigger = client.recent(o.ref) ?? `(the triggering act ${o.ref} is not in this session's buffer)`;
         return this.runJob(client, o, persona, policy, (branch) => buildBrief(o, trigger, branch, persona), true);
     }
@@ -391,6 +478,8 @@ export class Worker {
             body: `${act.act} from ${act.from}: ${act.body.split("\n")[0]?.slice(0, 120) ?? ""}`,
         };
         this.opts.log(`> continuing from ${act.act} ${act.id} by ${act.from}${persona ? ` — persona "${persona.name}"` : ""}`);
+        this.lastHold = "";
+        this.client?.reportWorkerState("running", `${act.act} ${act.id}`);
         const trigger = client.recent(act.id) ?? `(${act.act} ${act.id} is not in this session's buffer)`;
         return this.runJob(client, o, persona, policy, (branch) => buildContinuationBrief(act, trigger, branch, persona), false);
     }
@@ -399,17 +488,18 @@ export class Worker {
         if (this.opts.allowBash && !policy.allowBash && persona) {
             this.opts.log(`  bash    off for this run — persona "${persona.name}" says allow_bash: false`);
         }
-        let branch = `pantheon/${goal}`;
+        let branch = branchName(this.cfg.space, goal, this.client?.goals.get(goal)?.title);
         let worktree = join(this.opts.scratch, goal);
+        let baseRef = "", baseSha = "";
         try {
-            ({ branch, worktree } = prepareWorktree(this.opts.project, this.opts.scratch, goal, this.opts.log));
+            ({ branch, worktree, baseRef, baseSha } = prepareWorktree(this.opts.project, this.opts.scratch, goal, this.opts.log, branch, this.repoBase()));
         }
         catch (e) {
             const detail = `could not prepare a worktree: ${e.message}`;
             this.opts.log(`! ${detail}`);
             return { obligation: o, branch, worktree, ok: false, detail };
         }
-        const brief = makeBrief(branch);
+        const brief = makeBrief(branch) + baseNote(baseRef, baseSha);
         writeFileSync(join(worktree, ".pantheon-task.md"), brief);
         let command;
         let args;
@@ -420,7 +510,7 @@ export class Worker {
                 const plan = headlessSpawn({
                     backend: { id: "claude-code", label: "Claude Code", binaries: ["claude"] },
                     binary: this.opts.agentCmd,
-                    prompt: brief, worktree, cfg: this.cfg, branch, allowBash: policy.allowBash, runHome,
+                    prompt: brief, worktree, cfg: this.cfg, branch, allowBash: policy.allowBash, runHome, ...(baseSha ? { base: baseSha } : {}), goal,
                 });
                 materializeSpawnFiles(worktree, plan);
                 ({ command, args, env } = { command: plan.command, args: plan.args, env: { ...env, ...plan.env } });
@@ -466,6 +556,13 @@ export class Worker {
             }
             catch { }
         }
+        else if (ok && this.opts.notify && loadProfile(this.cfg).notifications?.worker_done) {
+            try {
+                const n = workerDoneNotice({ ok, triggeredBy, summary });
+                this.opts.notify({ title: n.title, subtitle: n.subtitle, body: n.body, eyebrow: "Pantheon · worker finished" });
+            }
+            catch { }
+        }
         this.opts.log(ok ? `< handled ${o.id} on ${branch}`
             : !exited ? `! run failed for ${o.id}: ${detail.split("\n")[0]} (see ${runLog})`
                 : `! run exited cleanly but sent no act for ${o.id} — see ${runLog}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@join-pantheon/cli",
-  "version": "0.19.1",
+  "version": "0.21.0",
   "description": "Let your coding agent collaborate directly with your teammates' agents — ask, agree an interface, and deliver, without a human relaying messages.",
   "type": "module",
   "bin": {
@@ -13,7 +13,7 @@
     "build": "rm -rf dist && tsc -p .",
     "dev": "tsc -p . --watch",
     "relay": "node dist/cli.js relay",
-    "test": "node --test dist/test/*.test.js",
+    "test": "PANTHEON_HOME=\"$(mktemp -d)\" node --test --test-force-exit dist/test/*.test.js",
     "prepare": "npm run build",
     "prepublishOnly": "npm run build && node --test dist/test/*.test.js",
     "start": "node dist/cli.js relay"