pi-goal-list-loop-audit 0.23.7 → 0.24.0

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
@@ -77,6 +77,17 @@ inspectable change; cosmetic churn is the known failure mode
 number, and tells you the trade-off before you confirm. Work with a finish
 line is still a `/goal`.
 
+**Anti-repetition** (v0.24.0, both loop flavors): the plateau stop watches
+the *number*; the stuck ladder watches the *work*. Every iteration is
+classified — exact/near-duplicate replies, A-B-A-B alternation, same
+tool-same-result three times, narration-only streaks, degenerate
+single-reply repetition — and a stuck iteration swaps the next prompt for
+a rotating intervention (different approach → different subtask →
+PROGRESS.md → fix one test failure → review your own diff). Three stuck in
+a row escalates to a hard reset (banned openings, tool-call-first); five
+stops the loop with the reason — bounded and surfaced, like plateau.
+Continuation lines also rotate: identical prompts invite identical answers.
+
 Subcommands match **exactly** — `/goal pause the pipeline` sets an objective
 about a pipeline; only bare `/goal pause` pauses. (Same rule everywhere, so
 your objectives can start with any verb.)
@@ -91,7 +102,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 +155,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 +197,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 +208,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

@@ -670,3 +670,21 @@ export function extractVerificationContract(raw: string): { objective: string; v
   }
   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/goal-loop-forever.ts

@@ -58,6 +58,20 @@ export interface LoopState {
   branchName?: string;
   /** branch=1 mode: the branch to return to on stop. */
   originalBranch?: string;
+  /** v0.24.0 anti-repetition: rolling fingerprints of iteration replies. */
+  recentPrints?: string[];
+  /** v0.24.0: last few iteration texts (near-duplicate check + banned openings). */
+  recentTexts?: string[];
+  /** v0.24.0: rolling tool-result fingerprints {tool, hash, isError}. */
+  recentToolResults?: { tool: string; hash: string; isError: boolean }[];
+  /** v0.24.0: tool calls seen since the last completed iteration. */
+  toolsThisTurn?: number;
+  /** v0.24.0: consecutive iterations with zero tool calls. */
+  toollessStreak?: number;
+  /** v0.24.0: consecutive stuck interventions (resets on a clean iteration). */
+  consecutiveStuck?: number;
+  /** v0.24.0: the last stuck reason (for the intervention directive + ledger). */
+  lastStuckReason?: string;
 }
 
 /** Scratch-branch name for branch=1 mode. Format pinned by tests. */

package/extensions/goal-loop-repetition.ts

