pi-goal-list-loop-audit 0.23.6 → 0.23.8

package/README.md

@@ -44,7 +44,7 @@ Four top-level commands, that's all:
 /list fix the login bug, add dark mode, write docs   # dump it — the agent shapes it into items, one Confirm
 /list plan.md                      # file detected → bulk import, one Confirm (sisyphus/Ralph style)
 /list <paste a checklist>          # multi-line paste → same batch flow
-/list "fix the flaky test. Done when: npm test green"   # explicit contract → queues directly, no interview
+/list "fix the flaky test. Done when: npm test green"   # explicit contract → added directly, no interview
 /list                              # show the list (add/import are optional no-op aliases — detection routes everything)
 
 (Or just say it: "queue these 10 things…" — the agent manages the list too.)
@@ -53,10 +53,10 @@ Four top-level commands, that's all:
 `/list next <n>` or the agent's `list_activate` tool picks any item — with
 subagents, what gets worked next is a choice, not a position. Numbering always
 matches `/list show`.
-/list                              # show active + queue
+/list                              # show active + waiting items
 /list next                         # skip current, activate next
-/list remove <n>                   # drop item n from the queue
-/list clear                        # empty the queue
+/list remove <n>                   # drop item n from the list
+/list clear                        # empty the list
 /loop                              # draft the loop (agent grills; measure is test-run before you confirm)
 /loop start "keep polishing the UI"                          # infinite metricless loop (v0.23.6): no plateau, no cap — ends at time=/tokens= or /loop stop
 /loop start "reduce TODOs" measure="grep -c TODO src.txt | head -1" direction=min
@@ -91,7 +91,7 @@ sisyphus-style plan file (checklists, bullets, numbered, plain lines) imports
 as-is — headings become nothing, items become goals. And the drafter itself
 batches: asking for "these 50 tasks" in a `/list` drafting session produces
 ONE confirmed batch, not 50 dialogs.
-Note: every queue item is audited individually, so at hundreds of items the
+Note: every list item is audited individually, so at hundreds of items the
 audit cost per item is the thing to think about.
 
 **Drafting is the default for long-running things.** `/goal` and
@@ -144,7 +144,7 @@ redirect you to `/goal`.
 | Loop | Command | Status |
 |---|---|---|
 | 1. Single ordered goal | `/goal "<objective>"` | **shipped v0.1.0** |
-| 2. Queue of goals | `/list [show\|next\|remove\|clear]` | **shipped v0.2.0** |
+| 2. List of goals (a pool, not a FIFO) | `/list [show\|next\|remove\|clear]` | **shipped v0.2.0** |
 | 3. Metric-driven process loop | `/loop start\|status\|stop` | **shipped v0.3.0** |
 
 Each loop is a different policy class on the same status machine.
@@ -186,6 +186,8 @@ No external watchdog plugin needed.
 /glla tokenlimit=10000000            # per-goal token budget (default: off) → GLOBAL
 /glla tokenlimit=0                   # explicitly no cap (the default)
 /glla wedgealert=30                  # hung-command alert minutes (default: 30, 0 = off)
