@join-pantheon/cli 0.24.1 → 0.25.0

package/dist/worker-policy.js

@@ -2,6 +2,7 @@ import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { CONFIG_PATH } from "./config.js";
 export const ASK_COOLDOWN_MS = 24 * 60 * 60 * 1_000;
+export const ASK_EXPIRY_MS = 14 * 24 * 60 * 60 * 1_000;
 export function policyHome(home) {
     return home ?? process.env.PANTHEON_HOME ?? dirname(CONFIG_PATH);
 }
@@ -41,7 +42,8 @@ export function revoke(p, cap) {
 export function mayAsk(p, cap, now = Date.now()) {
     if (p.grants[cap])
         return false;
-    if (p.asks[cap])
+    const open = p.asks[cap];
+    if (open && now - open.at < ASK_EXPIRY_MS)
         return false;
     const deniedAt = p.denied[cap];
     return deniedAt === undefined || now - deniedAt >= ASK_COOLDOWN_MS;

package/dist/worker.js

@@ -14,6 +14,7 @@ import { loadContinued, markContinued } from "./continued.js";
 import { loadProfile, reservedDecisionsNote } from "./profile.js";
 import { clip } from "./brief.js";
 import { composeWorker } from "./notice.js";
+import { diagnoseRun, gitProbe } from "./run-failure.js";
 import { installedTools, preferredTool } from "./notifier.js";
 import { loadPersonas, matchPersona, personaByName, personaMatches, effectivePolicy, personaBrief, describePersona, } from "./persona.js";
 import { isContinuationFor, LIMITS, shouldDeferToHuman } from "./protocol.js";
@@ -180,6 +181,13 @@ Act, reply if a reply is owed, then finish.`;
 }
 let fleetLock = null;
 const CONTINUATION_HORIZON_MS = 24 * 60 * 60_000;
+export function answerWindow(askSeq, hint, fullScanDue) {
+    if (askSeq !== null)
+        return Math.max(0, askSeq - 1);
+    if (fullScanDue)
+        return 0;
+    return Math.max(0, hint);
+}
 export class Worker {
     cfg;
     opts;
@@ -492,10 +500,13 @@ export class Worker {
             this.done.push(job);
             this.client?.reportWorkerState("idle");
             if (candidate && !job.ok) {
-                this.failedRuns.set(candidate.id, (this.failedRuns.get(candidate.id) ?? 0) + 1);
+                const failures = (this.failedRuns.get(candidate.id) ?? 0) + 1;
+                this.failedRuns.set(candidate.id, failures);
                 if (this.failedRuns.size > 200) {
                     this.failedRuns.delete(this.failedRuns.keys().next().value);
                 }
+                if (failures >= 2 && job.diagnosis)
+                    await this.reportStuck(client, candidate, job.diagnosis);
             }
             this.running = false;
             if (fleetLock === this)
@@ -537,11 +548,22 @@ export class Worker {
         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);
     }
+    commandGrant(persona) {
+        if (persona?.allowBash === false)
+            return false;
+        const policy = loadPolicy(this.opts.home);
+        if (!useGrant(policy, "run_commands"))
+            return false;
+        savePolicy(policy, this.opts.home);
+        this.opts.log(`  bash    on for this run — your human granted run_commands`);
+        return true;
+    }
     async runJob(client, o, persona, policy, makeBrief, requireReply) {
         const goal = o.goal ?? "adhoc";
         if (this.opts.allowBash && !policy.allowBash && persona) {
             this.opts.log(`  bash    off for this run — persona "${persona.name}" says allow_bash: false`);
         }
+        const allowBash = policy.allowBash || this.commandGrant(persona);
         let branch = branchName(this.cfg.space, goal, this.client?.goals.get(goal)?.title);
         let worktree = join(this.opts.scratch, goal);
         let baseRef = "", baseSha = "";
@@ -566,14 +588,14 @@ 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, ...(baseSha ? { base: baseSha } : {}), goal,
+                    prompt: brief, worktree, cfg: this.cfg, branch, allowBash, runHome, ...(baseSha ? { base: baseSha } : {}), goal,
                 });
                 materializeSpawnFiles(worktree, plan);
                 ({ command, args, env } = { command: plan.command, args: plan.args, env: { ...env, ...plan.env } });
             }
             else {
                 const { backend, binary } = resolveAgent(policy.agent ?? this.opts.agent);
-                const plan = headlessSpawn({ backend, binary, prompt: brief, worktree, cfg: this.cfg, branch, allowBash: policy.allowBash, runHome });
+                const plan = headlessSpawn({ backend, binary, prompt: brief, worktree, cfg: this.cfg, branch, allowBash, runHome });
                 materializeSpawnFiles(worktree, plan);
                 ({ command, args, env } = { command: plan.command, args: plan.args, env: { ...env, ...plan.env } });
                 this.opts.log(`  spawn   ${command} ${args.slice(0, 3).join(" ")}…`);
@@ -607,18 +629,56 @@ export class Worker {
         }, this.opts.home);
         const sent = client.mineSince(startedAt, o.goal);
         const quiet = ok && !requireReply && sent.length === 0;
+        const diagnosis = ok ? undefined : diagnoseRun({ exited, replied, allowBash, branch, project: this.opts.project, worktree, detail, runLog }, this.opts.probe ?? gitProbe);
         if (this.opts.notify && !quiet && (!ok || loadProfile(this.cfg).notifications?.worker_done)) {
             try {
                 const reply = sent[sent.length - 1] ?? null;
-                this.opts.notify(composeWorker({ ok, triggeredBy, obligationBody: o.body, goal: o.goal ? client.goals.get(o.goal) : undefined, reply, obligationRef: o.ref }, (() => { const tools = installedTools(); return { tools, preferred: preferredTool(loadProfile(this.cfg), tools, this.opts.home) }; })()));
+                this.opts.notify(composeWorker({ ok, triggeredBy, obligationBody: o.body, goal: o.goal ? client.goals.get(o.goal) : undefined, reply, obligationRef: o.ref, ...(diagnosis ? { diagnosis } : {}) }, (() => { const tools = installedTools(); return { tools, preferred: preferredTool(loadProfile(this.cfg), tools, this.opts.home) }; })()));
             }
             catch { }
         }
         this.opts.log(quiet ? `< read ${o.id} on ${branch} — the thread was already settled, nothing sent`
             : 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}`);
-        return { obligation: o, branch, worktree, ok, detail };
+                : `! ${o.id} stopped [${diagnosis.cause}]: ${diagnosis.says} (transcript: ${runLog})`);
+        return { obligation: o, branch, worktree, ok, detail, ...(diagnosis ? { diagnosis } : {}) };
+    }
+    async reportStuck(client, o, d) {
+        const key = `stuck:${o.id}`;
+        const space = this.spaceKey();
+        if (loadContinued(space, this.opts.home).has(key))
+            return;
+        const policy = loadPolicy(this.opts.home);
+        const asking = !!d.capability && mayAsk(policy, d.capability);
+        const what = clip(o.body, 120);
+        const lines = [
+            `Two runs on this machine could not finish ${o.kind === "CONTINUE" ? "a follow-up" : `the ${o.kind}`} it owes: ${what}`,
+            ``,
+            `WHY IT STOPPED. ${d.says}`,
+            `WHAT UNBLOCKS IT. ${d.fix}`,
+            ...(d.dir && d.lines?.length ? [``, `On this machine, in ${d.dir}:`, ...d.lines.map((l) => `  ${l}`)] : []),
+            ``,
+            `Nothing was sent to the teammate who asked, and the request is still open on them.`,
+            `It will not be retried unattended — a live session here, or you, has to move it.`,
+        ];
+        if (asking) {
+            lines.push(``, `MAY THE WORKER RUN COMMANDS ON THIS MACHINE? Answer "allow always", "allow once", or "deny".`, `Today it may edit files only, which is why it could not commit or push. Allowing it lets a woken`, `run execute tests and git in its own isolated worktree — never in your checkout.`);
+        }
+        try {
+            const sent = await client.send({
+                act: "ESCALATE", goal: o.goal, ref: o.ref, after_seq: client.readSeq,
+                summary: clip(`Stuck on you: ${d.says}`, 190),
+                body: lines.join("\n"),
+            });
+            markContinued(space, key, this.opts.home);
+            if (asking && d.capability) {
+                recordAsk(policy, d.capability, sent.id);
+                savePolicy(policy, this.opts.home);
+            }
+            this.opts.log(`* escalated ${o.id}: ${d.cause}${asking ? ` (and asked for ${d.capability})` : ""}`);
+        }
+        catch (e) {
+            this.opts.log(`! could not report the stuck obligation on the ledger: ${e.message}`);
+        }
     }
     enqueueContinuations(client, arrived) {
         this.loadContinued();
@@ -678,13 +738,18 @@ export class Worker {
         const home = this.opts.home;
         {
             const policy = loadPolicy(home);
-            const open = policy.asks.self_upgrade;
             let changed = false;
-            const fromStream = arrived.find((a) => a.act === "ANSWER" && a.ref && open && a.ref === open.act);
-            const body = fromStream?.body ?? (open ? await this.fetchGrantAnswer(open.act) : null);
-            if (open && body !== null) {
+            for (const cap of Object.keys(policy.asks)) {
+                const open = policy.asks[cap];
+                if (!open)
+                    continue;
+                const fromStream = arrived.find((a) => a.act === "ANSWER" && a.ref === open.act);
+                const body = fromStream?.body ?? await this.fetchGrantAnswer(open.act, client.head - 200);
+                if (body === null)
+                    continue;
                 const applied = applyAnswer(policy, open.act, body);
                 if (applied) {
+                    this.askAt.delete(open.act);
                     changed = true;
                     this.opts.log(`* grant request answered: ${applied.cap} -> ${applied.verdict}`);
                 }
@@ -756,10 +821,39 @@ export class Worker {
             }
         }
     }
-    async fetchGrantAnswer(askActId) {
+    askAt = new Map();
+    lastFullScan = 0;
+    async actSeq(id) {
+        try {
+            const base = this.cfg.relay.replace(/^ws/, "http").replace(/\/+$/, "");
+            const q = `space=${encodeURIComponent(this.cfg.space)}&token=${encodeURIComponent(this.cfg.token)}`;
+            const res = await fetch(`${base}/act?${q}&id=${encodeURIComponent(id)}`, { signal: AbortSignal.timeout(3000) });
+            if (!res.ok)
+                return null;
+            const j = await res.json();
+            return typeof j.act?.seq === "number" ? j.act.seq : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async fetchGrantAnswer(askActId, since = 0) {
+        let seq = this.askAt.get(askActId) ?? null;
+        if (seq === null) {
+            seq = await this.actSeq(askActId);
+            if (seq !== null)
+                this.askAt.set(askActId, seq);
+        }
+        let due = false;
+        if (seq === null) {
+            due = Date.now() - this.lastFullScan > 5 * 60_000;
+            if (due)
+                this.lastFullScan = Date.now();
+        }
+        const from = answerWindow(seq, since, due);
         try {
             const base = this.cfg.relay.replace(/^ws/, "http").replace(/\/+$/, "");
-            const url = `${base}/history?space=${encodeURIComponent(this.cfg.space)}&token=${encodeURIComponent(this.cfg.token)}&since=0`;
+            const url = `${base}/history?space=${encodeURIComponent(this.cfg.space)}&token=${encodeURIComponent(this.cfg.token)}&since=${from}`;
             const res = await fetch(url, { signal: AbortSignal.timeout(3000) });
             const j = await res.json();
             const ans = (j.acts ?? []).find((a) => a.act === "ANSWER" && a.ref === askActId);

package/helper/macos/main.swift

@@ -9,6 +9,8 @@
  *                      (the choice becomes the default), through a .command file
  *                      Terminal runs — no automation permission needed
  *   Show details       prints the act and the decision in Terminal
+ *   Fix it here        (a failed run) opens a Terminal where the work is, steps shown
+ *   Done               (decisions) answers it as handled, silently — the reminders stop
  *   Dismiss / ×        closes
  *
  * It owns no state. Everything it needs arrives as one JSON document:
@@ -25,13 +27,15 @@ import AppKit
 let args = CommandLine.arguments
 
 if args.count == 2, args[1] == "version" {
-  print("2")
+  print("4")
   exit(0)
 }
 
 struct Tool: Decodable { let id: String; let label: String; let kind: String?; let bundle: String?; let deeplink: String? }
 struct Primary: Decodable { let label: String; let `default`: String; let tools: [Tool]; let prompt: String }
 struct Details: Decodable { let act: String?; let decision: String? }
+/// The one thing a person could do about a failed run: where, and which steps.
+struct Fix: Decodable { let label: String; let dir: String; let lines: [String]; let why: String }
 struct Notice: Decodable {
   let kind: String
   let who: String
@@ -43,8 +47,11 @@ struct Notice: Decodable {
   let sound: Bool
   let primary: Primary?
   let details: Details?
+  let fix: Fix?
   /** where to write the chosen action and which .command files to open — supplied by the CLI */
   let bin_dir: String
+  /** the pantheon CLI to run silently for one-click actions — supplied by the CLI, since this helper has no PATH worth trusting */
+  let pantheon: String?
 }
 
 var notice: Notice
@@ -138,6 +145,31 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
     act(["action": "details", "act": notice.details?.act as Any, "decision": notice.details?.decision as Any].compactMapValues { $0 is NSNull ? nil : $0 }, command: "pantheon-details.command")
   }
 
+  /// Done: write the action, run the CLI without a Terminal, close. The CLI answers the decision as handled.
+  @objc func markDone(_ sender: Any?) {
+    guard !notice.bin_dir.isEmpty, let decision = notice.details?.decision else { NSApp.terminate(nil); return }
+    let dir = URL(fileURLWithPath: notice.bin_dir)
+    let payload: [String: Any] = ["action": "done", "decision": decision, "act": notice.details?.act as Any].compactMapValues { $0 is NSNull ? nil : $0 }
+    if let data = try? JSONSerialization.data(withJSONObject: payload) {
+      try? data.write(to: dir.appendingPathComponent(".hud-action.json"), options: .atomic)
+    }
+    let bin = (notice.pantheon?.isEmpty == false) ? notice.pantheon! : "pantheon"
+    let quoted = "'" + bin.replacingOccurrences(of: "'", with: "'\\''") + "'"
+    let p = Process()
+    p.executableURL = URL(fileURLWithPath: "/bin/sh")
+    p.arguments = ["-lc", "\(quoted) explain --queued >/dev/null 2>&1"]   // login shell: PATH with node, as the user's own terminal has
+    try? p.run()
+    NSApp.terminate(nil)
+  }
+
+  /// Fix it here: open a Terminal where the work is, with the steps shown. The
+  /// CLI asks before running anything — a run that just failed is the wrong
+  /// moment to take another unattended action on someone's machine.
+  @objc func fixIt(_ sender: Any?) {
+    guard let f = notice.fix else { NSApp.terminate(nil); return }
+    act(["action": "fix", "dir": f.dir, "lines": f.lines, "why": f.why], command: "pantheon-details.command")
+  }
+
   @objc func legacyOpen(_ sender: Any?) {
     if !legacyPrompt.isEmpty { NSPasteboard.general.clearContents(); NSPasteboard.general.setString(legacyPrompt, forType: .string) }
     if let b = legacyBundle, let url = NSWorkspace.shared.urlForApplication(withBundleIdentifier: b) {
@@ -260,6 +292,25 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         constraints += [d.leadingAnchor.constraint(equalTo: pull.trailingAnchor, constant: 14), d.centerYAnchor.constraint(equalTo: pull.centerYAnchor)]
         trailing = d
       }
+      if notice.fix != nil {
+        let fix = NSButton(title: notice.fix!.label, target: self, action: #selector(fixIt(_:)))
+        fix.isBordered = false; fix.font = .systemFont(ofSize: 12, weight: .medium); fix.contentTintColor = .controlAccentColor
+        fix.toolTip = notice.fix!.why
+        fix.translatesAutoresizingMaskIntoConstraints = false
+        root.addSubview(fix)
+        constraints += [fix.leadingAnchor.constraint(equalTo: trailing.trailingAnchor, constant: 14), fix.centerYAnchor.constraint(equalTo: pull.centerYAnchor)]
+        trailing = fix
+      }
+      if notice.details?.decision != nil {
+        // A decision can be settled from the banner itself: one click, no terminal, no more reminders.
+        let done = NSButton(title: "Done", target: self, action: #selector(markDone(_:)))
+        done.isBordered = false; done.font = .systemFont(ofSize: 12, weight: .medium); done.contentTintColor = .controlAccentColor
+        done.setAccessibilityLabel("Mark this decision handled")
+        done.translatesAutoresizingMaskIntoConstraints = false
+        root.addSubview(done)
+        constraints += [done.leadingAnchor.constraint(equalTo: trailing.trailingAnchor, constant: 14), done.centerYAnchor.constraint(equalTo: pull.centerYAnchor)]
+        trailing = done
+      }
       let dis = NSButton(title: "Dismiss", target: self, action: #selector(dismiss(_:)))
       dis.isBordered = false; dis.font = .systemFont(ofSize: 12); dis.contentTintColor = .secondaryLabelColor
       dis.translatesAutoresizingMaskIntoConstraints = false