@@ -0,0 +1,253 @@
+/**
+ * Loop anti-repetition (v0.24.0) — pure, stateless detectors for the failure
+ * mode the plateau stop cannot see: the loop keeps "working" but the work is
+ * the SAME work. Plateau watches the number; this watches the behavior.
+ *
+ * Clean-room implementation of standard techniques (rolling text
+ * fingerprints, word-trigram Jaccard similarity, repeated-n-gram detection)
+ * for pi-loop-mode's AGPL-licensed repertoire — no code shared.
+ *
+ * Everything here is a pure function; LoopState holds the rolling windows and
+ * runLoopTick (loops/goal.ts) feeds them in. One mechanical predicate per
+ * behavior — no fuzzy heuristics.
+ */
+
+import { createHash } from "node:crypto";
+
+export const REPETITION = {
+  /** Jaccard similarity at which two consecutive iterations count as a near-duplicate. */
+  similarityThreshold: 0.8,
+  /** Minimum normalized length before exact/near-duplicate checks apply (short replies repeat innocently). */
+  minExactLength: 80,
+  minSimilarLength: 60,
+  /** Same fingerprint seen this often inside the rolling window = alternating repetition (A-B-A-B). */
+  windowRepeat: 3,
+  /** Rolling window sizes held on LoopState. */
+  printWindow: 12,
+  textWindow: 3,
+  toolWindow: 6,
+  /** Last N identical tool results (same tool, same output) = no new information. */
+  toolResultRepeat: 3,
+  /** Consecutive iterations with zero tool calls = narration only. */
+  toollessIterations: 2,
+  /** Degenerate single-response repetition (one sentence/word/phrase looping inside ONE reply). */
+  degenerateMinLength: 150,
+  degenerateSentenceRepeats: 4,
+  degenerateWordRepeats: 16,
+  degeneratePhraseRepeats: 8,
+  degenerateMaxPhraseWords: 4,
+  /** Escalation ladder: hard-reset directive after this many consecutive stuck turns… */
+  hardResetAfter: 3,
+  /** …and the loop STOPS after this many (bounded, surfaced — same philosophy as plateau). */
+  maxInterventions: 5,
+} as const;
+
+/** Strip ANSI, collapse whitespace, lowercase — the canonical form all checks use. */
+export function normalizeForPrint(text: string): string {
+  return text.replace(/\x1b\[[0-9;]*m/g, "").replace(/\s+/g, " ").trim().toLowerCase();
+}
+
+/** Stable short fingerprint of one reply's canonical form. */
+export function textFingerprint(text: string): string {
+  return createHash("sha256").update(normalizeForPrint(text).slice(0, 4000)).digest("hex").slice(0, 16);
+}
+
+/** Digits are volatile (counters, timestamps, PIDs) — blank them so "try port 8081" ≈ "try port 8082". */
+function canonical(text: string): string {
+  return normalizeForPrint(text).replace(/\d+/g, "#");
+}
+
+function wordTrigrams(text: string): Set<string> {
+  const words = canonical(text).split(" ").filter(Boolean);
+  const out = new Set<string>();
+  if (words.length < 3) {
+    if (words.length) out.add(words.join(" "));
+    return out;
+  }
+  for (let i = 0; i + 3 <= words.length; i++) out.add(`${words[i]} ${words[i + 1]} ${words[i + 2]}`);
+  return out;
+}
+
+/** Jaccard similarity over word trigrams: 0 = nothing shared, 1 = same shingle set. */
+export function trigramSimilarity(a: string, b: string): number {
+  const sa = wordTrigrams(a);
+  const sb = wordTrigrams(b);
+  if (sa.size === 0 || sb.size === 0) return 0;
+  let shared = 0;
+  for (const t of sa) if (sb.has(t)) shared++;
+  return shared / (sa.size + sb.size - shared);
+}
+
+export interface DegenerateRepeat {
+  kind: "sentence" | "word" | "phrase";
+  unit: string;
+  count: number;
+}
+
+function tokenRun(text: string): DegenerateRepeat | undefined {
+  const tokens = normalizeForPrint(text).match(/[\p{L}\p{N}_'-]+/gu) ?? [];
+  for (let width = 1; width <= REPETITION.degenerateMaxPhraseWords; width++) {
+    const needed = width === 1 ? REPETITION.degenerateWordRepeats : REPETITION.degeneratePhraseRepeats;
+    for (let start = 0; start + width * needed <= tokens.length; start++) {
+      let run = 1;
+      while (
+        start + (run + 1) * width <= tokens.length &&
+        tokens.slice(start, start + width).join("") === tokens.slice(start + run * width, start + (run + 1) * width).join("")
+      ) {
+        run++;
+      }
+      if (run >= needed) {
+        return { kind: width === 1 ? "word" : "phrase", unit: tokens.slice(start, start + width).join(" "), count: run };
+      }
+    }
+  }
+  return undefined;
+}
+
+/** One sentence/word/phrase looping inside a SINGLE response (degenerate generation). */
+export function findDegenerateRepeat(text: string): DegenerateRepeat | undefined {
+  const canon = canonical(text);
+  if (canon.length < REPETITION.degenerateMinLength) return undefined;
+  const sentences = canon
+    .split(/(?<=[.!?])\s+|\n+/)
+    .map((s) => s.trim())
+    .filter((s) => s.length >= 15);
+  if (sentences.length >= REPETITION.degenerateSentenceRepeats) {
+    const counts = new Map<string, number>();
+    for (const s of sentences) counts.set(s, (counts.get(s) ?? 0) + 1);
+    let unit = "";
+    let best = 0;
+    for (const [s, n] of counts) if (n > best) { unit = s; best = n; }
+    if (best >= REPETITION.degenerateSentenceRepeats && best / sentences.length >= 0.5) {
+      return { kind: "sentence", unit, count: best };
+    }
+  }
+  return tokenRun(text);
+}
+
+export interface ToolResultPrint {
+  tool: string;
+  hash: string;
+  isError: boolean;
+}
+
+export interface LoopStuckInput {
+  /** Last assistant text of the finished iteration. */
+  assistantText: string;
+  /** Rolling fingerprints INCLUDING the current iteration's (appended last). */
+  recentPrints: string[];
+  /** Previous iteration's assistant text (for the near-duplicate check). */
+  previousText?: string;
+  /** Rolling tool-result prints (most recent last). */
+  recentToolResults: ToolResultPrint[];
+  /** Consecutive iterations with zero tool calls, including this one. */
+  toollessStreak: number;
+}
+
+function clip(text: string, n: number): string {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length <= n ? flat : `${flat.slice(0, n)}…`;
+}
+
+/**
+ * The one classifier: given the rolling windows, WHY is the loop stuck —
+ * or undefined when it's working normally. Checks run cheapest-and-most-
+ * certain first; the first hit wins so the reason stays specific.
+ */
+export function detectLoopStuck(input: LoopStuckInput): string | undefined {
+  const { assistantText, recentPrints, previousText, recentToolResults, toollessStreak } = input;
+
+  // Narration only: iterations that never touch tools produce nothing inspectable.
+  if (toollessStreak >= REPETITION.toollessIterations) {
+    return `no tool calls for ${toollessStreak} iterations (narration only)`;
+  }
+
+  // Degenerate generation inside the current response.
+  const degenerate = findDegenerateRepeat(assistantText);
+  if (degenerate) {
+    return `response degenerated: same ${degenerate.kind} repeated ${degenerate.count}× ("${clip(degenerate.unit, 60)}")`;
+  }
+
+  // Exact repeat of the immediately previous iteration.
+  const lastTwo = recentPrints.slice(-2);
+  if (lastTwo.length === 2 && lastTwo[0] === lastTwo[1] && normalizeForPrint(assistantText).length > REPETITION.minExactLength) {
+    return "repeated the previous response exactly";
+  }
+
+  // Near-duplicate of the previous iteration (slight rephrasing defeats fingerprints).
+  if (previousText && normalizeForPrint(assistantText).length > REPETITION.minSimilarLength) {
+    const sim = trigramSimilarity(assistantText, previousText);
+    if (sim >= REPETITION.similarityThreshold) {
+      return `response ~${Math.round(sim * 100)}% similar to the previous iteration`;
+    }
+  }
+
+  // Alternating repetition (A-B-A-B): the current fingerprint keeps recurring in the window.
+  const current = recentPrints[recentPrints.length - 1];
+  if (current && recentPrints.filter((p) => p === current).length >= REPETITION.windowRepeat) {
+    return `same response ${REPETITION.windowRepeat}+ times in recent iterations`;
+  }
+
+  // Same tool, same output, three times running: the loop is re-reading a result it already has.
+  const recentTools = recentToolResults.slice(-REPETITION.toolResultRepeat);
+  if (
+    recentTools.length === REPETITION.toolResultRepeat &&
+    recentTools.every((r) => r.tool === recentTools[0]!.tool && r.hash === recentTools[0]!.hash)
+  ) {
+    return recentTools.every((r) => r.isError)
+      ? `same ${recentTools[0]!.tool} error ${REPETITION.toolResultRepeat}× in a row`
+      : `same ${recentTools[0]!.tool} result ${REPETITION.toolResultRepeat}× in a row (no new information)`;
+  }
+
+  return undefined;
+}
+
+/**
+ * Rotating stuck interventions — a repeated identical nudge gets filtered as
+ * noise, so each consecutive stuck turn gets a DIFFERENT instruction.
+ * consecutiveStuck is 1-based (1 = first intervention).
+ */
+export function loopInterventionDirective(consecutiveStuck: number, reason: string, recentTexts: string[]): string {
+  const strategies = [
+    "Abandon the current angle entirely. Pick a genuinely different approach — different file, different technique — and execute it now.",
+    "Switch to a part of the target you have NOT touched in recent iterations and make one concrete, inspectable change there.",
+    "Write a short PROGRESS.md: current state, what was tried, what keeps failing, the next 3 concrete steps. Then execute step 1.",
+    "Run the project's build/tests, pick exactly ONE failure or warning, and fix only that.",
+    "Review your recent changes (git diff / git log), find one real problem in them, and fix it.",
+  ];
+  const strategy = strategies[(consecutiveStuck - 1) % strategies.length]!;
+  let escalation = "";
+  if (consecutiveStuck >= REPETITION.hardResetAfter) {
+    const banned = recentTexts
+      .map((t) => clip(normalizeForPrint(t), 40))
+      .filter(Boolean)
+      .map((t) => `"${t}"`)
+      .join(", ");
+    escalation =
+      ` HARD RESET (stuck intervention #${consecutiveStuck} in a row): forget your previous phrasing entirely.` +
+      (banned ? ` Banned openings: ${banned}.` : "") +
+      " Your FIRST action this turn must be a tool call that changes a file or produces new information — zero preamble text before it.";
+  }
+  return `⚠ STUCK — ${reason}.${escalation} ${strategy}`;
+}
+
+/**
+ * Varied continuation lines for metricless iterations: identical prompts
+ * invite identical answers, so the base instruction rotates by iteration.
+ */
+export function continueVariant(iteration: number): string {
+  const variants = [
+    "Advance the target with the next concrete, inspectable change.",
+    "Continue: pick the next unit of work from your plan and do it now.",
+    "Keep going — one real change that moves the target forward.",
+    "Proceed with the next focused step toward the target.",
+    "Make the next improvement; something you can point at in a diff.",
+  ];
+  return variants[iteration % variants.length]!;
+}
+
+/** Cap helper for the rolling windows on LoopState. */
+export function pushCapped<T>(arr: T[], item: T, cap: number): T[] {
+  const next = [...arr, item];
+  return next.length > cap ? next.slice(next.length - cap) : next;
+}

package/extensions/loops/goal.ts

@@ -56,6 +56,7 @@ import {
   normalizeDraftContract,
   draftContractItemCount,
   extractVerificationContract,
+  classifySessionCtx,
   readState,
   renderGoalMarkdown,
   shouldAutoResumeOnSessionStart,
@@ -63,6 +64,14 @@ import {
   writeGoalMd,
 } from "../goal-loop-core.js";
 import { runGoalCompletionAuditor } from "../goal-loop-auditor.js";
+import {
+  REPETITION,
+  detectLoopStuck,
+  loopInterventionDirective,
+  continueVariant,
+  textFingerprint,
+  pushCapped as pushRepetitionCapped,
+} from "../goal-loop-repetition.js";
 import { buildStatusText, buildWidgetLines, type AuditDisplayProgress } from "../goal-loop-display.js";
 import {
   applyMeasurement,
@@ -105,11 +114,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
@@ -361,7 +396,7 @@ function persistState(ctx: ExtensionContext): void {
 }
 
 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);
@@ -453,7 +488,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 {
@@ -567,7 +602,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");
@@ -590,8 +625,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);
@@ -654,8 +689,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;
@@ -700,13 +735,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;
@@ -718,7 +755,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");
   }
 }
 
@@ -744,7 +781,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") {
@@ -885,7 +922,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");
   }
 }
 
