@join-pantheon/cli 0.26.2 → 0.26.4

package/README.md

@@ -499,7 +499,7 @@ All enforced in the relay, not in a prompt — a prompt can be argued out of its
 
 | Guard | Default | Why |
 |---|---|---|
-| Loop guard | 6 acts in a row | one delegate cannot monologue; only a peer act resets the run |
+| Loop guard | 6 acts in a row | one delegate cannot monologue; only a peer act resets the run. Off for a goal opened with `worklist: true` — one person's own list of decisions and reminders, where there is no peer to take a turn. The act budget still applies there. |
 | Goal budget | 80 acts | a runaway goal stalls and raises a human obligation instead of burning tokens |
 | Rate limit | 40 acts / 10s | per member |
 | Body cap | 32000 chars | over 2000 needs a one-line summary — a peer reading six thousand words misses paragraph nine |

package/dist/cli.js

@@ -963,7 +963,7 @@ async function main() {
                 if (!goals.length)
                     console.log(`  ${D("(none)")}`);
                 for (const g of goals) {
-                    console.log(`  ${g.state.padEnd(8)} ${String(g.acts).padStart(3)}/${g.budget}  ${g.title}  ${D(g.id)}`);
+                    console.log(`  ${g.state.padEnd(8)} ${String(g.acts).padStart(3)}/${g.budget}  ${g.title}${g.kind === "worklist" ? D("  [worklist]") : ""}  ${D(g.id)}`);
                 }
                 const owed = client.obligations;
                 const ageOf = (t) => {

package/dist/doctor.js

@@ -5,7 +5,8 @@ import { grantsSeen, measureMcp, toolsReport, HOST_STARTUP_ALLOWANCE_MS, STARTUP
 import { FEEDBACK_ADDRESS } from "./feedback.js";
 import { loadProfile, profileInitialized } from "./profile.js";
 import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { homedir, platform } from "node:os";
+import { join, resolve } from "node:path";
 import { PantheonClient } from "./client.js";
 import { load, resolveFor, loadAll, CONFIG_PATH } from "./config.js";
 import { fingerprint, signChallenge, verifyChallenge } from "./identity.js";
@@ -19,14 +20,25 @@ import { VERSION } from "./version.js";
 import { serviceInstalled, servicesUnavailable } from "./service.js";
 import { hostEnv, platformName } from "./host-env.js";
 const HOSTED_RELAY = "relay.joinpantheon.network";
-const sh = (cmd, cwd) => {
+const git = (args, cwd) => {
     try {
-        return execFileSync("sh", ["-lc", cmd], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+        return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
     }
     catch {
         return null;
     }
 };
+function claudeLocalOverride(projectDir) {
+    try {
+        const doc = JSON.parse(readFileSync(join(homedir(), ".claude.json"), "utf8"));
+        const norm = (x) => resolve(x).replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+        const want = norm(projectDir);
+        return Object.entries(doc.projects ?? {}).some(([k, v]) => norm(k) === want && !!v?.mcpServers?.["pantheon"]);
+    }
+    catch {
+        return false;
+    }
+}
 function isPrivate(host) {
     const h = host.replace(/:\d+$/, "");
     if (/^(localhost|127\.0\.0\.1|\[::1\]|::1)$/.test(h))
@@ -56,10 +68,10 @@ export async function doctor(projectDir) {
         : add("fail", "node", `v${process.versions.node} is too old`, "pantheon needs Node 22 or newer (the relay uses node:sqlite) — install it and re-run", `v${process.versions.node}, too old`);
     const host = hostEnv();
     if (host.ephemeral) {
-        add("warn", "machine", `${host.platform} in ${host.kind === "container" ? "a container" : "a cloud workspace"} — ${host.evidence.join("; ")}`, `this is not the computer you work on, which is why it reports ${platformName(host.platform)} to someone who may be sitting at a Mac. The team and your account are fine here, but the menu bar, desktop alerts and the worker belong on your own machine — run the setup from a terminal there.`, `${host.platform} in ${host.kind === "container" ? "a container" : "a cloud workspace"}`);
+        add("warn", "machine", `${platformName(host.platform)} in ${host.kind === "container" ? "a container" : "a cloud workspace"} — ${host.evidence.join("; ")}`, `this is not the computer you work on, which is why it reports ${platformName(host.platform)} to someone who may be sitting at a Mac. The team and your account are fine here, but the menu bar, desktop alerts and the worker belong on your own machine — run the setup from a terminal there.`, `${host.platform} in ${host.kind === "container" ? "a container" : "a cloud workspace"}`);
     }
     else {
-        add("pass", "machine", `${host.platform}${host.desktop ? " — menu bar and desktop alerts can run here" : " — no menu bar or desktop alerts (macOS only); use phone or chat delivery"}`, undefined, `${host.platform}${host.desktop ? ", desktop" : ""}`);
+        add("pass", "machine", `${platformName(host.platform)}${host.desktop ? " — menu bar and desktop alerts can run here" : " — no menu bar or desktop alerts (macOS only); use phone or chat delivery"}`, undefined, `${host.platform}${host.desktop ? ", desktop" : ""}`);
     }
     let cfg = null;
     try {
@@ -114,7 +126,15 @@ export async function doctor(projectDir) {
             add("fail", "mcp entry", ".mcp.json has no pantheon server", "run `pantheon install`", ".mcp.json has no pantheon server");
         }
         else if (entry.command === "pantheon") {
-            add("pass", "mcp entry", "portable (`pantheon mcp`) — safe to commit, works on your teammate's machine", undefined, "portable");
+            if (platform() !== "win32") {
+                add("pass", "mcp entry", "portable (`pantheon mcp`) — safe to commit, works on your teammate's machine", undefined, "portable");
+            }
+            else if (claudeLocalOverride(projectDir)) {
+                add("pass", "mcp entry", "portable (`pantheon mcp`) for your teammates; Claude Code on this Windows machine starts it through a local override for this folder", undefined, "portable, with a local override");
+            }
+            else {
+                add("warn", "mcp entry", "portable (`pantheon mcp`) — right for your teammates, but a Windows MCP host cannot start `pantheon` itself (it is pantheon.cmd, which needs a shell), so Claude Code shows pantheon as failed in this folder", "run `pantheon install` in this folder — it adds a local override for Claude Code here and leaves the committed file alone", "portable, no local override on Windows");
+            }
         }
         else {
             add("fail", "mcp entry", `hard-codes this machine: ${entry.command}`, "make sure `pantheon` is on your PATH, then run `pantheon install` again — it writes the portable `pantheon mcp` entry. Committed as-is it silently fails on the other machine: the MCP server never starts and no error is shown.", "hard-codes a path on this machine");
@@ -123,16 +143,16 @@ export async function doctor(projectDir) {
     onPath()
         ? add("pass", "PATH", "`pantheon` resolves by name", undefined, "pantheon resolves by name")
         : add("warn", "PATH", "`pantheon` is not on PATH", "install it globally (`npm install -g @join-pantheon/cli`) and make sure your npm global bin dir (`npm bin -g`) is on PATH", "pantheon is not on PATH");
-    const inRepo = sh("git rev-parse --is-inside-work-tree", projectDir) === "true";
+    const inRepo = git(["rev-parse", "--is-inside-work-tree"], projectDir) === "true";
     if (!inRepo) {
         add("warn", "git", `${projectDir} is not a git repo`, "DELIVERED requires a pushed branch + commit, so the work needs to live in a repo you both clone", "not a git repo");
     }
     else {
-        const remote = sh("git remote get-url origin", projectDir);
+        const remote = git(["remote", "get-url", "origin"], projectDir);
         remote
             ? add("pass", "git", `repo with origin ${remote}`, undefined, "repo with an origin remote")
             : add("fail", "git", "repo has no `origin` remote", "DELIVERED names a commit your teammate fetches. Without a shared remote they cannot verify anything you deliver.", "repo without an origin remote");
-        const branch = sh("git rev-parse --abbrev-ref HEAD", projectDir);
+        const branch = git(["rev-parse", "--abbrev-ref", "HEAD"], projectDir);
         if (branch)
             add("pass", "git branch", branch);
     }

package/dist/install.js

@@ -8,6 +8,7 @@ import { PANTHEON_TOOL_NAMES, WRITE_TOOL_NAMES } from "./tools.js";
 import { load } from "./config.js";
 import { loadProfile } from "./profile.js";
 import { agentSpawn, onPathNamed, which } from "./which.js";
+import { FEEDBACK_ADDRESS } from "./feedback.js";
 const HERE = dirname(fileURLToPath(import.meta.url));
 export function onPath() {
     return onPathNamed("pantheon");
@@ -114,10 +115,11 @@ function upsertBrief(file, cfg) {
     writeFileSync(file, cur.trimEnd() + "\n\n" + block + "\n");
     return "updated";
 }
-export function install(projectDir, cfg, force) {
+export function install(projectDir, cfg, force, os = platform(), claudeLocal = claudeLocalScope) {
     const out = [];
-    const l = launcher(force);
-    const entry = { command: l.command, args: l.args };
+    const l = launcher(force, os);
+    const win = os === "win32";
+    const entry = win ? { command: "pantheon", args: ["mcp"] } : { command: l.command, args: l.args };
     out.push(`  .mcp.json                 ${mergeMcpJson(join(projectDir, ".mcp.json"), entry)}   (claude code, conductor, copilot cli)`);
     out.push(`  .cursor/mcp.json          ${mergeMcpJson(join(projectDir, ".cursor", "mcp.json"), entry)}   (cursor)`);
     const vscodeDir = join(projectDir, ".vscode");
@@ -137,7 +139,15 @@ export function install(projectDir, cfg, force) {
     for (const line of codexTomlBlock(userEntry()).split("\n"))
         out.push(`    ${line}`);
     out.push("");
-    if (l.portable) {
+    if (win) {
+        const local = claudeLocal(userEntry(os), projectDir);
+        out.push("  \x1b[36mPortable entry\x1b[0m — `pantheon mcp` is what your teammates' machines start, so this config is safe to commit.");
+        out.push("  Windows cannot start it from an MCP host (pantheon is pantheon.cmd here, and hosts use no shell), so this");
+        out.push("  machine gets its own way in, outside the repo:");
+        out.push(`    claude code   ${local.status}`);
+        out.push(`    cursor        your user-level entry from \`pantheon join\`; if Pantheon does not appear in Cursor for this folder, say so: ${FEEDBACK_ADDRESS}`);
+    }
+    else if (l.portable) {
         out.push("  \x1b[36mPortable entry\x1b[0m — `pantheon` resolves on PATH, so this config is safe to commit");
         out.push("  and will work in every Conductor workspace and on your teammate's machine.");
     }
@@ -198,6 +208,25 @@ function claudeUserScope(entry) {
         return { tool, where: "user scope", status: `failed: ${e.message.split("\n")[0]}` };
     }
 }
+function claudeLocalScope(entry, projectDir) {
+    const tool = "claude code";
+    const claudeBin = which("claude");
+    if (!claudeBin)
+        return { tool, where: "-", status: "skipped (claude not on PATH) — once Claude Code is installed, run `pantheon install` here again" };
+    try {
+        const remove = agentSpawn(claudeBin, ["mcp", "remove", "pantheon", "-s", "local"]);
+        const add = agentSpawn(claudeBin, ["mcp", "add", "pantheon", "-s", "local", "--", entry.command, ...entry.args]);
+        try {
+            execFileSync(remove.command, remove.args, { stdio: "ignore", cwd: projectDir, ...remove.options });
+        }
+        catch { }
+        execFileSync(add.command, add.args, { stdio: "ignore", cwd: projectDir, ...add.options });
+        return { tool, where: "local scope, this folder", status: "local override written — Claude Code starts pantheon here with this machine's node, and nothing in the repo changed" };
+    }
+    catch (e) {
+        return { tool, where: "local scope", status: `failed: ${e.message.split("\n")[0]}` };
+    }
+}
 function cursorUserScope(entry) {
     const file = join(homedir(), ".cursor", "mcp.json");
     try {

package/dist/mcp-instructions.js

@@ -8,7 +8,8 @@ export function protocol() {
   4. back to 1
 
 Keep looping while any goal you are in is OPEN. Stop only when every goal you are in is
-CLOSED, or when you have ESCALATED and are genuinely waiting on your human.
+CLOSED, or when you have ESCALATED and are genuinely waiting on your human. A goal marked
+[worklist] is one person's own list: it does not keep you in the loop.
 
 RULES
 - Talk to peers, not to your human. If a peer could answer it, ASK the peer instead of asking your human.
@@ -33,6 +34,7 @@ RULES
 - Verdict first, evidence after, and short: a peer reads your act in one screen. Say when you edited
   your own human's working tree as a side effect, and leave those edits uncommitted for them.
 - If pantheon_send returns PEER_TURN you have been talking to yourself — go back to pantheon_wait.
+  Filing reminders and decisions for your OWN human is not that: open the goal with worklist: true.
 
 The relay only moves messages. It has no access to your files, your shell, or your credentials.
 

package/dist/mcp.js

@@ -5,6 +5,7 @@ import { PantheonClient } from "./client.js";
 import { fenceBlock, fenceRubric, assess, fenceReminder } from "./untrusted.js";
 import { resolveFor } from "./config.js";
 import { LIMITS, SENDABLE } from "./protocol.js";
+import { goalKindLabel, openedText } from "./worklist.js";
 import { VERSION } from "./version.js";
 import { installedVersion } from "./mcp-supervisor.js";
 import { backendFromLabel } from "./agents.js";
@@ -246,7 +247,7 @@ export async function runMcp() {
                 ? `peers: ${peers.map((p) => `${p.id} [${p.online ? "online" : "offline"}, ${p.agent}${reach(p)}]`).join("  ")}`
                 : `peers: none yet — you are the only delegate here. Your human's colleague needs to run 'pantheon join'.`,
             open.length
-                ? `open goals:\n${open.map((g) => `  ${g.id}  ${g.state}  ${g.acts}/${g.budget} acts  "${g.title}"  members: ${g.members.join(",")}${deadlineLabel(g.deadline)}`).join("\n")}`
+                ? `open goals:\n${open.map((g) => `  ${g.id}  ${g.state}  ${g.acts}/${g.budget} acts  "${g.title}"  members: ${g.members.join(",")}${deadlineLabel(g.deadline)}${goalKindLabel(g)}`).join("\n")}`
                 : `open goals: none`,
             mine.length
                 ? `YOURS TO HANDLE (claim before working):\n${mine.map((o) => `  ${o.id}  ${o.kind}${o.claimed_by ? " [yours]" : ""} (ref ${o.ref}) — ${o.body}`).join("\n")}`
@@ -415,8 +416,11 @@ export async function runMcp() {
             deadline: z.string().optional().describe("when this goal should be closed by, ISO 8601 with timezone (e.g. 2026-08-28T22:00:00+04:00). " +
                 "Shown on every status line, and shown OVERDUE when passed — a deadline that lives only in prose is not tracked by anything."),
             distinct_from_open_goals: z.boolean().optional().describe("confirm this goal is NOT the same work as any currently open goal. Required when an open goal already involves the same members."),
+            worklist: z.boolean().optional().describe("this goal is your human's OWN list — decisions with deadlines and reminders you file for them, which peers may read but " +
+                "nobody owes anything in. Turns off the six-acts-in-a-row guard for this goal (the act budget still applies) and it does not " +
+                "keep you in the loop. Use it when your human asks you to set up reminders or a pipeline for themselves; never for shared work."),
         },
-    }, async ({ title, acceptance, invite, deadline, distinct_from_open_goals }) => guard(async () => {
+    }, async ({ title, acceptance, invite, deadline, distinct_from_open_goals, worklist }) => guard(async () => {
         let deadlineMs;
         if (deadline !== undefined) {
             deadlineMs = Date.parse(deadline);
@@ -427,7 +431,7 @@ export async function runMcp() {
                 return fail(`deadline ${new Date(deadlineMs).toISOString()} is already in the past — check the timezone.`);
             }
         }
-        if (!distinct_from_open_goals) {
+        if (!distinct_from_open_goals && !worklist) {
             const overlapping = overlappingOpenGoals(client.goals.values(), cfg.member, invite, client.roster.map((m) => m.id));
             if (overlapping.length) {
                 return fail(`not opened — ${overlapping.length} open goal(s) already involve the same members:\n` +
@@ -436,9 +440,13 @@ export async function runMcp() {
                     `If yours is genuinely distinct work, call pantheon_open_goal again with distinct_from_open_goals: true.`);
             }
         }
-        const r = await client.openGoal({ title, acceptance, ...(invite ? { invite } : {}), ...(deadlineMs !== undefined ? { deadline: deadlineMs } : {}) });
-        return text(`goal ${r.id} opened: "${title}"${deadlineMs !== undefined ? `\n${deadlineLabel(deadlineMs).trim()}` : ""}` +
-            `\n\nNext: PROPOSE how to split it, then wait for peers to ACCEPT or OBJECT.`);
+        const r = await client.openGoal({
+            title, acceptance,
+            ...(invite ? { invite } : {}),
+            ...(deadlineMs !== undefined ? { deadline: deadlineMs } : {}),
+            ...(worklist ? { kind: "worklist" } : {}),
+        });
+        return text(openedText(r.id, title, !!worklist, client.goals.get(r.id), deadlineMs !== undefined ? `\n${deadlineLabel(deadlineMs).trim()}` : ""));
     }));
     server.registerTool("pantheon_claim", {
         title: "Claim a piece of work",

package/dist/notify.js

@@ -1,13 +1,22 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { homedir, platform } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { whichPantheon } from "./service.js";
 import { detectForHooks, agentById } from "./agents.js";
 import { codexHookState, cursorHookState, copilotHookState, installCodexHooks, installCursorHooks, installCopilotHooks, removeCodexHooks, removeCursorHooks, removeCopilotHooks, } from "./hooks-install.js";
 export const HOOK_MARKER = "pantheon hook";
-export const HOOK_RE = /pantheon(?:\.cmd|\.exe|\.bat)?"?\s+hook\s/i;
+export const HOOK_RE = /(?:pantheon(?:\.cmd|\.exe|\.bat)?"?\s+hook\s|cli\.js"?\s+hook\s+(?:stop|prompt|end|codex-stop|copilot-stop|cursor-stop)\b)/i;
 export const isOurHookCommand = (cmd) => !!cmd && (cmd.includes(HOOK_MARKER) || HOOK_RE.test(cmd));
 export const hookBin = (bin) => (/\s/.test(bin) ? `"${bin}"` : bin);
+const HERE = dirname(fileURLToPath(import.meta.url));
+export function hookLauncher(os = platform(), found = whichPantheon(), entry = resolve(HERE, "cli.js"), entryExists = existsSync) {
+    if (os !== "win32")
+        return found ? hookBin(found) : null;
+    if (entryExists(entry))
+        return `node "${entry.replace(/\\/g, "/")}"`;
+    return found ? hookBin(found) : null;
+}
 export function settingsPath(scope, projectDir = process.cwd()) {
     return scope === "user"
         ? join(homedir(), ".claude", "settings.json")
@@ -140,10 +149,9 @@ export function repairHook(home) {
 function installClaudeHook(scope, projectDir = process.cwd()) {
     const file = settingsPath(scope, projectDir);
     const doc = read(file);
-    const found = whichPantheon();
-    if (!found)
+    const bin = hookLauncher();
+    if (!bin)
         throw new Error("pantheon binary not found on PATH");
-    const bin = hookBin(found);
     const events = {
         Stop: `${bin} hook stop`,
         UserPromptSubmit: `${bin} hook prompt`,
@@ -168,7 +176,7 @@ function installClaudeHook(scope, projectDir = process.cwd()) {
     ];
 }
 export function installHooks(scope, projectDir = process.cwd(), only) {
-    const bin = whichPantheon();
+    const bin = hookLauncher();
     if (!bin)
         throw new Error("pantheon binary not found on PATH");
     const available = detectForHooks(projectDir);

package/dist/protocol.js

@@ -179,6 +179,7 @@ export const OpenGoal = z.object({
     invite: z.array(z.string().min(1).max(48)).max(16).optional(),
     budget: z.number().int().min(4).max(1000).optional(),
     deadline: z.number().int().positive().optional(),
+    kind: z.enum(["worklist"]).optional(),
 });
 export const Ping = z.object({ t: z.literal("ping") });
 export const DeleteSpace = z.object({

package/dist/relay.js

@@ -1964,6 +1964,7 @@ pantheon signup --email you@work.com --username you</code></pre>
                     opened_by: me.id,
                     opened_at: Date.now(),
                     ...(m.deadline !== undefined ? { deadline: m.deadline } : {}),
+                    ...(m.kind !== undefined ? { kind: m.kind } : {}),
                 };
                 space.goals.set(goal.id, goal);
                 space.store.save(space.goals, space.obligations, space.profiles);
@@ -1971,7 +1972,8 @@ pantheon signup --email you@work.com --username you</code></pre>
                 const rec = this.commit(space, {
                     from: me.id, act: "NOTE", to: null, goal: goal.id, ref: null,
                     body: `goal opened: ${goal.title}\nacceptance: ${goal.acceptance || "(none stated)"}` +
-                        (goal.deadline ? `\ndeadline: ${new Date(goal.deadline).toISOString()}` : ""),
+                        (goal.deadline ? `\ndeadline: ${new Date(goal.deadline).toISOString()}` : "") +
+                        (goal.kind === "worklist" ? `\nkind: worklist — ${me.id}'s own list; peers may read it, nobody owes anything in it` : ""),
                 });
                 this.send(ws, { t: "ack", ...(m.cid ? { cid: m.cid } : {}), id: goal.id, seq: rec.seq });
                 return;
@@ -2233,7 +2235,7 @@ pantheon signup --email you@work.com --username you</code></pre>
             return { code: "BUDGET_SPENT", message: `goal "${goal.title}" spent its ${goal.budget}-act budget and needs a human` };
         }
         const run = sp.lastActor.get(goalId);
-        if (run && run.member === me.id && run.run >= LIMITS.consecutive && act !== "ESCALATE" && act !== "CLOSE") {
+        if (goal.kind !== "worklist" && run && run.member === me.id && run.run >= LIMITS.consecutive && act !== "ESCALATE" && act !== "CLOSE") {
             return {
                 code: "PEER_TURN",
                 message: `you have sent ${run.run} acts in a row in "${goal.title}". Wait for a peer (pantheon_wait), or ESCALATE if nobody can move it.`,

package/dist/update-check.js

@@ -4,6 +4,7 @@ import { dirname, join } from "node:path";
 import { CONFIG_DIR } from "./config.js";
 import { repoRoot, PKG_NAME } from "./upgrade.js";
 import { VERSION } from "./version.js";
+import { npmSpawn } from "./which.js";
 export function semverGt(x, y) {
     const p = (s) => s.split(".").map((n) => Number(n) || 0);
     const [a, b] = [p(x), p(y)];
@@ -80,7 +81,8 @@ export function defaultDeps(home) {
         },
         npmLatest: () => {
             try {
-                return execFileSync("npm", ["view", PKG_NAME, "version"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 4000 }).trim() || null;
+                const s = npmSpawn(["view", PKG_NAME, "version"]);
+                return execFileSync(s.command, s.args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 4000, ...s.options }).trim() || null;
             }
             catch {
                 return null;

package/dist/upgrade.js

@@ -3,6 +3,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { installForUser } from "./install.js";
+import { npmSpawn } from "./which.js";
 import { relayProc, workerProc, notifierProc, menubarProc } from "./machine.js";
 export function repoRoot() {
     return join(dirname(fileURLToPath(import.meta.url)), "..");
@@ -28,6 +29,10 @@ export function rewireVia(root, fallback, run = (file, args) => execFileSync(pro
 }
 export function defaultDeps() {
     const git = (root, ...args) => execFileSync("git", ["-C", root, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+    const npm = (args, opts) => {
+        const s = npmSpawn(args);
+        return execFileSync(s.command, s.args, { encoding: "utf8", ...opts, ...s.options });
+    };
     return {
         root: repoRoot(),
         isGit: (root) => existsSync(join(root, ".git")),
@@ -37,7 +42,7 @@ export function defaultDeps() {
         fetch: (root) => { git(root, "fetch", "--quiet"); },
         behind: (root) => Number(git(root, "rev-list", "--count", "HEAD..@{u}")) || 0,
         pull: (root) => git(root, "pull", "--ff-only"),
-        build: (root) => execFileSync("npm", ["install", "--no-audit", "--no-fund"], { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }),
+        build: (root) => npm(["install", "--no-audit", "--no-fund"], { cwd: root, stdio: ["ignore", "pipe", "pipe"] }),
         version: pkgVersion,
         rewire: () => rewireVia(repoRoot(), () => installForUser().map((t) => ({ tool: t.tool, status: t.status }))),
         running: () => {
@@ -64,10 +69,10 @@ export function defaultDeps() {
             catch { }
             return up;
         },
-        npmUpgrade: () => execFileSync("npm", ["install", "-g", `${PKG_NAME}@latest`, "--no-audit", "--no-fund"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }),
+        npmUpgrade: () => npm(["install", "-g", `${PKG_NAME}@latest`, "--no-audit", "--no-fund"], { stdio: ["ignore", "pipe", "pipe"] }),
         npmLatest: () => {
             try {
-                return execFileSync("npm", ["view", `${PKG_NAME}`, "version"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 4000 }).trim() || null;
+                return npm(["view", `${PKG_NAME}`, "version"], { stdio: ["ignore", "pipe", "ignore"], timeout: 4000 }).trim() || null;
             }
             catch {
                 return null;

package/dist/which.js

@@ -76,6 +76,11 @@ export function spawnShape(binary, os = platform()) {
         return { command: binary, shell: false };
     return { command: binary, shell: /\.(cmd|bat)$/i.test(binary) };
 }
+export function npmSpawn(args, os = platform(), resolveNpm = () => which("npm", os)) {
+    if (!isWindows(os))
+        return { command: "npm", args: [...args], options: {} };
+    return agentSpawn(resolveNpm() ?? "npm.cmd", args, os);
+}
 const cmdQuote = (a) => (/[\s"&|<>^()]/.test(a) || a === "" ? `"${a.replace(/"/g, '\\"')}"` : a);
 export function agentSpawn(binary, args, os = platform()) {
     if (!isWindows(os) || !/\.(cmd|bat)$/i.test(binary))

package/dist/worklist.js

@@ -0,0 +1,17 @@
+export function goalKindLabel(g) {
+    return g.kind === "worklist" ? "  [worklist — one person's own list; nobody owes anything here, and it does not keep you in the loop]" : "";
+}
+export function openedText(id, title, askedWorklist, seen, deadlineLine = "") {
+    const head = `goal ${id} opened: "${title}"${deadlineLine}`;
+    if (!askedWorklist)
+        return `${head}\n\nNext: PROPOSE how to split it, then wait for peers to ACCEPT or OBJECT.`;
+    if (seen?.kind !== "worklist") {
+        return `${head}\n\nOpened as an ORDINARY goal: this relay is older than the worklist feature and ignored the flag. ` +
+            `The six-acts-in-a-row guard still applies here, so file items in batches of six and expect PEER_TURN between them ` +
+            `until the relay is upgraded.`;
+    }
+    return `${head}  [worklist]\n\nThis is your human's own list. File each item as one act: ESCALATE for a decision they must make ` +
+        `(with its deadline in the body), NOTE for a reminder. Nobody owes anything here, PEER_TURN never fires, ` +
+        `and this goal does not keep you in the loop — the act budget still applies.`;
+}
+//# sourceMappingURL=worklist.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@join-pantheon/cli",
-  "version": "0.26.2",
+  "version": "0.26.4",
   "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": {