pi-goal-list-loop-audit 0.38.52 → 0.38.54

package/CHANGELOG.md

@@ -1,5 +1,64 @@
 # Changelog
 
+## 0.38.54 — Opt-in context-checkpoint projection (2026-09-14)
+
+The per-turn `context`-hook projection rewrote history on every turn, busting
+the provider prefix-cache (upstream issue #53). Projection is now opt-in:
+the hook leaves the transcript append-only by default so the cache holds
+across turns, while the fresh continuation prompt still carries live durable
+state every turn.
+
+### Added
+
+- **`contextCheckpointProjection` setting (default off):** explicit opt-in
+  restores the legacy per-turn splice of a bounded continuation checkpoint.
+  Carried in `SETTINGS_KEYS` with junk-normalization to unset, a row in the
+  `/glla` settings Other tab with an on/off editor, and a `docs/SETTINGS.md`
+  entry (release-gate docs coverage holds).
+
+### Fixed
+
+- **Prompt-cache continuity:** with projection off (the default) the hook
+  returns no message rewrite and records no projection event, preserving
+  cache-prefix reuse turn over turn.
+
+### Tests
+
+- Both hook paths pinned (default-off passthrough + opt-in splice), junk
+  normalization, menu row off/default, editor round-trip, and docs coverage.
+  Full suite 2163 pass / 2 skip / 0 fail; `tsc` clean; `git diff --check`
+  clean.
+
+## 0.38.53 — Consent-safe GLLA delegation skill and list-draft staging (2026-09-13)
+
+Added the packaged `glla-delegate` skill for normal-chat goal/list delegation.
+It documents the consent ladder, main-session ownership, auto-activation warning,
+and tool-first usage without adding new runtime powers. Its quoted frontmatter
+is validated through Pi's public loader and the packed-file release gate.
+
+### Added
+
+- **Consent-safe delegation guidance:** explicit queue requests may use
+  `list_add`; discovered follow-ups are offered first; durable goals use
+  `propose_goal_draft`; speculative queueing, unowned activation, and agent
+  `/loop` control remain prohibited.
+- **Pasted-list policy:** supplied multi-line, bullet, numbered, and checklist
+  structure is preserved without an exact-versus-refined meta-question. Only a
+  genuinely ambiguous individual item remains eligible for clarification, with
+  one-record seeds retaining the normal draft path.
+- **Release/package coverage:** `skills/glla-delegate/SKILL.md` is allowlisted,
+  declared in `pi.skills`, required by the packed-artifact smoke, and loaded
+  with zero diagnostics in the release contract.
+
+### Fixed
+
+- **Draft staging:** interview and stale-entry gates remain ahead of Confirm;
+  confirmation remains ahead of conflict handling and enqueue.
+- **Paused list carryover:** a confirmed multi-item draft now routes its first
+  promotion through the carryover-aware activation choke point, archiving the
+  paused predecessor before starting the list head instead of leaving the batch
+  stranded behind it.
+
 ## 0.38.52 — Second Gemini-gap: gate-inventory table + per-finding Test Results (2026-09-12)
 
 Surveyed five more Antigravity report screenshots

package/INSTALL.md

@@ -31,11 +31,11 @@ GLLA loads into new pi sessions. If pi is already open, reload that session:
 
 ## Updating
 
-The status line always shows the running version (`glla: … · v0.38.48`).
+The status line always shows the running version (`glla: … · vX.Y.Z`).
 When the npm registry is ahead, it also nudges:
 
 ```text
-glla: … · v0.38.47 · update v0.38.48 available
+glla: … · vX.Y.Z · update vA.B.C available
 ```
 
 The nudge comes from a daily sidecar check (`.pi-glla/update-check.json`),
@@ -117,10 +117,16 @@ waiting for a decision.
 ```text
 /list "refactor the cache. Done when: tests pass"
 /list plan.md
-/list
+/list                                     # interview + Confirm for a context draft
+/list show                                # show active and waiting items
+/list add <text...>                        # queue one item directly (no interview)
+/list import <file>                        # import a file: one Confirm for the whole batch
 /list start
 /list next
 /list resume
+/list remove <n>
+/list clear
+/list cancel
 
 /loop
 /loop start                                  # one clear recent target, metricless

package/README.md

@@ -157,7 +157,8 @@ quietly inventing an unbounded backlog.
 ```text
 /list "fix the cache. Done when: tests pass"
 /list plan.md                              # import a checklist or plan file
-/list                                     # show active and waiting items
+/list                                     # interview + Confirm for a context draft
+/list show                                # show active and waiting items
 /list start                                # activate the queued head, or draft one clear recent request
 /list next                                 # explicitly skip/activate the next item
 /list next <n>                             # explicitly choose a specific item
@@ -165,11 +166,22 @@ quietly inventing an unbounded backlog.
 /list remove <n>
 /list clear
 /list cancel                               # stop the active item and drop waiting items
+/list add <text...>                        # queue one item directly (no interview)
+/list import <file>                        # import a file: one Confirm for the whole batch
 ```
 
+A pasted multi-line, bulleted, numbered, or checklist-style list keeps its
+item wording and boundaries; GLLA does not ask for an “exact or refined” choice.
+Only a genuinely ambiguous individual item needs clarification. The direct
+`/list add` path skips the interview but not consent: pasted text and files
+still get one Confirm for the whole batch before anything is queued. The packaged
+`skills/glla-delegate/SKILL.md` records the safe normal-chat delegation path:
+explicit queue requests may use `list_add`, while discovered follow-ups are
+offered first and durable goals remain Confirm-gated.
+
 Order is the default, not the law. Automatic advance normally uses the head of
 the queue, while `/list next <n>` or the agent's `list_activate` tool can choose
-another item. Numbering always matches `/list` output. After a list item is
+another item. Numbering always matches `/list show` output. After a list item is
 approved and archived, the next queued item starts automatically; no manual
 `/list next` is needed between items.
 
@@ -305,9 +317,9 @@ GLLA is the supervisor. These companions add capabilities around it:
   count + `/glla agents`. If you see the same run stacked 3× or panels
   swapping order, set pi-subagents `inlineToolDisplay: "summary"` (one
   stable row per run) and pin `fleetViewPlacement`; GLLA's own richness is
-  the `subagentDisplayRichness` setting (`/glla` → Subagents): `rich`
-  (default: worker rows + task linkage), `compact` (count line), `quiet`
-  (hung/aborting workers only). Upstream triple-render report:
+  the `subagentDisplayRichness` setting (`/glla` → Subagents): `quiet`
+  (default: troubled workers + the count line; HUNG is never silent),
+  `compact` (count line), `rich` (all worker rows). Upstream triple-render report:
   nicobailon/pi-subagents#1931.
 
 Install (or keep pinned):

package/docs/INDEX.md

@@ -16,7 +16,7 @@ Policy contracts and recent changes live in the `audit/` directory of the
   failback; v0.35.9 hardened cross-version npm tarball checks; v0.35.10
   handles multi-entry npm dry-run reports; v0.35.11 accepts both npm report
   shapes; v0.35.12 supports npm 12's keyed pack reports; v0.35.13 fixes stale-API recovery loops.
-  v0.35.14–v0.38.52 continue through the supervisor freeze (`/glla pause`),
+  v0.35.14–v0.38.54 continue through the supervisor freeze (`/glla pause`),
   load hold, auditor picker parity, Windows launch fix, zombie-watchdog
   subagent carve-out, due-wait backstop, the `/glla agents` visibility panel,
   durable state-root selection, blank-until-resume auditor context, frozen
@@ -25,18 +25,20 @@ Policy contracts and recent changes live in the `audit/` directory of the
   extensions, bounded zero-stream retry containment, crash-safe persistence,
   packed-artifact release verification, and the 2026-09-07 display/lifecycle/
   settings audit pass (abort-latch send guards, ownership compare-and-swap,
-  auditor inherit/clear parity) and the v0.38.25 post-objective summary
-  (canonical approval render, persist + replay, audit-goal counts line), the v0.38.27 selective port of PRs #45/#46 (`/loop pause` soft-hold, widget subtask count), the v0.38.28 provenance-row closure fix, and the v0.38.29 compact active-card recovery/judgment projection; see CHANGELOG.md for the full trail.
+  auditor inherit/clear parity), the v0.38.25 post-objective summary
+  (canonical approval render, persist + replay, audit-goal counts line), the v0.38.27 selective port of PRs #45/#46 (`/loop pause` soft-hold, widget subtask count), the v0.38.28 provenance-row closure fix, the v0.38.29 compact active-card recovery/judgment projection, and the v0.38.53 consent-safe `glla-delegate`
+  skill/list-drafting release, and the v0.38.54 opt-in context-checkpoint
+  projection (prompt-cache continuity, issue #53); see CHANGELOG.md for the full trail.
 - `../README.md`: what the plugin is, install, quickstart, and the
   architectural guarantee (drafting + confirm + detached auditor).
-- `../INSTALL.md`: source install / local development setup; the recommended
-  companion plugins and the `auditor reads / writes are path-checked`
-  note.
+- `../INSTALL.md`: source install / local development setup and the
+  recommended companion plugins.
 
 ## Entry points
 - `../README.md`: what the plugin is, install, quickstart
 - `SETTINGS.md`: canonical settings reference (files, precedence, every key)
 - `../INSTALL.md`: source install / local development setup
+- `../skills/glla-delegate/SKILL.md`: normal-chat goal/list delegation and consent ladder
 - `../CHANGELOG.md`: user-facing changelog; the first versioned heading is
   the current released package version (use `/glla version` to compare with
   the registry); post-release work may appear in `Unreleased` above it.

package/docs/SETTINGS.md

@@ -73,6 +73,7 @@ copies are ignored (the recovery runtime reads the global file):
 | `subagentModelStrategy` | `"inherit-parent"` | Default subagent model policy for new sessions. |
 | `subagentModelOverrides` | unset | Per-agent-type model pin; always wins over strategy. |
 | `subagentFallbacks` | unset | Per-role fallback chains (first eligible ref wins). |
+| `subagentDisplayRichness` | `"quiet"` | Ambient worker UI: `"quiet"` (default, troubled workers + count line) / `"compact"` / `"rich"`. |
 | `aggressiveMode` | `true` | Keep-going defaults (`false` = pause-first policy). |
 | `stuckMaxInterventions` | `5` (10 aggressive) | Consecutive stuck interventions before a loop stops. |
 | `subagentHangEscalationMinutes` | `30` | Confirmed no-progress minutes before child-specific abort (`0` = warn only). |
@@ -82,4 +83,5 @@ copies are ignored (the recovery runtime reads the global file):
 | `stallSimilarityThreshold` | `0.6` | Trigram similarity above this (tool-less) is a nudge. |
 | `postaudit` | unset | Post-completion audit config (same shape as legacy `reviewer`). |
 | `toolOverrides` | unset | Per-tool allow/hide/per-tool-config overrides. |
+| `contextCheckpointProjection` | `false` (off) | Per-turn `context`-hook splice of a bounded continuation checkpoint. Off (default) leaves the transcript append-only so the provider prefix-cache holds; the fresh continuation prompt still carries live state. On restores the legacy projection (busts the cache). |
 | `reviewer` | legacy | Deprecated alias for `postaudit`; migrated on load, `postaudit` wins. |

package/extensions/completion-summary.ts

@@ -292,6 +292,10 @@ export interface RichTerminalParts {
   durationLine: string | null;
   findingLines: string[];
   tableLines: string[];
+  /** Audit 2026-09-13: auto-collapsed green verification (chat only) —
+   * one PASS line standing in for the table section; null when the full
+   * table renders or when there is nothing to verify. */
+  verificationLine: string | null;
   nextLines: string[];
 }
 
@@ -383,6 +387,19 @@ export function buildDurationLine(goal: Goal, now = Date.now()): string | null {
   return segs.length > 0 ? `\u2014 ${segs.join(" \u00b7 ")}` : null;
 }
 
+/** Audit 2026-09-13 (terminal findings-first): commit SHAs read as
+ * machine receipts in chat. Hex tokens of 7+ chars carrying at least one
+ * digit are hashes in practice (02871aa6, full SHAs); pure-letter tokens,
+ * versions (v9.9.9 splits to v9/9/9), counts, and file:line evidence never
+ * match. The archive keeps the full text — strip chat-side only. */
+export function stripCommitHashes(value: string): string {
+  return value
+    .replace(/\b[0-9a-fA-F]{7,64}\b/g, (token) => (/[0-9]/.test(token) ? "\u2026" : token))
+    .replace(/[ \t]{2,}/g, " ")
+    .replace(/\s+([,.;:])/g, "$1")
+    .trim();
+}
+
 /** Partition informing details into findings / Tests / next buckets. */
 export function partitionRichDetails(details: string[]): { findings: string[]; tests: string[]; next: string[] } {
   const findings: string[] = [];
@@ -425,9 +442,19 @@ export function buildRichTerminalParts(args: {
   durationLine?: string | null;
   groups?: FindingGroup[];
   gates?: GateRow[];
+  /** Audit 2026-09-13: "auto" collapses the verification table to one
+   * PASS line when every row is green (chat default-off); "full" keeps
+   * the table (archive + mechanical fallback). Default "full" so the
+   * v0.38.52 byte-identical fallback survives untouched. */
+  verification?: "full" | "auto";
+  /** Audit 2026-09-13: strip commit hashes chat-side (archive keeps them). */
+  chatSafe?: boolean;
 }): RichTerminalParts {
   const { findings, tests, next } = partitionRichDetails(args.details);
-  const headline = requestEchoHeadline("Done", args.objective, args.outcome);
+  const chatSafe = args.chatSafe === true;
+  const safe = (text: string): string => (chatSafe ? stripCommitHashes(text) : text);
+  const outcome = safe(args.outcome);
+  const headline = requestEchoHeadline("Done", args.objective, outcome);
   const budgeted = takeBudgetedGroups(args.groups ?? []);
   const useTable = budgeted.length >= RICH_TABLE_GROUP_THRESHOLD;
   const findingLines: string[] = [];
@@ -436,34 +463,37 @@ export function buildRichTerminalParts(args: {
     for (const group of budgeted) {
       group.findings.forEach((finding, fi) => {
         const { text, evidence } = extractEvidenceTokens(finding);
-        const { lead, body } = leadBody(text);
+        const { lead, body } = leadBody(safe(text));
         // v0.38.52: test proof rides the Evidence cell (tables have no
         // sub-bullets); cells stay pipe-escaped and budgeted.
         const proof = group.tests?.[fi]?.trim();
-        const evidenceCell = [evidence.join(", ") || "\u2014", ...(proof ? [`Tests: ${proof}`] : [])].join(" \u00b7 ");
+        const evidenceCell = [evidence.join(", ") || "\u2014", ...(proof ? [`Tests: ${safe(proof)}`] : [])].join(" \u00b7 ");
         findingLines.push(
-          `| ${escapeTableCell(clipSummaryValue(group.title, RICH_OBJECTIVE_ECHO_CHARS))} | ${escapeTableCell(`**${lead}** \u2014 ${clipSummaryValue(body, RICH_VALUE_BUDGET)}`)} | ${escapeTableCell(clipSummaryValue(evidenceCell, RICH_VALUE_BUDGET))} |`,
+          `| ${escapeTableCell(clipSummaryValue(safe(group.title), RICH_OBJECTIVE_ECHO_CHARS))} | ${escapeTableCell(`**${lead}** \u2014 ${clipSummaryValue(body, RICH_VALUE_BUDGET)}`)} | ${escapeTableCell(clipSummaryValue(evidenceCell, RICH_VALUE_BUDGET))} |`,
         );
       });
     }
   } else if (budgeted.length > 0) {
     budgeted.forEach((group, i) => {
-      findingLines.push(`#### ${i + 1}. ${clipSummaryValue(group.title, RICH_OBJECTIVE_ECHO_CHARS)}`);
+      findingLines.push(`#### ${i + 1}. ${clipSummaryValue(safe(group.title), RICH_OBJECTIVE_ECHO_CHARS)}`);
       group.findings.forEach((finding, fi) => {
-        const { lead, body } = leadBody(finding);
+        const { lead, body } = leadBody(safe(finding));
         findingLines.push(`- **${lead}** \u2014 ${clipSummaryValue(body, RICH_VALUE_BUDGET)}`);
         // v0.38.52: per-finding test proof (shot C) — absent stays absent.
         const proof = group.tests?.[fi]?.trim();
-        if (proof) findingLines.push(`  - Test Results: ${clipSummaryValue(proof, RICH_VALUE_BUDGET)}`);
+        if (proof) findingLines.push(`  - Test Results: ${clipSummaryValue(safe(proof), RICH_VALUE_BUDGET)}`);
       });
     });
   } else {
     findings.slice(0, RICH_FINDINGS_CAP).forEach((detail, i) => {
-      const { lead, body } = leadBody(detail);
+      const { lead, body } = leadBody(safe(detail));
       findingLines.push(`${i + 1}. **${lead}** \u2014 ${clipSummaryValue(body, RICH_VALUE_BUDGET)}`);
     });
   }
   const tableRows: string[] = [];
