@join-pantheon/cli 0.33.5 → 0.33.6-rc.1

package/dist/notifier.js

@@ -14,6 +14,7 @@ import { loadPolicy } from "./worker-policy.js";
 import { wakeAlerted } from "./continued.js";
 import { cliOnPath, detectAvailable } from "./agents.js";
 import { whichPantheon } from "./service.js";
+import { removalFor, removalHolds, removalRefusal, removalWords, removedLine, removedNotice, takeTold } from "./removed.js";
 export const DEFAULT_REMINDER_MS = 4 * 60 * 60 * 1_000;
 export const PASSED_OVER_EVERY_MS = 3_600_000;
 export const MAX_REMINDERS = 4;
@@ -145,7 +146,37 @@ export class HumanNotifier {
     stop() {
         this.stopped = true;
     }
+    async waitWhileRemoved() {
+        const team = { space: this.cfg.space, spaceId: this.cfg.spaceId ?? null, relay: this.cfg.relay, member: this.cfg.member };
+        const now = this.opts.now ?? Date.now;
+        let said = false;
+        while (!this.stopped) {
+            let r = null;
+            try {
+                r = removalFor(team);
+            }
+            catch {
+                return;
+            }
+            if (!removalHolds(r, now()))
+                return;
+            if (!said) {
+                said = true;
+                const words = removalWords(team, r.by);
+                this.opts.log(`! ${removedLine(words)}`);
+                try {
+                    if (takeTold(team))
+                        await (this.opts.send ?? sendDesktopNotification)(removedNotice(words));
+                }
+                catch { }
+            }
+            await new Promise((res) => setTimeout(res, this.opts.removedPollMs ?? 60_000));
+        }
+    }
     async run() {
+        await this.waitWhileRemoved();
+        if (this.stopped)
+            return;
         const client = new PantheonClient(this.cfg, undefined, { role: "cli" });
         await client.connect();
         const stateFile = this.opts.stateFile ?? join(CONFIG_DIR, "notifier-state.json");
@@ -155,7 +186,21 @@ export class HumanNotifier {
         let state = readState(stateFile);
         this.opts.log(`notifier online as ${this.cfg.member}`);
         this.opts.log(`  reminders after ${Math.round(this.opts.reminderMs / 60_000)} minutes, then doubling to daily, ${MAX_REMINDERS} at most — after that a decision waits on pantheon brief and the menu bar`);
+        let removedSaid = false;
         while (!this.stopped) {
+            if (client.removedFrom && !removedSaid) {
+                removedSaid = true;
+                const team = { space: this.cfg.space, spaceId: this.cfg.spaceId ?? null, relay: this.cfg.relay, member: this.cfg.member };
+                const r = removalWords(team, client.removedFrom.by);
+                this.opts.log(`! ${removedLine(r)}`);
+                try {
+                    if (takeTold(team))
+                        await send(removedNotice(r));
+                }
+                catch { }
+            }
+            else if (!client.removedFrom)
+                removedSaid = false;
             const pruned = pruneNotificationState(state, client.obligations, this.cfg.member, now());
             let dirty = JSON.stringify(pruned) !== JSON.stringify(state);
             state = pruned;
@@ -268,22 +313,27 @@ export async function runNotifiers(teams, o) {
         let wait = o.retryMs ?? 30_000;
         for (;;) {
             failing.delete(i);
+            let removed = false;
             try {
                 await t.run();
                 return;
             }
             catch (e) {
-                failing.add(i);
-                o.log(`[${t.label}] ! not connecting: ${e.message.split("\n")[0]}`);
-                if (failing.size === teams.length) {
-                    gaveUp = true;
-                    giveUp();
-                    return;
+                removed = !!removalRefusal(e.message);
+                if (!removed) {
+                    failing.add(i);
+                    o.log(`[${t.label}] ! not connecting: ${e.message.split("\n")[0]}`);
+                    if (failing.size === teams.length) {
+                        gaveUp = true;
+                        giveUp();
+                        return;
+                    }
                 }
             }
             if (gaveUp || t.stopped?.())
                 return;
-            o.log(`[${t.label}]   the other teams' alerts keep running; trying this one again in ${Math.round(wait / 1000)}s`);
+            if (!removed)
+                o.log(`[${t.label}]   the other teams' alerts keep running; trying this one again in ${Math.round(wait / 1000)}s`);
             await sleep(wait);
             if (gaveUp || t.stopped?.())
                 return;

package/dist/persona.js

@@ -2,9 +2,10 @@ import { lstatSync, readFileSync, readdirSync, realpathSync, writeFileSync, exis
 import { homedir } from "node:os";
 import { join, sep } from "node:path";
 import { CONFIG_DIR } from "./config.js";
+import { parseRunMinutes, RUN_MINUTES } from "./worker-policy.js";
 export const PERSONA_INSTRUCTIONS_MAX = 8_000;
 const KNOWN_KEYS = new Set([
-    "allow_bash", "max_runs_per_hour", "max_runs_per_day",
+    "allow_bash", "max_runs_per_hour", "max_runs_per_day", "max_run_minutes",
     "wake_by", "kinds", "goals", "agent", "name", "spaces",
 ]);
 const list = (v) => v.split(",").map((s) => s.trim()).filter(Boolean);
@@ -55,6 +56,14 @@ export function parsePersona(name, scope, file, raw) {
                         p.warnings.push(`${key} must be a number, got "${value}"`);
                     break;
                 }
+                case "max_run_minutes": {
+                    const n = parseRunMinutes(value);
+                    if (n !== null)
+                        p.maxRunMinutes = n;
+                    else
+                        p.warnings.push(`max_run_minutes must be a whole number of minutes from ${RUN_MINUTES.min} to ${RUN_MINUTES.max}, got "${value}"`);
+                    break;
+                }
                 case "wake_by":
                     p.wakeBy = list(value);
                     break;
@@ -212,6 +221,7 @@ export const PERSONA_TEMPLATE = `---
 # allow_bash: false            # runs handled here never get shell, even with --allow-bash
 # max_runs_per_hour: 6
 # max_runs_per_day: 20
+# max_run_minutes: 30          # a run it handles is stopped after this long (only lowers the machine's limit)
 # wake_by: alice, bob          # only these peers' requests are handled by this persona
 # kinds: ANSWER, ACCEPT        # ANSWER (asks), ACCEPT (verdicts), REVISE (objections), CONTINUE (replies/deliveries)
 # goals: launch-*              # only goals whose id or title matches
@@ -239,24 +249,38 @@ export function initPersona(name, scope, projectDir = process.cwd(), home) {
     writeFileSync(file, PERSONA_TEMPLATE);
     return file;
 }
+export function olderTeammatesNote(p) {
+    if (p.scope !== "project" || p.broken)
+        return null;
+    const newer = p.maxRunMinutes !== undefined ? ["max_run_minutes"] : [];
+    if (!newer.length)
+        return null;
+    return `uses ${newer.join(", ")}, which Pantheon before 0.33.6 does not know: a teammate's worker on an older version reads this committed persona as broken and skips it until they upgrade (pantheon upgrade). Keep it in your own ~/.pantheon/personas instead, or wait until the team is on 0.33.6`;
+}
 export function describePersona(p) {
-    const rules = [];
+    const filters = [];
+    if (p.spaces?.length)
+        filters.push(`spaces ${p.spaces.join(" / ")}`);
     if (p.wakeBy?.length)
-        rules.push(`wake_by ${p.wakeBy.join(",")}`);
+        filters.push(`wake_by ${p.wakeBy.join(",")}`);
     if (p.kinds?.length)
-        rules.push(`kinds ${p.kinds.join(",")}`);
+        filters.push(`kinds ${p.kinds.join(",")}`);
     if (p.goals?.length)
-        rules.push(`goals ${p.goals.join(",")}`);
+        filters.push(`goals ${p.goals.join(",")}`);
+    const limits = [];
     if (p.allowBash === false)
-        rules.push("bash off");
+        limits.push("bash off");
     if (p.maxRunsPerHour !== undefined)
-        rules.push(`≤${p.maxRunsPerHour}/h`);
+        limits.push(`≤${p.maxRunsPerHour}/h`);
     if (p.maxRunsPerDay !== undefined)
-        rules.push(`≤${p.maxRunsPerDay}/d`);
+        limits.push(`≤${p.maxRunsPerDay}/d`);
+    if (p.maxRunMinutes !== undefined)
+        limits.push(`≤${p.maxRunMinutes}min/run`);
     if (p.agent)
-        rules.push(`agent ${p.agent}`);
+        limits.push(`agent ${p.agent}`);
     if (p.broken)
         return `${p.name} (${p.scope})  BROKEN — takes no work until fixed: ${p.broken}`;
-    return `${p.name} (${p.scope})${rules.length ? `  ${rules.join(", ")}` : "  matches everything"}`;
+    const rules = filters.length ? [...filters, ...limits].join(", ") : `matches everything${limits.length ? `; ${limits.join(", ")}` : ""}`;
+    return `${p.name} (${p.scope})  ${rules}`;
 }
 //# sourceMappingURL=persona.js.map

package/dist/pickup.js

@@ -0,0 +1,82 @@
+import { LIMITS, WORKER_REASONS } from "./protocol.js";
+export function inWords(ms) {
+    if (ms < 60_000)
+        return "under a minute";
+    const m = Math.round(ms / 60_000);
+    if (m < 60)
+        return `about ${m} minute${m === 1 ? "" : "s"}`;
+    const h = Math.round(m / 60);
+    return `about ${h} hour${h === 1 ? "" : "s"}`;
+}
+const UNAVAILABLE = {
+    no_agent: "Claude Code (or another agent CLI) isn't installed there",
+    kiro_only: "only Kiro is installed there, and Kiro answers in live sessions only",
+    not_signed_in: "its agent CLI isn't signed in",
+    unsandboxed_off: "its only agent has no sandbox, and it is set to leave requests for its person",
+    no_agent_choice: "no agent there can be chosen for a run",
+    sandbox_unavailable: "its Linux sandbox can't start",
+};
+function reasonOf(w) {
+    if (w.reason && WORKER_REASONS.includes(w.reason))
+        return w.reason;
+    const m = /\[([a-z_]{3,40})\]\s*$/.exec(w.detail ?? "");
+    return m && WORKER_REASONS.includes(m[1]) ? m[1] : undefined;
+}
+export function pickupEstimate(peer, o = {}) {
+    const now = o.now ?? Date.now();
+    const who = peer.id;
+    const live = (peer.sessions ?? []).filter((s) => s.role === "interactive").length > 0;
+    const workerOn = (peer.sessions ?? []).some((s) => s.role === "worker");
+    if (o.mayWake === false) {
+        return { kind: "no-wake", says: `${who}'s worker does not take your requests (the team does not let you wake it), so this waits for ${who}${live ? ", who has a live session open" : ""}` };
+    }
+    if (!workerOn) {
+        return { kind: "offline", says: live
+                ? `${who}'s worker is offline; ${who} has a live session open, which sees this when their agent next looks`
+                : `${who}'s worker is offline, so this waits until ${who} is back` };
+    }
+    const w = peer.worker && now - peer.worker.at < 15 * 60_000 ? peer.worker : undefined;
+    const reason = w ? reasonOf(w) : undefined;
+    if (w && (w.state === "unavailable" || (reason && UNAVAILABLE[reason]))) {
+        return { kind: "unavailable", says: `${who}'s machine can't take requests yet${reason && UNAVAILABLE[reason] ? `: ${UNAVAILABLE[reason]}` : ""}` };
+    }
+    if (w?.state === "running") {
+        const mine = !!o.about && ((!!o.about.ref && w.ref === o.about.ref) || (!!o.about.goal && !w.ref && w.goal === o.about.goal));
+        return mine
+            ? { kind: "working", says: `${who}'s agent is working on this now` }
+            : { kind: "queued", says: `${who}'s worker is busy with another request; this one is next` };
+    }
+    const idleMs = typeof w?.idle_ms === "number" ? w.idle_ms : undefined;
+    const wait = (ms) => (idleMs !== undefined ? inWords(ms) : `${inWords(ms)} (if they kept the default wait)`);
+    const lifts = w?.state === "holding" && w.until && w.until > now ? w.until - now : null;
+    if (w?.state === "holding" && reason === "capped") {
+        return { kind: "holding", says: `${who}'s worker has used its runs for now (its hourly or daily cap)${lifts ? `; it can take this in ${inWords(lifts)}` : ", so this waits"}` };
+    }
+    if (w?.state === "holding" && reason === "outage") {
+        return { kind: "holding", says: `${who}'s agent is out for now (a usage limit or an outage)${lifts ? `; it should be back in ${inWords(lifts)}` : ""}` };
+    }
+    if (w?.state === "holding" && reason === "awaiting_wake_approval") {
+        return { kind: "holding", says: `${who}'s machine may be waiting for ${who} to approve a teammate before it starts their work` };
+    }
+    if (w?.state === "holding" && reason === "busy_elsewhere") {
+        return { kind: "queued", says: `${who}'s machine is busy with another request (possibly for another team); this one waits until it finishes` };
+    }
+    if (w?.state === "holding" && reason === "unknown") {
+        return { kind: "holding", says: `${who}'s worker is holding requests for now` };
+    }
+    if (lifts)
+        return { kind: "holding", says: `${who}'s agent will pick this up in ${inWords(lifts)}` };
+    if (live && (peer.work?.busy || reason === "busy_turn")) {
+        return { kind: "keyboard", says: `${who} is at their keyboard; their agent picks this up ${wait(idleMs ?? LIMITS.workerIdleMs)} after they go quiet` };
+    }
+    if (live && peer.work?.idle_since) {
+        const left = peer.work.idle_since + (idleMs ?? LIMITS.workerIdleMs) - now;
+        if (left > 0)
+            return { kind: "keyboard", says: `${who} was at their keyboard moments ago; their agent picks this up in ${wait(left)} if they stay quiet` };
+    }
+    if (live && (!peer.work || reason === "no_signal")) {
+        return { kind: "keyboard", says: `${who} has a live session open (with no activity signal), so their agent sees this there; their worker takes it once that session closes` };
+    }
+    return { kind: "soon", says: `${who}'s agent should pick this up within a minute, if nothing on their machine holds it` };
+}
+//# sourceMappingURL=pickup.js.map

package/dist/profile.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { CONFIG_DIR } from "./config.js";
+import { isCatchAllDomain } from "./protocol.js";
 export const AGENT_SURFACES = ["codex", "claude-code", "cursor", "copilot", "kiro"];
 export const SURFACE_BUNDLE_IDS = {
     codex: "com.openai.codex",
@@ -176,6 +177,28 @@ export function teamProfile(profile, ...forSpace) {
 export function profileForTeam(cfg, file = profilePath()) {
     return teamProfile(loadProfile(cfg, file), cfg.spaceId, cfg.space);
 }
+export function dropCatchAllClaims(profile) {
+    const dropped = new Set();
+    const clean = (a) => {
+        if (!a)
+            return a;
+        const out = {};
+        for (const [d, m] of Object.entries(a)) {
+            if (isCatchAllDomain(d))
+                dropped.add(d);
+            else
+                out[d] = m;
+        }
+        return out;
+    };
+    const authority = clean(profile.authority);
+    const spaces = profile.spaces
+        ? Object.fromEntries(Object.entries(profile.spaces).map(([k, v]) => [k, v.authority ? { ...v, authority: clean(v.authority) } : v]))
+        : undefined;
+    if (!dropped.size)
+        return { profile, dropped: [] };
+    return { profile: { ...profile, authority, ...(spaces ? { spaces } : {}) }, dropped: [...dropped].sort() };
+}
 export function organizationProfile(profile, ...forSpace) {
     const team = teamProfile(profile, ...forSpace);
     return {
@@ -185,7 +208,7 @@ export function organizationProfile(profile, ...forSpace) {
         title: profile.human.title,
         responsibilities: cleanList(team.human.responsibilities),
         authority: Object.fromEntries(Object.entries(team.authority)
-            .map(([domain, mode]) => [normalize(domain), mode]).filter(([domain]) => !!domain)),
+            .map(([domain, mode]) => [normalize(domain), mode]).filter(([domain]) => !!domain && !isCatchAllDomain(domain))),
         decision_keywords: cleanKeywords(team.decision_keywords),
         capabilities: cleanList(profile.capabilities),
         delegations: cleanDelegations(profile.delegations),

package/dist/protocol.js

@@ -24,6 +24,15 @@ export const UPKEEP_AGENT = "pantheon-upkeep";
 export function siblingSessions(roster, member, session) {
     return (roster.find((m) => m.id === member)?.sessions ?? []).filter((s) => s.id !== session && s.agent !== UPKEEP_AGENT);
 }
+export const CATCH_ALL_DOMAINS = [
+    "all", "*", "everything", "every", "any", "anything", "everyone", "anyone", "whatever",
+    "none", "nothing", "n/a", "all-domains", "all_domains",
+];
+export const normalizeDomainName = (d) => d.normalize("NFKC").trim().toLowerCase();
+export function isCatchAllDomain(domain) {
+    const d = normalizeDomainName(domain);
+    return !d || CATCH_ALL_DOMAINS.includes(d) || /[*?]/.test(d);
+}
 export const LIMITS = {
     bodyChars: 32000,
     summaryRequiredOver: 2000,
@@ -116,7 +125,7 @@ export const GoalSigSchema = z.object({
     kind: z.string().max(32).nullable().optional(),
     cert: DelegateCertSchema.optional(),
 });
-export const RELAY_FEATURES = ["act-sig", "delegate", "named-decider"];
+export const RELAY_FEATURES = ["act-sig", "delegate", "named-decider", "worker-state-2"];
 export const Hello = z.object({
     t: z.literal("hello"),
     v: z.number().int().optional(),
@@ -236,11 +245,19 @@ export const DeleteSpace = z.object({
     cid: z.string().max(64).optional(),
     confirm: z.string().min(1).max(64),
 });
+export const WORKER_REASONS = ["no_agent", "kiro_only", "not_signed_in", "unsandboxed_off", "no_agent_choice",
+    "busy_turn", "recently_active", "no_signal", "capped", "outage", "awaiting_wake_approval", "busy_elsewhere", "unknown", "sandbox_unavailable"];
+const WORK_ID = /^(cont:)?[a-z]{1,3}_[A-Za-z0-9_-]{4,64}$/;
 export const WorkerState = z.object({
     t: z.literal("worker_state"),
-    state: z.enum(["idle", "holding", "running"]),
+    state: z.enum(["idle", "holding", "running", "unavailable"]),
     detail: z.string().max(200).optional(),
     until: z.number().int().positive().optional(),
+    idle_ms: z.number().int().min(0).max(3_600_000).optional(),
+    reason: z.string().regex(/^[a-z_]{1,40}$/).optional(),
+    ref: z.string().regex(WORK_ID).optional(),
+    goal: z.string().regex(WORK_ID).optional(),
+    until_in: z.number().int().min(0).max(7 * 24 * 3600_000).optional(),
 });
 export const Inbound = z.discriminatedUnion("t", [Hello, SendAct, OpenGoal, Claim, Admit, MakeInvite, ListInvites, RevokeInvite, PublishProfile, ClearAuthority, BindRepo, DeleteSpace, WorkerState, Ping]);
 export function shouldDeferToHuman(sessions, work, opts = {}) {