@join-pantheon/cli 0.26.3 → 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/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/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/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.3",
+  "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": {