+/glla autoresume=on                  # held goals/loops auto-resume in fresh sessions (unattended rigs)
+/glla autoaccept=on                  # drafts ACTIVATE without the Confirm dialog (unattended rigs)
 /glla project tokenlimit=500         # rare per-project override
 ```
 
@@ -195,6 +197,29 @@ auditor can't auth it — you're told once (info level) with the fix:
 `/glla model=provider/id`, set once, rarely touched again. The plugin never
 picks a model itself. Thinking follows the session too (floor `high`).
 
+`autoaccept=on` skips BOTH the Confirm dialog and the drafting interview
+floor — every `propose_*` draft (goal, list batch, loop, task list)
+activates the moment the agent proposes it, with a notification and a
+`draft_autoaccepted` ledger entry (auto-accept is never silent). The seed
+carries the intent. Pair with `autoresume=on` for fully unattended rigs.
+
+## Subagents (`@tintinweb/pi-subagents`)
+
+Subagent sessions bind extensions too, so glla loads there — by design the
+**main session owns the goal/loop/list; subagents are workers** (v0.23.8):
+
+- Read-only agents (Explore, Plan) get no glla tools (pi-subagents gates
+  them); general-purpose agents see them but state-mutating calls
+  (`complete_goal`, `propose_*`, `list_add`, `pause_goal`, …) are refused
+  with "report back to the main agent".
+- A subagent session never clobbers the loop's session handle, never runs
+  the restore gate, and never drives continuation — so the heartbeat,
+  wedge alert, and auto-resume machinery always act on the main session.
+  (pi hands a fresh ctx wrapper per event; `ctx.sessionManager` identity
+  is the discriminator.)
+- Subagent tool activity counts as activity for the wedge clock — a long
+  subagent run is work, not a hang.
+
 ## Token guard
 
 Every goal tracks real token usage; crossing the budget pauses the goal.

package/extensions/goal-loop-core.ts

@@ -300,7 +300,10 @@ export interface ListItem {
 export function goalArgsNeedDrafting(args: string): boolean {
   const t = args.trim();
   if (!t) return false; // no-args is already the drafting path
-  return !/\bdone\s+when\s*:/i.test(t);
+  // v0.23.7: any "done when" phrase counts — requiring the colon to
+  // immediately follow made "Done when ALL of the following are true:"
+  // route to the interview even though the user wrote a contract.
+  return !/\bdone\s+when\b/i.test(t);
 }
 
 /**
@@ -627,3 +630,61 @@ export function normalizeDraftContract(raw: string): string {
 export function draftContractItemCount(normalized: string): number {
   return normalized.split("\n").filter((l) => /^\d+\.\s/.test(l)).length;
 }
+
+/**
+ * Split raw objective text into { objective, verificationContract } at the
+ * first "Done when…:"-family marker (line-start preferred, inline fallback
+ * for one-liners). v0.23.7: the marker family accepts ANY text between the
+ * keyword and the colon ("Done when ALL of the following are true:") —
+ * the shield's contractItems already drops such introducer lines
+ * (v0.23.4), and goalArgsNeedDrafting recognizes the same phrase, so the
+ * three "done when" parsers can no longer drift apart. Lives in the pure
+ * module so tests exercise THIS function, not a copy (the pre-0.23.7 test
+ * re-implemented it and silently went stale).
+ */
+export function extractVerificationContract(raw: string): { objective: string; verificationContract: string } {
+  // Line-based first: a marker at line start begins the contract block.
+  const lines = raw.split("\n");
+  let mode: "obj" | "verify" = "obj";
+  const objParts: string[] = [];
+  const verifyParts: string[] = [];
+  for (const line of lines) {
+    if (line.match(/^\s*(?:done when|verified when|verify|verification|done)\b[^:]*:/i)) {
+      mode = "verify";
+    }
+    if (mode === "obj") objParts.push(line);
+    else verifyParts.push(line);
+  }
+  let objective = objParts.join("\n").trim();
+  let verificationContract = verifyParts.join("\n").trim();
+
+  // Inline fallback: users write one-liners like
+  //   "Create x.txt. Done when: grep -q ok x.txt"
+  // where the marker is mid-line. Split at the first inline marker.
+  if (!verificationContract) {
+    const m = raw.match(/^(.*?)(?:\.|;)??\s+(?:done when|verified when|verify|verification)\b[^:]*:\s*(.+)$/is);
+    if (m) {
+      objective = (m[1] ?? "").trim().replace(/[.;]\s*$/, "");
+      verificationContract = (m[2] ?? "").trim();
+    }
+  }
+  return { objective, verificationContract };
+}
+
+/**
+ * v0.23.8: subagent-session ownership. pi-subagents binds extensions in
+ * subagent sessions too, so glla's session_start/handlers fire there with
+ * the same module state. The MAIN session owns the goal/loop; subagent
+ * sessions are workers — they must never clobber the loop's ctx handle
+ * (a headless subagent ctx would silently kill the heartbeat/wedge
+ * machinery), never receive continuation injection, and never mutate goal
+ * state. pi hands a FRESH ctx wrapper per event (verified in
+ * dist/core/extensions/runner.js — createContext() per emit), so object
+ * identity is useless; ctx.sessionManager is the stable per-session
+ * discriminator (each subagent gets its own SessionManager).
+ */
+export type OwnerClaim = "claim" | "refresh" | "foreign";
+export function classifySessionCtx(ownerSession: unknown, ownerLive: boolean, sessionManager: unknown): OwnerClaim {
+  if (!ownerSession || !ownerLive) return "claim";
+  return sessionManager === ownerSession ? "refresh" : "foreign";
+}

package/extensions/loops/goal.ts

@@ -55,6 +55,8 @@ import {
   piGlaDir,
   normalizeDraftContract,
   draftContractItemCount,
+  extractVerificationContract,
+  classifySessionCtx,
   readState,
   renderGoalMarkdown,
   shouldAutoResumeOnSessionStart,
@@ -104,11 +106,37 @@ let extensionApi: ExtensionAPI | null = null;
 // pi replaces sessions (newSession/fork/reload) and stale ctx throws on use,
 // so timers must never capture a ctx — they read lastCtx at fire time.
 let lastCtx: ExtensionContext | null = null;
+// v0.23.8: the session that OWNS the loop (its sessionManager). Subagent
+// sessions (pi-subagents binds extensions there too) fire our handlers
+// with their own ctx — they must never take over lastCtx (a headless
+// subagent ctx would silently kill the heartbeat/wedge machinery).
+let ownerSession: unknown = null;
 
 function rememberCtx(ctx: ExtensionContext): void {
+  let ownerLive = false;
+  if (ownerSession && lastCtx) {
+    try { lastCtx.isIdle(); ownerLive = true; } catch { /* owner went stale (session replaced) */ }
+  }
+  const claim = classifySessionCtx(ownerSession, ownerLive, ctx.sessionManager);
+  if (claim === "foreign") return;
+  ownerSession = ctx.sessionManager;
   lastCtx = ctx;
 }
 
+/** True when ctx belongs to a subagent/foreign session, not the loop owner. */
+function isForeignCtx(ctx: ExtensionContext): boolean {
+  return ownerSession !== null && ctx.sessionManager !== ownerSession;
+}
+
+const FOREIGN_SESSION_TOOL_MESSAGE =
+  "This tool changes goal/loop/list state, which only the MAIN session owns — you are running in a subagent session. Report back to the main agent; it owns the goal and can call this tool.";
+
+/** Refusal message when a state-mutating tool is called from a subagent session, else null. */
+function foreignToolGuard(execCtx: unknown): string | null {
+  const c = execCtx as ExtensionContext | undefined;
+  return c && isForeignCtx(c) ? FOREIGN_SESSION_TOOL_MESSAGE : null;
+}
+
 let state: State = { goal: null };
 
 // Drafting mode: a no-arg loop command starts a clarification turn; the agent
@@ -354,43 +382,13 @@ function createGoal(objective: string, ctx: ExtensionContext, policy: "goal" | "
   return goal;
 }
 
-function extractVerificationContract(raw: string): { objective: string; verificationContract: string } {
-  // Line-based first: a marker at line start begins the contract block.
-  const lines = raw.split("\n");
-  let mode: "obj" | "verify" = "obj";
-  const objParts: string[] = [];
-  const verifyParts: string[] = [];
-  for (const line of lines) {
-    const lower = line.toLowerCase();
-    if (lower.match(/^\s*(?:done when|verify|verified when|verification|done):/)) {
-      mode = "verify";
-    }
-    if (mode === "obj") objParts.push(line);
-    else verifyParts.push(line);
-  }
-  let objective = objParts.join("\n").trim();
-  let verificationContract = verifyParts.join("\n").trim();
-
-  // Inline fallback: users write one-liners like
-  //   "Create x.txt. Done when: grep -q ok x.txt"
-  // where the marker is mid-line. Split at the first inline marker.
-  if (!verificationContract) {
-    const m = raw.match(/^(.*?)(?:\.|;)??\s+(done when|verified when|verify|verification)\s*:\s*(.+)$/is);
-    if (m) {
-      objective = (m[1] ?? "").trim().replace(/[.;]\s*$/, "");
-      verificationContract = (m[3] ?? "").trim();
-    }
-  }
-  return { objective, verificationContract };
-}
-
 function persistState(ctx: ExtensionContext): void {
   appendLedger(ctx.cwd, "state", { goal: state.goal, list: state.list ?? [], loop: state.loop ?? null });
   refreshUI(ctx); // every state transition flows through here → the TUI is always current
 }
 
 function setGoal(goal: Goal, ctx: ExtensionContext): void {
-  state = { goal, list: state.list ?? [] }; // preserve the queue!
+  state = { goal, list: state.list ?? [] }; // preserve the list!
   const file = writeGoalMd(ctx.cwd, goal);
   state.goal!.activePath = path.relative(ctx.cwd, file) || file;
   persistState(ctx);
@@ -482,7 +480,7 @@ async function startDrafting(ctx: ExtensionContext, target: "goal" | "list" | "l
     if (target === "list") {
       tmpl = tmpl.replace(
         "[GOAL DRAFTING]",
-        "[GOAL DRAFTING — the confirmed goal goes into the /list LIST, it does not activate immediately. If the user wants MANY things queued (a plan, a checklist, 'these 50 tasks'), propose them ALL AT ONCE with the items[] parameter — one Confirm for the whole batch, never 50 separate proposals.]",
+        "[GOAL DRAFTING — the confirmed goal goes into the /list LIST, it does not activate immediately. If the user wants MANY things added at once (a plan, a checklist, 'these 50 tasks'), propose them ALL AT ONCE with the items[] parameter — one Confirm for the whole batch, never 50 separate proposals.]",
       );
     }
   } catch {
@@ -596,7 +594,7 @@ async function cmdPause(ctx: ExtensionContext): Promise<void> {
   // v0.22.7: name WHAT was paused — a list item resumes through /list.
   if (state.goal.policy === "list") {
     const queued = listQueue().length;
-    ctx.ui.notify(`List item ${state.goal.id} paused${queued > 0 ? ` (${queued} queued in the list)` : ""}. /list resume to continue.`, "info");
+    ctx.ui.notify(`List item ${state.goal.id} paused${queued > 0 ? ` (${queued} waiting in the list)` : ""}. /list resume to continue.`, "info");
     return;
   }
   ctx.ui.notify(`Goal ${state.goal.id} paused. /goal resume to continue.`, "info");
@@ -619,8 +617,8 @@ async function cmdResume(ctx: ExtensionContext): Promise<void> {
   const isListItem = state.goal.policy === "list";
   ctx.ui.notify(
     isListItem
-      ? `Resumed list item [${state.goal.id}]: ${state.goal.objective.replace(/\s+/g, " ").slice(0, 70)}${queued > 0 ? ` (+${queued} queued in the list)` : ""}`
-      : `Resumed goal [${state.goal.id}]: ${state.goal.objective.replace(/\s+/g, " ").slice(0, 70)}${queued > 0 ? ` (+${queued} queued in the list — resuming the list's head)` : ""}`,
+      ? `Resumed list item [${state.goal.id}]: ${state.goal.objective.replace(/\s+/g, " ").slice(0, 70)}${queued > 0 ? ` (+${queued} waiting in the list)` : ""}`
+      : `Resumed goal [${state.goal.id}]: ${state.goal.objective.replace(/\s+/g, " ").slice(0, 70)}${queued > 0 ? ` (+${queued} waiting in the list — resuming the list's head)` : ""}`,
     "info",
   );
   scheduleContinuation(ctx, true);
@@ -683,8 +681,8 @@ async function cmdTweak(args: string, ctx: ExtensionContext): Promise<void> {
   try {
     confirmed = await ctx.ui.confirm(
       "Tweak goal?",
-      `CURRENT:\n${current.objective.slice(0, 400)}\n\nNEW:\n${newObjective.slice(0, 400)}` +
-      (newContract ? `\n\nNew contract:\n${newContract.slice(0, 200)}` : "\n\n(New text carries no contract; old contract is dropped.)"),
+      `CURRENT:\n${current.objective}\n\nNEW:\n${newObjective}` +
+      (newContract ? `\n\nNew contract:\n${newContract}` : "\n\n(New text carries no contract; old contract is dropped.)"),
     );
   } catch {
     confirmed = false;
@@ -729,13 +727,15 @@ async function bulkAddItems(ctx: ExtensionContext, parsed: string[], sourceName:
     ctx.ui.notify("No items found (headings/blank lines don't count).", "warning");
     return;
   }
-  const preview = parsed.slice(0, 5).map((t, i) => `  ${i + 1}. ${t.slice(0, 70)}`).join("\n");
+  // v0.23.7: show ALL items in full — a Confirm the user can't fully
+  // read is not a gate (same rule as the draft dialog, v0.23.5).
+  const preview = parsed.map((t, i) => `  ${i + 1}. ${t}`).join("\n");
   let confirmed = true;
   if (ctx.hasUI) {
     try {
       confirmed = await ctx.ui.confirm(
-        "Import into queue?",
-        `${parsed.length} items from ${sourceName}:\n${preview}${parsed.length > 5 ? `\n  … and ${parsed.length - 5} more` : ""}`,
+        "Import into list?",
+        `${parsed.length} items from ${sourceName}:\n${preview}`,
       );
     } catch {
       confirmed = false;
@@ -747,7 +747,7 @@ async function bulkAddItems(ctx: ExtensionContext, parsed: string[], sourceName:
   }
   const n = enqueueItems(ctx, parsed, sourceName);
   if (state.goal && state.goal.status === "active") {
-    ctx.ui.notify(`Imported ${n} items (${listQueue().length} queued).`, "info");
+    ctx.ui.notify(`Imported ${n} items (${listQueue().length} waiting in the list).`, "info");
   }
 }
 
@@ -773,7 +773,7 @@ async function cmdList(args: string, ctx: ExtensionContext): Promise<void> {
     // is the same motion as /goal resume — named for the surface the user is
     // looking at (v0.22.7: "we would just unpause, and that is next").
     if (!state.goal || state.goal.status !== "paused") {
-      ctx.ui.notify("No paused list item to resume. /list show to see the queue.", "info");
+      ctx.ui.notify("No paused list item to resume. /list show to see the list.", "info");
       return;
     }
     if (state.goal.policy !== "list") {
@@ -914,7 +914,7 @@ function addSingleItem(ctx: ExtensionContext, raw: string): void {
   if (!state.goal || state.goal.status === "complete" || state.goal.status === "aborted") {
     activateNextListItem(ctx);
   } else {
-    ctx.ui.notify(`Queued (${listQueue().length} waiting): ${objective.slice(0, 80)}`, "info");
+    ctx.ui.notify(`Added to the list (${listQueue().length} waiting): ${objective.slice(0, 80)}`, "info");
   }
 }
 
@@ -1345,7 +1345,9 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       completionSummary: Type.Optional(Type.String({ description: "1-paragraph completion claim" })),
       verificationSummary: Type.Optional(Type.String({ description: "Per-item evidence for the verification contract" })),
     }),
-    async execute(_id, params, signal) {
+    async execute(_id, params, signal, _onUpdate, execCtx) {
+      const foreign0 = foreignToolGuard(execCtx);
+      if (foreign0) return { content: [{ type: "text", text: foreign0 }], details: {} };
       if (!state.goal || state.goal.status !== "active") {
         return { content: [{ type: "text", text: "No active goal." }], details: {} };
       }
@@ -1504,7 +1506,9 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       reason: Type.String({ description: "Why the work is paused" }),
       suggestedAction: Type.Optional(Type.String({ description: "What the user should do next" })),
     }),
-    async execute(_id, params) {
+    async execute(_id, params, _signal, _onUpdate, execCtx) {
+      const foreign1 = foreignToolGuard(execCtx);
+      if (foreign1) return { content: [{ type: "text", text: foreign1 }], details: {} };
       const p = params as { reason: string; suggestedAction?: string };
       if (!state.goal) return { content: [{ type: "text", text: "No active goal." }], details: {} };
       updateGoal({
@@ -1583,6 +1587,8 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       items: Type.Optional(Type.Array(Type.String(), { description: "LIST drafting only: many objectives at once (e.g. 'queue these 50 things'). Each becomes a list item; per-item 'Done when:' clauses are honored." })),
     }),
     async execute(_id, params, _signal, _onUpdate, execCtx) {
+      const foreign2 = foreignToolGuard(execCtx);
+      if (foreign2) return { content: [{ type: "text", text: foreign2 }], details: {} };
       const p = params as { objective: string; verificationContract?: string; items?: string[] };
       if (draftingTarget !== "goal" && draftingTarget !== "list") {
         return {
@@ -1591,11 +1597,15 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         };
       }
       // v0.14.0: the interview floor — no Confirm until the user replied.
-      // v0.14.0: the interview floor — no Confirm until the user replied.
-      if (draftingUserReplies === 0) draftingBlockedProposals++;
-      const block = draftProposalBlock(draftingUserReplies, draftingBlockedProposals);
-      if (block) {
-        return { content: [{ type: "text", text: block }], details: {} };
+      // v0.23.8: /glla autoaccept=on skips the floor AND the Confirm —
+      // the seed carries the intent (unattended rigs). Default off.
+      const autoAccept = loadSettings(ctx.cwd).autoAcceptDrafts === true;
+      if (!autoAccept) {
+        if (draftingUserReplies === 0) draftingBlockedProposals++;
+        const block = draftProposalBlock(draftingUserReplies, draftingBlockedProposals);
+        if (block) {
+          return { content: [{ type: "text", text: block }], details: {} };
+        }
       }
       // Multi-item drafts are LIST-only: a goal is single by definition.
       if (p.items && p.items.length > 0 && draftingTarget !== "list") {
@@ -1607,16 +1617,24 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       const liveCtx = (execCtx as ExtensionContext | undefined) ?? ctx;
       // Multi-item list draft: one Confirm for the whole batch.
       if (p.items && p.items.length > 0) {
-        const preview = p.items.slice(0, 6).map((t, i) => `  ${i + 1}. ${t.slice(0, 60)}`).join("\n");
+        // v0.23.7: show ALL items in full — the user approves the whole
+        // batch; hidden items would be approved blind.
+        const preview = p.items.map((t, i) => `  ${i + 1}. ${t}`).join("\n");
         const batchActivates = !state.goal || state.goal.status === "complete" || state.goal.status === "aborted";
         let batchConfirmed = false;
-        try {
-          batchConfirmed = await liveCtx.ui.confirm(
-            "Confirm queue batch",
-            `${p.items.length} items:\n${preview}${p.items.length > 6 ? `\n  … and ${p.items.length - 6} more` : ""}${batchActivates ? "\n\n(List is empty — confirming ACTIVATES item 1 immediately as the active goal.)" : ""}`,
-          );
-        } catch {
-          batchConfirmed = false;
+        if (autoAccept) {
+          batchConfirmed = true;
+          liveCtx.ui.notify(`List batch auto-accepted (/glla autoaccept=on): ${p.items.length} items${batchActivates ? " — item 1 ACTIVATES now" : ""}.`, "info");
+          appendLedger(liveCtx.cwd, "draft_autoaccepted", { kind: "batch", count: p.items.length });
+        } else {
+          try {
+            batchConfirmed = await liveCtx.ui.confirm(
+              "Confirm list batch",
+              `${p.items.length} items:\n${preview}${batchActivates ? "\n\n(List is empty — confirming ACTIVATES item 1 immediately as the active goal.)" : ""}`,
+            );
+          } catch {
+            batchConfirmed = false;
+          }
         }
         if (!batchConfirmed) {
           return {
@@ -1630,7 +1648,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         if (wasIdle) {
           return { content: [{ type: "text", text: `${n} items confirmed; first activated (list was empty). Begin work now.` }], details: {} };
         }
-        return { content: [{ type: "text", text: `${n} items confirmed and queued (${listQueue().length} waiting).` }], details: {} };
+        return { content: [{ type: "text", text: `${n} items confirmed and added to the list (${listQueue().length} waiting).` }], details: {} };
       }
       const normContract = p.verificationContract?.trim() ? normalizeDraftContract(p.verificationContract) : "";
       const checkCount = normContract ? draftContractItemCount(normContract) : 0;
@@ -1644,14 +1662,20 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       const willActivate = isListDraft && (!state.goal || state.goal.status === "complete" || state.goal.status === "aborted");
       const activationNote = isListDraft
         ? willActivate
-          ? "\n\n(List is empty — confirming ACTIVATES this immediately as the active goal. Reject if you only wanted to queue it.)"
-          : "\n\n(Goes into the list, queued behind the active goal.)"
+          ? "\n\n(List is empty — confirming ACTIVATES this immediately as the active goal. Reject if you only wanted to add it, not start it.)"
+          : "\n\n(Goes into the list, waiting behind the active goal.)"
         : "";
       let confirmed = false;
-      try {
-        confirmed = await liveCtx.ui.confirm(isListDraft ? "Confirm list item" : "Confirm goal", `${p.objective.trim()}${contractBlock}${activationNote}`);
-      } catch {
-        confirmed = false;
+      if (autoAccept) {
+        confirmed = true;
+        liveCtx.ui.notify(`Draft auto-accepted (/glla autoaccept=on)${willActivate ? " — ACTIVATING now" : ""}: ${p.objective.trim().slice(0, 90)}`, "info");
+        appendLedger(liveCtx.cwd, "draft_autoaccepted", { kind: isListDraft ? "list" : "goal", objective: p.objective.trim().slice(0, 200) });
+      } else {
+        try {
+          confirmed = await liveCtx.ui.confirm(isListDraft ? "Confirm list item" : "Confirm goal", `${p.objective.trim()}${contractBlock}${activationNote}`);
+        } catch {
+          confirmed = false;
+        }
       }
       if (!confirmed) {
         return {
@@ -1673,7 +1697,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
           activateNextListItem(liveCtx);
           return { content: [{ type: "text", text: "Confirmed and activated (list was empty). Begin work now." }], details: {} };
         }
-        return { content: [{ type: "text", text: `Confirmed and queued (${listQueue().length} waiting). It activates when the current goal completes.` }], details: {} };
+        return { content: [{ type: "text", text: `Confirmed and added to the list (${listQueue().length} waiting). It activates when the current goal completes.` }], details: {} };
       }
       const goal = createGoal(full, liveCtx);
       setGoal(goal, liveCtx);
@@ -1702,6 +1726,8 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       branch: Type.Optional(Type.Boolean({ description: "branch=true: scratch-branch mode (clean git tree required)" })),
     }),
     async execute(_id, params, _signal, _onUpdate, execCtx) {
+      const foreign3 = foreignToolGuard(execCtx);
+      if (foreign3) return { content: [{ type: "text", text: foreign3 }], details: {} };
       const p = params as { target: string; measureCmd?: string; direction?: "min" | "max"; window?: number; max?: number; time?: number; tokens?: number; branch?: boolean };
       if (draftingTarget !== "loop") {
         return {
@@ -1749,17 +1775,27 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       }
       const window = p.window && p.window > 0 ? Math.floor(p.window) : 5;
       // v0.23.0: explicit max=0 = truly unbounded (no iteration cap).
-      const max = p.max !== undefined && Number.isFinite(p.max) && p.max >= 0 ? Math.floor(p.max) : 50;
+      // v0.23.8: metricless + no explicit max = UNBOUNDED here too — the
+      // drafter path was still defaulting to 50 after v0.23.6 flipped the
+      // CLI default.
+      const max = p.max !== undefined && Number.isFinite(p.max) && p.max >= 0 ? Math.floor(p.max) : metricless ? 0 : 50;
+      const autoAccept = loadSettings(ctx.cwd).autoAcceptDrafts === true;
       let confirmed = false;
-      try {
-        confirmed = await liveCtx.ui.confirm(
+      if (autoAccept) {
+        confirmed = true;
+        liveCtx.ui.notify(`Loop draft auto-accepted (/glla autoaccept=on): ${p.target.trim().slice(0, 90)}`, "info");
+        appendLedger(liveCtx.cwd, "draft_autoaccepted", { kind: "loop", target: p.target.trim().slice(0, 200), metricless });
+      } else {
+        try {
+          confirmed = await liveCtx.ui.confirm(
           "Confirm loop",
           metricless
             ? `Target: ${p.target.trim()}\n\nMeasure: NONE — metricless spec loop. There is NO plateau stop: the loop ends only at ${max > 0 ? `${max} iterations` : "NO iteration cap"}${typeof p.time === "number" && p.time > 0 ? ` · Time bound: ${p.time}h` : ""}${typeof p.tokens === "number" && p.tokens > 0 ? ` · Token bound: ${p.tokens.toLocaleString()}` : ""} · /loop stop.${p.branch ? "\nbranch mode: scratch branch, every iteration committed (clean tree required)" : ""}\n\nEvery iteration must make ONE real, inspectable change — cosmetic churn is the known failure mode (doorknob-polishing). Start it?`
             : `Target: ${p.target.trim()}\n\nMeasure: ${p.measureCmd}\nTest-run output: ${rawOutput.slice(0, 200)}\nParsed number: ${parsed} (${p.direction === "min" ? "lower is better" : "higher is better"})\n\nPlateau stop: ${window} non-improving iterations · Cap: ${max > 0 ? `${max} iterations` : "none (unbounded)"}${typeof p.time === "number" && p.time > 0 ? ` · Time bound: ${p.time}h` : ""}${typeof p.tokens === "number" && p.tokens > 0 ? ` · Token bound: ${p.tokens.toLocaleString()}` : ""}${p.branch ? "\nbranch mode: scratch branch (clean tree required)" : ""}\n\nThe loop never completes — it runs until one of these bounds, plateau, or /loop stop. Start it?`,
-        );
-      } catch {
-        confirmed = false;
+          );
+        } catch {
+          confirmed = false;
+        }
       }
       if (!confirmed) {
         return {
@@ -1798,6 +1834,8 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       rationale: Type.String({ description: "Why the current spec no longer captures 'better' — shown to the user in the Confirm dialog" }),
     }),
     async execute(_id, params, _signal, _onUpdate, execCtx) {
+      const foreign4 = foreignToolGuard(execCtx);
+      if (foreign4) return { content: [{ type: "text", text: foreign4 }], details: {} };
       const p = params as { target?: string; measureCmd?: string; rationale: string };
       const liveCtx = (execCtx as ExtensionContext | undefined) ?? ctx;
       const loop = state.loop;
@@ -1862,12 +1900,14 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
 
   pi.registerTool(defineTool({
     name: "list_add",
-    label: "Add to queue",
-    description: "Add one or many objectives to the /list list (loop 2). Use when the user asks to queue work — 'add these to my list', 'queue these 10 things', 'put this on the backlog'. Each item becomes an audited goal; per-item 'Done when:' clauses are honored. The first queued item activates automatically when nothing is running. The list is UNBOUNDED — hundreds of small items are fine; propose them all.",
+    label: "Add to list",
+    description: "Add one or many objectives to the /list list (loop 2). Use when the user asks to add work — 'add these to my list', 'queue these 10 things', 'put this on the backlog'. The list is a POOL, not a FIFO: order is the default, not the law — any item can be activated next. Each item becomes an audited goal; per-item 'Done when:' clauses are honored. The first item activates automatically when nothing is running. The list is UNBOUNDED — hundreds of small items are fine; propose them all.",
     parameters: Type.Object({
-      items: Type.Array(Type.String(), { description: "Objectives to enqueue — no count limit; large plans belong in ONE call." }),
+      items: Type.Array(Type.String(), { description: "Objectives to add — no count limit; large plans belong in ONE call." }),
     }),
     async execute(_id, params, _signal, _onUpdate, execCtx) {
+      const foreign5 = foreignToolGuard(execCtx);
+      if (foreign5) return { content: [{ type: "text", text: foreign5 }], details: {} };
       const p = params as { items: string[] };
       if (listMutationBlocked(draftingTarget)) {
         return { content: [{ type: "text", text: LIST_DRAFTING_BLOCK_MESSAGE }], details: {} };
@@ -1883,7 +1923,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         content: [{
           type: "text",
           text: wasIdle
-            ? `${n} item(s) queued; the first is now active. Work it normally and call complete_goal when done — the next item activates automatically.`
+            ? `${n} item(s) added; the first is now active. Work it normally and call complete_goal when done — the next item activates automatically.`
             : `${n} item(s) queued (${listQueue().length} waiting behind the active goal).`,
         }],
         details: {},
@@ -1899,6 +1939,8 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       n: Type.Number({ description: "1-based position in the queue (1 = head)" }),
     }),
     async execute(_id, params, _signal, _onUpdate, execCtx) {
+      const foreign6 = foreignToolGuard(execCtx);
+      if (foreign6) return { content: [{ type: "text", text: foreign6 }], details: {} };
       const p = params as { n: number };
       if (listMutationBlocked(draftingTarget)) {
         return { content: [{ type: "text", text: LIST_DRAFTING_BLOCK_MESSAGE }], details: {} };
@@ -1972,11 +2014,18 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         const subs = (t.subtasks ?? []).map((s, j) => `   ${i + 1}.${j + 1} ${s}`).join("\n");
         return `${i + 1}. ${t.title}` + (subs ? `\n${subs}` : "");
       }).join("\n");
+      const autoAcceptTasks = loadSettings(ctx.cwd).autoAcceptDrafts === true;
       let confirmed = false;
-      try {
-        confirmed = await liveCtx.ui.confirm("Confirm task list", preview);
-      } catch {
-        confirmed = false;
+      if (autoAcceptTasks) {
+        confirmed = true;
+        liveCtx.ui.notify(`Task list auto-accepted (/glla autoaccept=on): ${p.tasks.length} tasks.`, "info");
+        appendLedger(liveCtx.cwd, "draft_autoaccepted", { kind: "tasks", count: p.tasks.length });
+      } else {
+        try {
+          confirmed = await liveCtx.ui.confirm("Confirm task list", preview);
+        } catch {
+          confirmed = false;
+        }
       }
       if (!confirmed) {
         return { content: [{ type: "text", text: "Task list rejected by the user. Adjust and propose again." }], details: {} };
@@ -2011,6 +2060,10 @@ interface Settings {
   /** on → restored goals/loops/lists auto-resume even in fresh sessions
    * (unattended rigs). Default off: restore holds until /goal resume. */
   autoResume?: boolean;
+  /** on → propose_* drafts activate WITHOUT the Confirm dialog and the
+   * interview floor is skipped — the seed carries the intent (unattended
+   * rigs). Default off: nothing activates before the user confirms. */
+  autoAcceptDrafts?: boolean;
 }
 
 const DEFAULT_SETTINGS: Settings = {
@@ -2055,7 +2108,7 @@ function settingsProvenance(cwd: string): Record<keyof Settings, { value: unknow
   const glob = readSettingsFile(globalSettingsPath());
   const effective = loadSettings(cwd);
   const out: Record<string, { value: unknown; source: "project" | "global" | "default" }> = {};
-  const keys: Array<keyof Settings> = ["auditorModel", "auditorThinkingLevel", "notifyCmd", "tokenLimit", "wedgeAlertMinutes", "autoResume"];
+  const keys: Array<keyof Settings> = ["auditorModel", "auditorThinkingLevel", "notifyCmd", "tokenLimit", "wedgeAlertMinutes", "autoResume", "autoAcceptDrafts"];
   for (const k of keys) {
     if ((proj as Record<string, unknown>)[k] !== undefined) out[k] = { value: (proj as any)[k], source: "project" };
     else if ((glob as Record<string, unknown>)[k] !== undefined) out[k] = { value: (glob as any)[k], source: "global" };
@@ -2181,7 +2234,7 @@ async function openSettingsUI(ctx: ExtensionContext): Promise<void> {
           else ctx.ui.notify(`Not a non-negative integer: ${v}`, "warning");
         }
       } else if (choice.startsWith("Wedge alert")) {
-        const v = await ctx.ui.input("Wedge alert threshold (minutes)", "non-negative integer; 0 = off, empty = default 45");
+        const v = await ctx.ui.input("Wedge alert threshold (minutes)", "non-negative integer; 0 = off, empty = default 30");
         if (v !== undefined) {
           const n = Number.parseInt(v.trim(), 10);
           if (Number.isFinite(n) && n >= 0) saveSettings("global", ctx.cwd, { wedgeAlertMinutes: n });
@@ -2225,6 +2278,7 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
         fmt("notifyCmd", "notify"),
         fmt("tokenLimit", "tokenLimit"),
         fmt("autoResume", "autoResume"),
+        fmt("autoAcceptDrafts", "autoAccept"),
         `\nglobal:  ${globalSettingsPath()}`,
         `project: ${projectSettingsPath(ctx.cwd)}`,
         `Set with: /glla key=value (global) · /glla project key=value (project override)`,
@@ -2270,7 +2324,7 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
       } else {
         const n = Number.parseInt(value, 10);
         if (Number.isFinite(n) && n >= 0) {
-          patch.wedgeAlertMinutes = n; // 0 = off; unset = default 45
+          patch.wedgeAlertMinutes = n; // 0 = off; unset = default 30
           changed = true;
         } else {
           ctx.ui.notify(`wedgealert must be a non-negative integer (minutes, 0 = off), got: ${value}`, "warning");
@@ -2286,6 +2340,17 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
       } else {
         ctx.ui.notify(`autoresume must be on or off, got: ${value}`, "warning");
       }
+    } else if (key === "autoaccept") {
+      if (["on", "true", "1", "yes"].includes(value)) {
+        patch.autoAcceptDrafts = true;
+        changed = true;
+        ctx.ui.notify("autoaccept=on: drafts will ACTIVATE without the Confirm dialog (the interview floor is skipped too — the seed is the intent). /glla autoaccept=off restores the gate.", "warning");
+      } else if (["off", "false", "0", "no", "unset"].includes(value)) {
+        patch.autoAcceptDrafts = undefined;
+        changed = true;
+      } else {
+        ctx.ui.notify(`autoaccept must be on or off, got: ${value}`, "warning");
+      }
     } else if (key === "thinking" || key === "auditorthinkinglevel") {
       if (["off", "minimal", "low", "medium", "high", "xhigh"].includes(value)) {
         patch.auditorThinkingLevel = value as Settings["auditorThinkingLevel"];
@@ -2417,6 +2482,7 @@ export default function (pi: ExtensionAPI): void {
       ["notify=", "desktop push command: /glla notify='notify-send pi \"$1\"'"],
       ["tokenlimit=", "per-goal token budget (0 = off): /glla tokenlimit=2000000"],
       ["autoresume=", "on: auto-resume held goals/loops in fresh sessions"],
+      ["autoaccept=", "on: drafts activate without the Confirm dialog (unattended rigs)"],
       ["project", "write a project override: /glla project key=value"],
     ]),
     handler: settingsHandler,
@@ -2424,7 +2490,7 @@ export default function (pi: ExtensionAPI): void {
   pi.registerCommand("list", {
     description: "Loop 2: the list of audited goals — order is the default, not the law. /list <describe tasks or name a plan file> (dumps get shaped into items, files import, 'Done when:' adds directly) | /list show | /list resume | /list next [n] | /list remove <n> | /list clear",
     getArgumentCompletions: completions([
-      ["show", "display the queued items"],
+      ["show", "display the waiting items"],
       ["resume", "resume the paused list item (the list's head)"],
       ["next", "activate the next item (or /list next <n> for position n)"],
       ["remove", "remove an item: /list remove <n>"],
@@ -2470,6 +2536,10 @@ export default function (pi: ExtensionAPI): void {
 
   pi.on("session_start", async (event: any, ctx: ExtensionContext) => {
     rememberCtx(ctx);
+    // v0.23.8: subagent sessions (pi-subagents binds extensions there too)
+    // are workers — never run the restore gate or reschedule the loop from
+    // a foreign session.
+    if (isForeignCtx(ctx)) return;
     state = readState(ctx.cwd);
     if (!registeredCtx) {
       registerAgentTools(pi, ctx);
@@ -2512,14 +2582,14 @@ export default function (pi: ExtensionAPI): void {
         // v0.22.7: name WHAT is held — a list head resumes through /list.
         const isListItem = state.goal.policy === "list";
         const resumeCmd = isListItem ? "/list resume" : "/goal resume";
-        const resumeHint = `${resumeCmd} to continue${queued > 0 ? ` (+${queued} queued in the list)` : ""} · /glla autoresume=on to auto-resume in this project`;
+        const resumeHint = `${resumeCmd} to continue${queued > 0 ? ` (+${queued} waiting in the list)` : ""} · /glla autoresume=on to auto-resume in this project`;
         updateGoal({
           status: "paused",
           pauseReason: "restored in a fresh session — no work started",
           pauseSuggestedAction: resumeHint,
         }, ctx);
         ctx.ui.notify(
-          `${isListItem ? "List item" : "Goal"} held on restore [${state.goal.id}]: ${state.goal.objective.slice(0, 70)}${queued > 0 ? ` (+${queued} queued in the list)` : ""} — ${resumeCmd} to continue.`,
+          `${isListItem ? "List item" : "Goal"} held on restore [${state.goal.id}]: ${state.goal.objective.slice(0, 70)}${queued > 0 ? ` (+${queued} waiting in the list)` : ""} — ${resumeCmd} to continue.`,
           "info",
         );
       }
@@ -2547,6 +2617,9 @@ export default function (pi: ExtensionAPI): void {
 
   pi.on("agent_end", async (event: any, ctx: ExtensionContext) => {
     rememberCtx(ctx);
+    // v0.23.8: a subagent finishing must not drive the main session's
+    // continuation loop.
+    if (isForeignCtx(ctx)) return;
     noteActivity();
     if (!registeredCtx) {
       registerAgentTools(pi, ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.23.6",
+  "version": "0.23.8",
   "description": "Goal. Loop. Audit. Done. — a pi-coding-agent extension that supervises long-running work, with isolated auditor on each completion. Beat bamboozling by design: the auditor runs in a fresh session with no extensions, no skills, no editor — only the read tools needed to verify your goal.",
   "license": "MIT",
   "author": "dracon",

package/prompts/goal-loop-forever-draft.md

@@ -38,10 +38,12 @@ stops it.
 3. Clarify the **direction**: is lower better (min) or higher better (max)?
    (Skip this for a metricless loop — there is no direction without a metric.)
 4. Optional tuning: `window` (plateau stop after N non-improving iterations,
-   default 5 — meaningless for metricless), `max` (iteration cap, default 50;
-   `max=0` = truly unbounded). Suggest smaller values for expensive measures.
-   For metricless loops, ALWAYS discuss bounds — an unbounded metricless loop
-   is a deliberate furnace.
+   default 5 — meaningless for metricless), `max` (iteration cap: default 50
+   for METRIC loops; default UNBOUNDED (`max=0`) for metricless loops,
+   v0.23.6 — a bare infinite loop is the point of the metricless form).
+   Suggest smaller values for expensive measures. For metricless loops,
+   ALWAYS discuss bounds — an unbounded metricless loop is a deliberate
+   furnace.
 5. When concrete, call `propose_loop_draft` with `target`, `measureCmd` (or
    omit/`"none"` for metricless), `direction` (measured only), and optional
    `window`/`max`/`time`/`tokens`.