+  // Audit 2026-09-13: parallel check/status facts drive the auto collapse
+  // (row strings alone cannot carry the verdict once escaped/clipped).
+  const rowFacts: Array<{ check: string; status: string }> = [];
   const gates = (args.gates ?? []).slice(0, 10);
   if (gates.length > 0) {
     // v0.38.52 (shots B/D): the agent inventory supersedes the mechanical
@@ -472,28 +502,42 @@ export function buildRichTerminalParts(args: {
     // zero failures ("Clean exit 0"-style notes honestly stay REPORTED).
     for (const row of gates) {
       const derived = testsRowStatus(row.notes ?? "");
-      tableRows.push(`| ${escapeTableCell(clipSummaryValue(row.gate, RICH_OBJECTIVE_ECHO_CHARS))} | ${escapeTableCell(clipSummaryValue(row.scope?.trim() || "\u2014", RICH_VALUE_BUDGET))} | ${derived} | ${escapeTableCell(clipSummaryValue(row.notes?.trim() || "\u2014", RICH_VALUE_BUDGET))} |`);
+      rowFacts.push({ check: row.gate, status: derived });
+      tableRows.push(`| ${escapeTableCell(clipSummaryValue(safe(row.gate), RICH_OBJECTIVE_ECHO_CHARS))} | ${escapeTableCell(clipSummaryValue(safe(row.scope?.trim() || "\u2014"), RICH_VALUE_BUDGET))} | ${derived} | ${escapeTableCell(clipSummaryValue(safe(row.notes?.trim() || "\u2014"), RICH_VALUE_BUDGET))} |`);
     }
   } else {
     for (const detail of tests.slice(0, 2)) {
       const { body } = leadBody(detail);
-      tableRows.push(`| Tests | ${testsRowStatus(body)} | ${escapeTableCell(clipSummaryValue(body, RICH_VALUE_BUDGET))} |`);
+      const status = testsRowStatus(body);
+      rowFacts.push({ check: "Tests", status });
+      tableRows.push(`| Tests | ${status} | ${escapeTableCell(clipSummaryValue(safe(body), RICH_VALUE_BUDGET))} |`);
     }
   }
   const auditStatus = auditRowStatus(args.auditHistory);
   if (auditStatus !== "NO VERDICT") {
-    const auditBody = args.countsLine.replace(/^\u2014\s*/, "").replace(/\.\s*$/, "");
+    rowFacts.push({ check: "Audit", status: auditStatus });
+    const auditBody = safe(args.countsLine.replace(/^\u2014\s*/, "").replace(/\.\s*$/, ""));
     if (gates.length > 0) {
       tableRows.push(`| Audit | ${escapeTableCell(clipSummaryValue(auditBody, RICH_VALUE_BUDGET))} | ${auditStatus} | ${escapeTableCell(clipSummaryValue(auditBody, RICH_VALUE_BUDGET))} |`);
     } else {
       tableRows.push(`| Audit | ${auditStatus} | ${escapeTableCell(clipSummaryValue(auditBody, RICH_VALUE_BUDGET))} |`);
     }
   }
-  const tableLines = tableRows.length > 0
+  // Audit 2026-09-13: auto-off — every row green collapses the table to
+  // one PASS line (findings keep the space); anything else renders full.
+  // REPORTED is not green: an unclaimed status stays visible, never hidden.
+  let tableLines = tableRows.length > 0
     ? [(gates.length > 0 ? "| Quality Gate | Scope | Status | Notes |" : "| Check | Status | Details |"), (gates.length > 0 ? "| --- | --- | --- | --- |" : "| --- | --- | --- |"), ...tableRows]
     : [];
+  let verificationLine: string | null = null;
+  if (args.verification === "auto" && tableRows.length > 0
+    && rowFacts.every((fact) => /^(PASS|APPROVED)/.test(fact.status))) {
+    const middle = clipSummaryValue(rowFacts.map((fact) => `${clipSummaryValue(safe(fact.check), RICH_OBJECTIVE_ECHO_CHARS)} ${fact.status}`).join(" \u00b7 "), 300);
+    verificationLine = `\u2014 Verification passed (${middle}); details in the archive record.`;
+    tableLines = [];
+  }
   const nextLines = next.slice(0, RICH_NEXT_CAP).map((detail) => {
-    const { lead, body } = leadBody(detail);
+    const { lead, body } = leadBody(safe(detail));
     return `- **${lead}** \u2014 ${clipSummaryValue(body, RICH_VALUE_BUDGET)}`;
   });
   return {
@@ -501,12 +545,15 @@ export function buildRichTerminalParts(args: {
     durationLine: args.durationLine ?? null,
     findingLines,
     tableLines,
+    verificationLine,
     nextLines,
   };
 }
 
 /** Compose parts + headline + section headers into markdown lines.
- * v0.38.50: the duration line rides directly under the headline. */
+ * v0.38.50: the duration line rides directly under the headline.
+ * Audit 2026-09-13: findings-first order is pinned — findings, then the
+ * verification table (or its auto-collapsed PASS line), then Next. */
 export function composeRichTerminalLines(parts: RichTerminalParts, opts?: { headline?: string }): string[] {
   const lines = [opts?.headline ?? parts.headline, ""];
   if (parts.durationLine) lines.push(parts.durationLine, "");
@@ -515,6 +562,8 @@ export function composeRichTerminalLines(parts: RichTerminalParts, opts?: { head
   }
   if (parts.tableLines.length > 0) {
     lines.push("### Verification Summary", ...parts.tableLines, "");
+  } else if (parts.verificationLine) {
+    lines.push(parts.verificationLine, "");
   }
   if (parts.nextLines.length > 0) {
     lines.push("### Next", ...parts.nextLines, "");
@@ -546,6 +595,9 @@ export function buildRichArchiveSection(goal: Goal, status: Status, archivePath:
     durationLine: buildDurationLine(goal),
     groups: findingGroups,
     gates: gateRows,
+    // Audit 2026-09-13: the archive is the full-detail surface — the
+    // verification table never collapses here and hashes are preserved.
+    verification: "full",
   });
   return [
     ...composeRichTerminalLines(parts, {
@@ -718,8 +770,9 @@ export function buildTerminalApprovalRender(input: TerminalApprovalRenderInput):
   const recordBullet = trailerBullet(input.record);
   // Rich voice: headline + Key Findings + Verification table + Next,
   // closed by the pinned trailer (approval/counts/record, record last).
-  // The transcript mirrors chat without the record pointer and extras —
-  // the record lives in chat and the archive, matching the old contract.
+  // Audit 2026-09-13: chat is findings-first — verification auto-collapses
+  // to one PASS line when green, hashes stay archive-only. The transcript
+  // mirrors chat; the archive keeps the full table and full text.
   const richParts = buildRichTerminalParts({
     outcome: richBrief.outcome,
     details: withoutStaleNext(richDetails),
@@ -729,6 +782,8 @@ export function buildTerminalApprovalRender(input: TerminalApprovalRenderInput):
     durationLine: buildDurationLine(input.goal),
     groups: input.findingGroups,
     gates: input.gateRows,
+    verification: "auto",
+    chatSafe: true,
   });
   const chatBody = composeRichTerminalLines(richParts);
   const transcriptBody = composeRichTerminalLines(richParts);

package/extensions/goal-settings.ts

@@ -270,6 +270,13 @@ export interface Settings {
     /** Per-tool configuration knobs (extensible). */
     perToolConfig?: Record<string, Record<string, unknown>>;
   };
+  /** v0.38.54: on → the per-turn `context` hook replaces stale GLLA
+   * continuation payloads with a bounded checkpoint (legacy behaviour).
+   * Default off (unset): the hook leaves the transcript alone so the
+   * provider prefix-cache stays valid across turns; the fresh
+   * continuation prompt still carries live durable state every turn.
+   * Explicit opt-in restores the per-turn splice. */
+  contextCheckpointProjection?: boolean;
 }
 
 /** These settings describe global provider-recovery policy, not a project
@@ -532,6 +539,7 @@ export function normalizeLoadedSettings(settings: Settings): Settings {
   if (typeof settings.aggressiveMode !== "boolean") delete settings.aggressiveMode;
   if (typeof settings.autoResume !== "boolean") delete settings.autoResume;
   if (typeof settings.autoAcceptDrafts !== "boolean") delete settings.autoAcceptDrafts;
+  if (typeof settings.contextCheckpointProjection !== "boolean") delete settings.contextCheckpointProjection;
   if (typeof settings.notifyCmd !== "string" || settings.notifyCmd.trim().length === 0) {
     delete settings.notifyCmd;
   }
@@ -643,6 +651,7 @@ export const SETTINGS_KEYS: Array<keyof Settings> = [
   "subagentModelStrategy",
   "subagentModelOverrides",
   "subagentFallbacks",
+  "subagentDisplayRichness",
   "aggressiveMode",
   "stuckMaxInterventions",
   "subagentHangEscalationMinutes",
@@ -652,6 +661,7 @@ export const SETTINGS_KEYS: Array<keyof Settings> = [
   "stallSimilarityThreshold",
   "postaudit",
   "toolOverrides",
+  "contextCheckpointProjection",
   "reviewer", // v0.33.1: legacy alias — menu saves can still write it (when postaudit is unset) and load-migration consolidates it into postaudit on the next read; provenance must know it exists or reviewer-sourced values report "unknown"
 ];
 

package/extensions/loops/goal-activation.ts

@@ -2846,8 +2846,12 @@ export function registerGoalRuntime(pi: ExtensionAPI): void {
     // may coexist with an active loop. Project whenever either surface is
     // active, while passing both states so a paused goal is not mistaken for
     // the loop's current objective.
+    // v0.38.54: projection is opt-in (default off). Rewriting history
+    // busts the provider prefix-cache on every turn, while the fresh
+    // continuation prompt already carries live durable state. Only splice
+    // the bounded checkpoint when explicitly enabled.
     const activeLoop = state.loop?.active === true ? state.loop : null;
-    const checkpointProjection = state.goal || activeLoop
+    const checkpointProjection = (state.goal || activeLoop) && loadSettings(ctx.cwd).contextCheckpointProjection === true
       ? projectBoundedGllaContext(
         hygiene.messages,
         buildAuthoritativeContextCheckpoint({

package/extensions/loops/goal-list-queue.ts

@@ -860,7 +860,7 @@ async function startDrafting(ctx: ExtensionContext, target: "goal" | "list" | "l
   // concatenation produced "…regular draft.Goal drafting — deep planning: …".
   const seededHint = (planNote ? `${planNote} ` : "") + (
     target === "list"
-      ? `${label}: free-text is valid without a "Done when:" clause — the agent will turn it into short list items and grill for concrete per-item contracts (nothing activates until you confirm). To skip drafting, include a per-item "Done when:" clause.`
+      ? `${label}: free-text is valid without a "Done when:" clause — the agent will turn it into short list items and grill for concrete per-item contracts (nothing activates until you confirm). If the seed is already a pasted multi-line, bulleted, numbered, or checklist-style list, use its wording and structure as supplied; do not ask whether it should be exact or refined. To skip drafting, include a per-item "Done when:" clause.`
       : target === "loop"
         ? `${label}: a loop target needs a metric and a direction — the agent will help you design them first (nothing activates until you confirm). Skip the interview entirely: /loop start "<target>" (bare = infinite metricless) or /loop start "<target>" measure="<cmd>" direction=min|max [window=5] [max=50] [time=h] [tokens=n] [branch=1].`
         : `${label}: the objective has no "Done when:" clause — the agent will grill you about it first (nothing activates until you confirm). Skip the interview entirely: /goal start <objective>.`);
@@ -877,7 +877,10 @@ async function startDrafting(ctx: ExtensionContext, target: "goal" | "list" | "l
           "for the big version. When the user has many items to enqueue at once ('queue these 50 audits'), propose them ALL AT " +
           "ONCE with the items[] parameter — one Confirm for the whole batch, never 50 separate proposals. Each items[] entry " +
           "is still a SHORT task — never an aggregate wrapper ('land all N findings' with a '≥N commits' contract is the " +
-          "canonical anti-pattern: the auto-committer squashes, the count fails, the auditor disapproves finished work).]",
+          "canonical anti-pattern: the auto-committer squashes, the count fails, the auditor disapproves finished work). " +
+          "For a pasted multi-line, bulleted, numbered, or checklist-style seed, preserve the supplied wording and structure, " +
+          "strip only import syntax and empty headings/lines, and propose items[] directly — do not ask whether it should be exact " +
+          "or refined; clarify only a genuinely ambiguous individual item.]",
       );
   }
   // v0.14.0: the LLM grills (its strength — v0.13.0's canned questionnaire
@@ -1027,6 +1030,9 @@ function currentToolContext(execCtx: unknown): ExtensionContext | null {
 defineGoalRuntimeGlobal("listQueue", { get: () => listQueue });
 defineGoalRuntimeGlobal("groupOpenChildren", { get: () => groupOpenChildren });
 defineGoalRuntimeGlobal("activateNextListItem", { get: () => activateNextListItem });
+// Audit 2026-09-13: list_activate must screen content before the conflict
+// can archive, so the repair helper joins the runtime-global bridge.
+defineGoalRuntimeGlobal("queueRepairAheadOfListItem", { get: () => queueRepairAheadOfListItem });
 defineGoalRuntimeGlobal("startDrafting", { get: () => startDrafting });
 defineGoalRuntimeGlobal("restoreDrafterModel", { get: () => restoreDrafterModel });
 defineGoalRuntimeGlobal("handleDrafterModelFailure", { get: () => handleDrafterModelFailure });

package/extensions/loops/goal-runtime-globals.ts

@@ -219,6 +219,7 @@ export const GOAL_RUNTIME_GLOBAL_NAMES = [
   "listQueue",
   "groupOpenChildren",
   "activateNextListItem",
+  "queueRepairAheadOfListItem",
   "startDrafting",
   "healGoalPolicy",
   "notifyExternal",
@@ -590,6 +591,7 @@ declare global {
   var listQueue: GoalRuntimeGlobals["listQueue"];
   var groupOpenChildren: GoalRuntimeGlobals["groupOpenChildren"];
   var activateNextListItem: GoalRuntimeGlobals["activateNextListItem"];
+  var queueRepairAheadOfListItem: GoalRuntimeGlobals["queueRepairAheadOfListItem"];
   var startDrafting: GoalRuntimeGlobals["startDrafting"];
   var healGoalPolicy: GoalRuntimeGlobals["healGoalPolicy"];
   var notifyExternal: GoalRuntimeGlobals["notifyExternal"];

package/extensions/loops/goal-settings-ui.ts

@@ -1036,6 +1036,17 @@ export async function handleSettingChoice(id: string, ctx: ExtensionContext): Pr
       }
       return;
     }
+    case "contextCheckpointProjection": {
+      const v = await ctx.ui.select("Context checkpoint projection — off keeps the transcript append-only so the provider prefix-cache holds across turns; on restores the legacy per-turn splice of a bounded continuation checkpoint", [
+        "off — leave the transcript alone; the continuation prompt carries live state (default)",
+        "on — splice a bounded checkpoint every turn (legacy; busts the prompt cache)",
+      ]);
+      if (v) {
+        saveSettings("global", ctx.cwd, { contextCheckpointProjection: v.startsWith("on") ? true : undefined });
+        ctx.ui.notify(v.startsWith("on") ? "Context checkpoint projection ON — legacy per-turn splice; expect higher prompt-cache miss rates." : "Context checkpoint projection OFF — transcript stays append-only; the continuation prompt carries live state.", "info");
+      }
+      return;
+    }
     case "mainAgent": {
       ctx.ui.notify("The current main agent and thinking level are controlled by pi's regular model/thinking selectors. The fallback chain is configured in this tab.", "info");
       return;

package/extensions/loops/goal-tools.ts

@@ -2440,17 +2440,26 @@ function registerAgentTools(pi: any): void {
         // 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";
+        const startsFromEmpty = !state.goal || state.goal.status === "complete" || state.goal.status === "aborted";
+        const replacesPaused = state.goal?.status === "paused";
+        const batchActivates = startsFromEmpty || replacesPaused;
+        const activationNote = startsFromEmpty
+          ? listQueue().length > 0
+            ? "\n\n(Confirming starts the current list head immediately.)"
+            : "\n\n(List is empty — confirming ACTIVATES the first proposed item immediately as the active goal.)"
+          : replacesPaused
+            ? "\n\n(A paused objective is held — confirming resolves that carryover and ACTIVATES the current list head. Reject if you only wanted to queue these items.)"
+            : "";
         let batchConfirmed = false;
         if (autoAccept) {
           batchConfirmed = true;
-          liveCtx.ui.notify(`List batch auto-accepted (Auto-accept drafts = on in /glla settings): ${p.items.length} items${batchActivates ? " — item 1 ACTIVATES now" : ""}.`, "info");
+          liveCtx.ui.notify(`List batch auto-accepted (Auto-accept drafts = on in /glla settings): ${p.items.length} items${batchActivates ? " — the list head ACTIVATES now" : ""}.`, "info");
           appendLedger(liveCtx.cwd, "draft_autoaccepted", { kind: "batch", count: p.items.length });
         } else {
           const c = await confirmDraft(
             liveCtx,
             "Confirm list batch",
-            `${p.items.length} items:\n${preview}${batchActivates ? "\n\n(List is empty — confirming ACTIVATES item 1 immediately as the active goal.)" : ""}`,
+            `${p.items.length} items:\n${preview}${activationNote}`,
           );
           const afterConfirm = freshCtxForGeneration(draftGeneration);
           if (!afterConfirm) {
@@ -2487,12 +2496,42 @@ function registerAgentTools(pi: any): void {
             };
           }
         }
+        // Audit 2026-09-13: zero-yield pre-scan BEFORE the conflict can
+        // archive — the batch conflict sits ahead of enqueueItems' own
+        // duplicate filter, so a replace-then-zero-yield run would archive
+        // the paused record and gain nothing. Pinned order is preserved:
+        // this is a read-only scan, not an enqueue mutation.
+        const completedBeforeConflict = recentlyCompletedObjectives(liveCtx.cwd);
+        const freshCount = p.items.filter((t) => {
+          const text = parseListItemDeclaration(t).objective.trim();
+          return text.length > 0 && !completedBeforeConflict.has(normalizeObjective(text));
+        }).length;
+        if (freshCount === 0) {
+          draftingTarget = null;
+          await ((globalThis as any).restoreDrafterModel?.() ?? Promise.resolve());
+          return { content: [{ type: "text", text: "No new list items were queued — every item duplicates work COMPLETED in the last 24h. No conflict was started and the current objective is unchanged." }], details: {} };
+        }
         draftingTarget = null;
         await ((globalThis as any).restoreDrafterModel?.() ?? Promise.resolve());
-        const wasIdle = !state.goal || state.goal.status === "complete" || state.goal.status === "aborted";
+        // enqueueItems owns the empty/terminal-slot auto-start. A paused
+        // objective is different: preserve the one-confirm batch, then route
+        // promotion through the same carryover-aware choke point so the
+        // paused record is archived before the new list head starts.
+        const slotWasEmpty = !state.goal || state.goal.status === "complete" || state.goal.status === "aborted";
+        const pausedBeforeEnqueue = state.goal?.status === "paused";
         const n = enqueueItems(liveCtx, p.items, "drafted batch");
-        if (wasIdle) {
-          return { content: [{ type: "text", text: `${n} items confirmed; first activated (list was empty). Begin work now.` }], details: {} };
+        if (n === 0) {
+          return { content: [{ type: "text", text: "No new list items were queued — the proposed batch was empty after duplicate/persistence checks." }], details: {} };
+        }
+        if (pausedBeforeEnqueue && state.goal?.status === "paused") {
+          const activated = activateNextListItem(liveCtx);
+          if (activated) {
+            return { content: [{ type: "text", text: `${n} items confirmed; the list head activated after paused carryover resolution. Begin work now.` }], details: {} };
+          }
+          return { content: [{ type: "text", text: `${n} items confirmed and queued (${listQueue().length} waiting), but activation was held. The paused objective remains recoverable; retry list activation after fixing the reported issue.` }], details: {} };
+        }
+        if (slotWasEmpty && state.goal?.status === "active" && state.goal.policy === "list") {
+          return { content: [{ type: "text", text: `${n} items confirmed; the first list item activated. Begin work now.` }], details: {} };
         }
         return { content: [{ type: "text", text: `${n} items confirmed and added to the list (${listQueue().length} waiting).` }], details: {} };
       }
@@ -2509,7 +2548,9 @@ function registerAgentTools(pi: any): void {
       const activationNote = isListDraft
         ? willActivate
           ? "\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.)"
+          : state.goal?.status === "paused"
+            ? "\n\n(A paused objective is held — confirming queues this item, archives that paused carryover, and ACTIVATES the current list head. Reject if you only wanted to queue this item.)"
+            : "\n\n(Goes into the list, waiting behind the active goal.)"
         : "";
       let confirmed = false;
       if (autoAccept) {
@@ -2582,9 +2623,25 @@ function registerAgentTools(pi: any): void {
         }
         hydrateListQueueFromDisk(liveCtx);
         const extracted = parseListItemDeclaration(full);
+        // Audit 2026-09-13: resolve Subtask-of parent bindings like
+        // enqueueItems — the inline path used to insert children flat.
+        let singleParentId: string | undefined;
+        if (extracted.parentObjective) {
+          if (!extracted.objective) {
+            appendLedger(liveCtx.cwd, "list_subtask_refused", { source: "drafted single", reason: "empty-child" });
+            return { content: [{ type: "text", text: "The draft is a Subtask-of marker with no child text — nothing was queued. Restate the subtask, then propose again." }], details: {} };
+          }
+          const singleParent = listQueue().find((c: ListItem) => !c.parentId && normalizeObjective(c.objective) === normalizeObjective(extracted.parentObjective!));
+          if (!singleParent) {
+            appendLedger(liveCtx.cwd, "list_subtask_refused", { source: "drafted single", declaration: extracted.parentObjective.slice(0, 200) });
+            return { content: [{ type: "text", text: `The Subtask-of declaration did not match any top-level queue item ("${extracted.parentObjective}") — the draft was NOT queued. Fix the parent wording so it names the queued item exactly, then propose again.` }], details: {} };
+          }
+          singleParentId = singleParent.id;
+        }
         const item = assignQueueOrder([{
           id: newGoalId(),
           objective: extracted.objective,
+          ...(singleParentId ? { parentId: singleParentId } : {}),
           ...(extracted.agentRole ? { agentRole: extracted.agentRole } : {}),
           verificationContract: extracted.verificationContract || undefined,
           ...(extracted.parallelSafe === undefined ? {} : { parallelSafe: extracted.parallelSafe }),
@@ -2601,6 +2658,11 @@ function registerAgentTools(pi: any): void {
         replaceState({ ...state, list: [...listQueue(), item] });
         persistState(liveCtx);
         appendLedger(liveCtx.cwd, "list_added", { id: item.id, objective: item.objective, drafted: true });
+        // Audit 2026-09-13: port the v0.38.53 batch fix — a paused holder
+        // never resolves, so queueing behind it strands the item under a
+        // false "activates on completion" promise. Route through the same
+        // carryover-aware choke point instead.
+        const pausedBeforeEnqueue = state.goal?.status === "paused";
         if (!state.goal || state.goal.status === "complete" || state.goal.status === "aborted") {
           // v0.29.4: an auto-accepted draft STARTS — autoAcceptDrafts is the
           // pre-consent (the user asked for the draft in-session). The
@@ -2610,6 +2672,10 @@ function registerAgentTools(pi: any): void {
           activateNextListItem(liveCtx);
           return { content: [{ type: "text", text: "Confirmed and activated (list was empty). Begin work now." }], details: {} };
         }
+        if (pausedBeforeEnqueue && state.goal?.status === "paused") {
+          const activated = activateNextListItem(liveCtx);
+          return { content: [{ type: "text", text: activated ? `Confirmed and activated after paused carryover resolution (${listQueue().length} still waiting). Begin work now.` : `Confirmed and queued (${listQueue().length} waiting), but activation was held. The paused objective remains recoverable; retry list activation after fixing the reported issue.` }], details: {} };
+        }
         return { content: [{ type: "text", text: `Confirmed and added to the list (${listQueue().length} waiting). It activates when the current goal completes.` }], details: {} };
       }
       const goalConflict = await resolveDraftActivationConflict(liveCtx, "goal", p.objective.trim());
@@ -2902,12 +2968,29 @@ function registerAgentTools(pi: any): void {
       const clean = p.items.map((t) => t.trim()).filter((t) => t.length > 0);
       const wasIdle = !state.goal || state.goal.status === "complete" || state.goal.status === "aborted";
       const n = enqueueItems(liveCtx, clean, "agent list_add");
+      // Audit 2026-09-13: report post-enqueue truth, not the stale
+      // pre-enqueue snapshot — n===0 (duplicates/persist-fail) and held
+      // auto-activation both used to render as a false "now active".
+      if (n === 0) {
+        return { content: [{ type: "text", text: "No new list items were queued — the batch was empty after duplicate/persistence checks. Nothing was activated." }], details: {} };
+      }
+      if (wasIdle) {
+        const active = state.goal?.status === "active" && state.goal.policy === "list";
+        return {
+          content: [{
+            type: "text",
+            text: active
+              ? `${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) added but activation was held. The list holds ${listQueue().length} waiting item(s); run /list next when ready.`,
+          }],
+          details: {},
+        };
+      }
+      const holder = state.goal?.status === "paused" ? "paused objective" : "active goal";
       return {
         content: [{
           type: "text",
-          text: wasIdle
-            ? `${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).`,
+          text: `${n} item(s) queued (${listQueue().length} waiting behind the ${holder}).`,
         }],
         details: {},
       };
@@ -2917,7 +3000,7 @@ function registerAgentTools(pi: any): void {
   pi.registerTool(defineTool({
     name: "list_activate",
     label: "Activate list item",
-    description: "Activate a specific item from the /list queue by position (1-based). Order is the default, not the law: use this when a different item should be worked next (e.g. you want to research item 5 while item 1 waits). Aborts the currently active goal if one is running.",
+    description: "Activate a specific item from the /list queue by position (1-based). Order is the default, not the law: use this when a different item should be worked next (e.g. you want to research item 5 while item 1 waits). If a live objective is running you choose update / replace / cancel first (replace archives it); a paused objective is handled as carryover, not a live conflict.",
     parameters: Type.Object({
       n: Type.Number({ description: "1-based position in the queue (1 = head)" }),
     }),
@@ -2937,6 +3020,17 @@ function registerAgentTools(pi: any): void {
       const targetItem = position.item;
       const rawIndex = position.flatIndex + 1;
       if (targetItem) {
+        // Audit 2026-09-13: screen content BEFORE the conflict can archive —
+        // a suspicious pick queues its repair instead, with the current
+        // objective preserved (mirrors the queue's own activation guard).
+        const preAssessment = assessSuspiciousObjective(targetItem.objective, targetItem.verificationContract);
+        if (preAssessment.suspicious) {
+          queueRepairAheadOfListItem(liveCtx, targetItem, preAssessment);
+          return {
+            content: [{ type: "text", text: "The requested item failed the suspicious-content screen, so a safe repair item was queued in its place; the current objective was preserved and no replacement was started." }],
+            details: {},
+          };
+        }
         const incomingWholeList = targetItem.objective + (targetItem.verificationContract ? `\nDone when:\n${targetItem.verificationContract}` : "");
         const conflict = await resolveDraftActivationConflict(liveCtx, "list", incomingWholeList);
         if (conflict !== "proceed") {

package/extensions/loops/goal-ui.ts

@@ -824,7 +824,9 @@ function refreshUI(ctx: ExtensionContext, force = false): void {
           const rows = agents as AgentsPanelRow[];
           // v0.38.23: the head lifesign reads the same rows the worker
           // rows render — one snapshot, two projections, never diverging.
-          const extras = assembleAgentsExtras(rows, settings.subagentDisplayRichness ?? "rich", now, theme);
+          // Audit 2026-09-13: quiet is the canonical default (2026-09-07
+          // exceptions-only decision, menu label, DEFAULT_SETTINGS).
+          const extras = assembleAgentsExtras(rows, settings.subagentDisplayRichness ?? "quiet", now, theme);
           return extras ? { agents: extras, agentRows: rows } : { agentRows: rows };
         } catch { return {}; }
       })(),

package/extensions/settings-menu.ts

@@ -644,6 +644,15 @@ export function buildSettingsRows(
       description:
         "post-completion follow-up enqueuer: mode, triggers, cascade, caps (postaudit / reviewer)",
     },
+    {
+      id: "contextCheckpointProjection",
+      section: "other",
+      label: "Context checkpoint projection",
+      valueText: show("contextCheckpointProjection", "off"),
+      sourceText: src("contextCheckpointProjection"),
+      description:
+        "off: leave the transcript alone so the provider prefix-cache holds (default) · on: legacy per-turn splice of a bounded continuation checkpoint",
+    },
   );
 
   return rows;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.38.52",
+  "version": "0.38.54",
   "description": "Mission control for autonomous pi: interview-drafted goals, an audited task queue, and forever-loops (metric, spec, project-audit) that run for hours. A detached extension-less auditor process re-verifies every completion with raw evidence without holding the main pi turn; confirmed drafts, decision pauses and consent gates keep you in charge.",
   "license": "AGPL-3.0-only",
   "author": "dracon",
@@ -29,6 +29,7 @@
   },
   "files": [
     "extensions",
+    "skills",
     "prompts",
     "schemas",
     "scripts",
@@ -45,6 +46,9 @@
   "pi": {
     "extensions": [
       "extensions/loops/goal.ts"
+    ],
+    "skills": [
+      "skills/glla-delegate"
     ]
   },
   "scripts": {

package/prompts/goal-loop-continuation.md

@@ -1,4 +1,4 @@
-// pi-goal-list-loop-audit — v0.1.0
+// pi-goal-list-loop-audit
 // prompts/goal-loop-continuation.md
 //
 // This file is exported as a raw string. We don't use string-concat in TS for
@@ -55,7 +55,7 @@ When a goal, list item, or pending task explicitly says `Agent: Designer`, `Role
 
 ## Available tools
 
-You have `read`, `write`, `edit`, `bash`, `grep`, `find`, `ls`, the `subagent` tool, and the goal toolkit (`propose_task_list`, `complete_task`, `update_task_status`, `update_task_batch`, `record_goal_judgment`, `pause_goal`, `complete_goal`), plus the list tools (`list_add`, `list_status`, `list_activate`) — when the user asks to queue more work ("add these to my list", "queue these 10 things"), call `list_add` with the items; when unsure what is running or waiting, call `list_status`.
+You have `read`, `write`, `edit`, `bash`, `grep`, `find`, `ls`, the `subagent` tool, and the goal toolkit (`propose_task_list`, `complete_task`, `update_task_status`, `update_task_batch`, `record_goal_judgment`, `pause_goal`, `complete_goal`), plus the list tools (`list_add`, `list_status`, `list_activate`) — when the user asks to queue more work ("add these to my list", "queue these 10 things"), call `list_add` with the items; when unsure what is running or waiting, call `list_status`. A pasted multi-line, bulleted, numbered, or checklist-style list keeps its item wording and boundaries — never ask "exact or refined"; clarify only genuinely ambiguous individual items. Never `list_activate` an item the user has not selected or clearly authorized. Drafts stay Confirm-gated (`propose_goal_draft`); never auto-activate a speculative seed.
 
 If the objective decomposes into milestones and no task list exists yet, call `propose_task_list` early — the user confirms it, then you track progress with `complete_task` / `update_task_status` / `update_task_batch` as you go (not as a post-hoc checklist at the end). For several status changes at once, prefer one `update_task_batch` call: the whole batch validates first, milestones verify, then all statuses persist in one write. Limits: 20 tasks, 5 subtasks per task.
 

package/prompts/goal-loop-draft.md

@@ -68,9 +68,20 @@ While drafting, watch the seed's shape and recommend the right mode:
 
 `[GOAL DRAFTING]`
 
-The user invoked `/goal` with no objective. Your job is to turn their vague
+The user invoked `/goal` (or `/list` for a list draft) with no objective. Your job is to turn their vague
 request into a **confirmed goal contract**. Do NOT start substantive work yet.
 
+## Pasted list seeds
+
+When this prompt is being used for `/list` and the user supplies a multi-line,
+bulleted, numbered, or checklist-style seed, use its structure and wording as
+provided. Strip only import syntax and empty headings/lines, then propose the
+resulting items together through `items[]`. Do not ask whether the user wants
+the list exact or refined: there is no such choice. Clarify only a genuinely
+ambiguous individual item; never turn a complete pasted list into a
+meta-choice. A direct user request to add such a list may use the normal
+bulk-enqueue path instead of drafting.
+
 ## Protocol
 
 1. If the request is vague, ask ONE focused question at a time. Offer a

package/prompts/goal-loop-plan.md

@@ -49,6 +49,16 @@ confirms.
    earn its place — decisions, constraints, and checkable outcomes only.
    Do not pad with boilerplate the user did not ask for.
 
+## Pasted list seeds
+
+When plan mode is used for `/list` and the user supplies a multi-line,
+bulleted, numbered, or checklist-style seed, preserve its item boundaries and
+wording as supplied. Normalize only import syntax and empty headings/lines;
+do not ask whether the list should be exact or refined. Clarify only a
+genuinely ambiguous individual item, never turn a complete pasted list into a
+meta-choice. Research may deepen contracts and verification, but it must not
+rewrite a clear pasted list merely to make it sound more polished.
+
 ## Hard rules (unchanged from regular drafting)
 
 - Do NOT start implementing during planning. Research is read-only.

package/scripts/release-pack-smoke.mjs

@@ -48,7 +48,21 @@ try {
     "extensions/goal-loop-auditor-process.ts",
     "scripts/goal-auditor-launch.mjs",
     "scripts/goal-auditor-worker.mjs",
+    // Audit 2026-09-13: every runtime-loaded file rides the gate, not just
+    // the entry points — a files-narrowing that drops a prompt, the schema,
+    // or a spawned worker must fail here, not at draft time in the field.
+    "scripts/goal-compactor-worker.mjs",
+    "scripts/durable-wait.mjs",
     "scripts/release-pack-smoke.mjs",
+    "prompts/goal-loop-continuation.md",
+    "prompts/goal-loop-draft.md",
+    "prompts/goal-loop-forever-draft.md",
+    "prompts/goal-loop-forever-metricless.md",
+    "prompts/goal-loop-forever.md",
+    "prompts/goal-loop-plan-loop.md",
+    "prompts/goal-loop-plan.md",
+    "schemas/goal.schema.json",
+    "skills/glla-delegate/SKILL.md",
   ];
   const listing = run("tar", ["-tzf", tarball]);
   for (const file of required) {
@@ -94,6 +108,20 @@ try {
   const auditor = await jiti.import(path.join(installedPackage, "extensions/goal-loop-auditor-process.ts"));
   if (typeof auditor.resolveWorkerCommand !== "function") throw new Error("packed auditor process did not expose its worker command resolver");
   if (auditor.resolveWorkerCommand("/usr/bin/node") !== "/usr/bin/node") throw new Error("packed auditor resolver returned an unexpected command");
+  // Audit 2026-09-13: presence is not loadability — run the packed skill
+  // through Pi's own loader against the INSTALLED tree (the source-tree
+  // check in release-contract.test.ts cannot catch tarball-only defects).
+  const piCoding = await jiti.import("@earendil-works/pi-coding-agent");
+  if (typeof piCoding.loadSkills !== "function") throw new Error("packed gate could not resolve Pi loadSkills");
+  const skillProbe = piCoding.loadSkills({
+    cwd: installedPackage,
+    agentDir: installedPackage,
+    skillPaths: ["skills/glla-delegate"],
+    includeDefaults: false,
+  });
+  if (skillProbe.diagnostics.length > 0) throw new Error(`packed skill has loader diagnostics: ${JSON.stringify(skillProbe.diagnostics).slice(0, 300)}`);
+  if (!skillProbe.skills.some((skill) => skill.name === "glla-delegate")) throw new Error("packed skill not discoverable by Pi loadSkills");
+  console.log("OK: packed glla-delegate skill loads with zero diagnostics");
   console.log(`OK: installed and imported ${packageName}@${packageJson.version} from its packed tarball`);
 } finally {
   fs.rmSync(workspace, { recursive: true, force: true });

package/skills/glla-delegate/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: glla-delegate
+description: "Use GLLA's audited goals and list queue from normal chat: queue explicit work, offer follow-ups before adding them, or draft a confirmed goal. Includes safe handling for pasted list-like input."
+---
+
+# GLLA delegation
+
+GLLA is not a scratch task list. A queued item becomes an audited goal, and
+when the queue is idle its first item may activate immediately. Use these
+tools in the main session only:
+
+- `list_status` is read-only and safe for inspection.
+- If the user explicitly asks to queue, add, backlog, or list work, call
+  `list_add` with the requested items. Do not turn a direct queue request
+  into an unnecessary interview.
+- If you discover a useful follow-up while doing other work, finish the
+  current request and offer to queue it first. Queue it without another
+  question only when the user has given standing permission such as
+  “queue follow-ups as you find them.”
+- If one durable, multi-hour objective is warranted, interview only what is
+  genuinely unknown, then call `propose_goal_draft`; the user's Confirm
+  dialog is the activation gate. Never activate a speculative raw seed.
+  (Unless Auto-accept drafts is on in /glla settings, which skips the
+  Confirm — never promise a dialog that setting suppresses.)
+- Never call `list_activate` for an item the user has not selected or clearly
+  authorized. Never control `/loop` bounds, metrics, or stopping on the
+  user's behalf.
+
+## Pasted list-like input
+
+When the user supplies a multi-line, bulleted, numbered, or checklist-style
+list and asks to use or add it, use the structure and wording as supplied.
+Strip only import syntax and empty headings/lines, then pass the resulting
+items in one `list_add` call. Do **not** ask whether the user wants the list
+“exact” or “refined”; there is no such choice. Clarify only a genuinely
+ambiguous individual item, never turn a complete pasted list into a
+meta-choice.
+
+If a `/list` drafting session is already active, do not bypass its Confirm
+gate with `list_add`: pass the complete pasted set once as `items[]` to
+`propose_goal_draft` instead. This keeps one confirmation for the whole
+batch and prevents partial activation.
+
+Use the tools, not slash-command text, when acting. Worker and subagent
+sessions do not own GLLA state; respect a foreign-session refusal instead of
+routing around it.