@@ -953,7 +990,7 @@ async function runGit(ctx: ExtensionContext, args: string[]): Promise<{ ok: bool
   }
 }
 
-function loopPrompt(loop: LoopState, regressionNote: string, strategyNote: string, boundsNote: string): string {
+function loopPrompt(loop: LoopState, regressionNote: string, strategyNote: string, boundsNote: string, interventionNote = "", variantNote = ""): string {
   // v0.23.0: metricless loops get their own prompt — no metric section,
   // anti-doorknob rules instead of anti-gaming rules.
   const metricless = !loop.measureCmd;
@@ -963,8 +1000,8 @@ function loopPrompt(loop: LoopState, regressionNote: string, strategyNote: strin
     tmpl = fs.readFileSync(tmplPath, "utf-8");
   } catch {
     tmpl = metricless
-      ? `[LOOP ITERATION ${loop.iteration + 1}] Target: ${loop.target}. Metricless spec loop — make ONE real, inspectable change advancing the target. No cosmetic churn.`
-      : `[LOOP ITERATION ${loop.iteration + 1}] Target: ${loop.target}. Measure: ${loop.measureCmd} (${loop.direction}). Make ONE small change to improve the metric.`;
+      ? `[LOOP ITERATION ${loop.iteration + 1}] Target: ${loop.target}. Metricless spec loop — make ONE real, inspectable change advancing the target. No cosmetic churn. ${variantNote} ${interventionNote}`
+      : `[LOOP ITERATION ${loop.iteration + 1}] Target: ${loop.target}. Measure: ${loop.measureCmd} (${loop.direction}). Make ONE small change to improve the metric. ${interventionNote}`;
   }
   return tmpl
     .replace(/\$\{ITERATION\}/g, String(loop.iteration + 1))
@@ -978,7 +1015,9 @@ function loopPrompt(loop: LoopState, regressionNote: string, strategyNote: strin
     .replace(/\$\{PLATEAU_WINDOW\}/g, String(loop.plateauWindow))
     .replace(/\$\{REGRESSION_NOTE\}/g, regressionNote)
     .replace(/\$\{STRATEGY_NOTE\}/g, strategyNote)
-    .replace(/\$\{BOUNDS_NOTE\}/g, boundsNote);
+    .replace(/\$\{BOUNDS_NOTE\}/g, boundsNote)
+    .replace(/\$\{INTERVENTION_NOTE\}/g, interventionNote)
+    .replace(/\$\{VARIANT_NOTE\}/g, variantNote);
 }
 
 function scheduleLoopTick(ctx: ExtensionContext): void {
@@ -1031,10 +1070,18 @@ function sendLoopTurn(): void {
   } else if (bounds.length) {
     boundsNote = `\n- Arbitrary bounds: the loop also stops after ${bounds.join(" or ")}`;
   }
+  // v0.24.0: a stuck intervention REPLACES the pep talk — the rotating
+  // directive names why the loop is stuck and what rung of the ladder it's on.
+  const interventionNote = (loop.consecutiveStuck ?? 0) > 0 && loop.lastStuckReason
+    ? loopInterventionDirective(loop.consecutiveStuck!, loop.lastStuckReason, loop.recentTexts ?? [])
+    : "";
+  // v0.24.0: identical prompts invite identical answers — rotate the base
+  // instruction (metricless loops; metric loops already vary via values).
+  const variantNote = metricless ? continueVariant(loop.iteration) : "";
   try {
     extensionApi.sendMessage({
       customType: GOAL_EVENT_ENTRY,
-      content: loopPrompt(loop, regressionNote, strategyNote, boundsNote),
+      content: loopPrompt(loop, regressionNote, strategyNote, boundsNote, interventionNote, variantNote),
       display: false,
     }, { triggerTurn: true, deliverAs: "followUp" });
   } catch {
@@ -1054,10 +1101,40 @@ async function runLoopTick(ctx: ExtensionContext, event?: any): Promise<void> {
   // Hypothesis line (pi-autoresearch's good idea): the agent's stated intent
   // for the turn goes into the ledger, making loop history auditable.
   let hypothesis: string | undefined;
+  let lastAssistantText = "";
   if (event) {
     const last = [...(event.messages as any[])].reverse().find((m) => m.role === "assistant");
-    const text = last && Array.isArray(last.content) ? last.content.filter((p: any) => p.type === "text").map((p: any) => p.text).join("\n") : "";
-    hypothesis = text.match(/^HYPOTHESIS:\s*(.+)$/m)?.[1]?.trim().slice(0, 200);
+    lastAssistantText = last && Array.isArray(last.content) ? last.content.filter((p: any) => p.type === "text").map((p: any) => p.text).join("\n") : "";
+    hypothesis = lastAssistantText.match(/^HYPOTHESIS:\s*(.+)$/m)?.[1]?.trim().slice(0, 200);
+  }
+  // v0.24.0 anti-repetition: roll the behavior windows, then classify. The
+  // plateau stop watches the NUMBER; this watches the WORK — a metricless
+  // loop (no number) has no other defense against doorknob-polishing.
+  const toolsUsed = loop.toolsThisTurn ?? 0;
+  loop.toolsThisTurn = 0;
+  loop.toollessStreak = toolsUsed === 0 ? (loop.toollessStreak ?? 0) + 1 : 0;
+  const previousText = loop.recentTexts && loop.recentTexts.length > 0 ? loop.recentTexts[loop.recentTexts.length - 1] : undefined;
+  if (lastAssistantText) {
+    loop.recentPrints = pushRepetitionCapped(loop.recentPrints ?? [], textFingerprint(lastAssistantText), REPETITION.printWindow);
+    loop.recentTexts = pushRepetitionCapped(loop.recentTexts ?? [], lastAssistantText, REPETITION.textWindow);
+  }
+  const stuckReason = detectLoopStuck({
+    assistantText: lastAssistantText,
+    recentPrints: loop.recentPrints ?? [],
+    previousText,
+    recentToolResults: loop.recentToolResults ?? [],
+    toollessStreak: loop.toollessStreak ?? 0,
+  });
+  if (stuckReason) {
+    loop.consecutiveStuck = (loop.consecutiveStuck ?? 0) + 1;
+    loop.lastStuckReason = stuckReason;
+    appendLedger(ctx.cwd, "loop_stuck", { iteration: loop.iteration, reason: stuckReason, consecutive: loop.consecutiveStuck });
+    if (loop.consecutiveStuck === 1 || loop.consecutiveStuck >= REPETITION.hardResetAfter) {
+      ctx.ui.notify(`Loop stuck (${loop.consecutiveStuck}×): ${stuckReason}`, "warning");
+    }
+  } else {
+    loop.consecutiveStuck = 0;
+    loop.lastStuckReason = undefined;
   }
   const outcome = metricless ? applyMetriclessTick(loop, nowIso()) : applyMeasurement(loop, value, nowIso());
   persistState(ctx);
@@ -1067,6 +1144,7 @@ async function runLoopTick(ctx: ExtensionContext, event?: any): Promise<void> {
     best: loop.bestValue,
     stall: loop.stallCount,
     hypothesis,
+    stuck: stuckReason,
   });
   // branch=1 mode: commit improvements, hard-reset regressions — always and
   // only on the scratch branch. v0.23.0: a metricless loop has no regression
@@ -1082,6 +1160,18 @@ async function runLoopTick(ctx: ExtensionContext, event?: any): Promise<void> {
     }
     persistState(ctx);
   }
+  // v0.24.0: the top of the stuck ladder — bounded and surfaced, same
+  // philosophy as a plateau stop. The loop ends WITH the reason, not in silence.
+  if (outcome.kind !== "stop" && (loop.consecutiveStuck ?? 0) >= REPETITION.maxInterventions) {
+    loop.active = false;
+    loop.stopReason = `stuck — ${loop.lastStuckReason} (${loop.consecutiveStuck} consecutive interventions)`;
+    persistState(ctx);
+    await finishLoopGit(ctx, loop);
+    ctx.ui.notify(`Loop stopped: ${loop.stopReason}. ${loop.history.length} iterations recorded.`, "warning");
+    appendLedger(ctx.cwd, "loop_stopped", { reason: loop.stopReason, iterations: loop.iteration, best: loop.bestValue });
+    notifyExternal(ctx, `Loop stopped: ${loop.stopReason}`);
+    return;
+  }
   if (outcome.kind === "stop") {
     await finishLoopGit(ctx, loop);
     ctx.ui.notify(`Loop stopped: ${outcome.reason}. ${loop.history.length} iterations recorded.`, "info");
@@ -1316,7 +1406,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: {} };
       }
@@ -1475,7 +1567,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({
@@ -1554,6 +1648,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 {
@@ -1562,11 +1658,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") {
@@ -1583,13 +1683,19 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         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}${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 {
@@ -1603,7 +1709,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;
@@ -1617,14 +1723,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 {
@@ -1646,7 +1758,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);
@@ -1675,6 +1787,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 {
@@ -1722,17 +1836,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 {
@@ -1771,6 +1895,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;
@@ -1835,12 +1961,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: {} };
@@ -1856,7 +1984,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: {},
@@ -1872,6 +2000,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: {} };
@@ -1945,11 +2075,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: {} };
@@ -1984,6 +2121,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 = {
@@ -2028,7 +2169,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" };
@@ -2198,6 +2339,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)`,
@@ -2259,6 +2401,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"];
@@ -2390,6 +2543,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,
@@ -2397,7 +2551,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>"],
@@ -2435,6 +2589,18 @@ export default function (pi: ExtensionAPI): void {
   // v0.15.1: ask_user_question answers arrive as tool results, not chat
   // messages — count answered (non-cancelled) questionnaires as replies too.
   pi.on("tool_result", async (event: any) => {
+    // v0.24.0: roll loop tool-result fingerprints (same-tool-same-result
+    // detection) — recorded for ANY tool result while a loop is active.
+    if (isLoopActive()) {
+      const loop = state.loop!;
+      const out = event?.output ?? event?.result ?? event?.details ?? "";
+      const text = typeof out === "string" ? out : JSON.stringify(out) ?? "";
+      loop.recentToolResults = pushRepetitionCapped(
+        loop.recentToolResults ?? [],
+        { tool: String(event?.toolName ?? "?"), hash: textFingerprint(text), isError: Boolean(event?.isError ?? event?.error) },
+        REPETITION.toolWindow,
+      );
+    }
     if (draftingTarget === null) return;
     if (askUserQuestionAnswered(String(event?.toolName ?? ""), event?.details)) {
       draftingUserReplies++;
@@ -2443,6 +2609,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);
@@ -2485,14 +2655,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",
         );
       }
@@ -2520,6 +2690,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);
@@ -2615,5 +2788,9 @@ export default function (pi: ExtensionAPI): void {
   pi.on("tool_call", () => {
     toolCallsThisTurn++;
     noteActivity();
+    // v0.24.0: count loop-iteration tool calls (narration-only detection).
+    if (isLoopActive()) {
+      state.loop!.toolsThisTurn = (state.loop!.toolsThisTurn ?? 0) + 1;
+    }
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.23.7",
+  "version": "0.24.0",
   "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-metricless.md

@@ -16,10 +16,13 @@ ${TARGET}
 
 ## Your job THIS turn
 
+${VARIANT_NOTE}
+
 Start your reply with exactly one line: `HYPOTHESIS: <what you will change and why it is real progress on the spec>`.
 Then make **ONE** concrete, inspectable change that advances the target.
 Then stop.
 
+${INTERVENTION_NOTE}
 ${REGRESSION_NOTE}
 ${STRATEGY_NOTE}
 

package/prompts/goal-loop-forever.md

@@ -26,6 +26,7 @@ Start your reply with exactly one line: `HYPOTHESIS: <what you will change and w
 Then make **ONE** small, concrete change that moves the metric in the right
 direction. Then stop.
 
+${INTERVENTION_NOTE}
 ${REGRESSION_NOTE}
 ${STRATEGY_NOTE}