pi-goal-list-loop-audit 0.38.48 → 0.38.49

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # Changelog
 
+## 0.38.49 — audit-pass drift fixes: prompt gate, summary segmentation, task honesty (2026-09-11)
+
+Full-project audit pass on v0.38.48 (three parallel scout surveys). Six new
+findings, all fixed on main; scout claims that were unproven, stale, or
+by-design are disposed with rationale in the pass note, not as findings.
+
+### Fixed
+
+- **Continuation prompt drift:** the Available-tools list and task workflow
+  now name `update_task_batch` (validate whole, verify milestones, persist
+  once) and the pending-task completion gate (`complete_goal` refused
+  before audit while committed tasks are open; `record_goal_judgment`
+  `choice=deferred` + `taskId` exempts a blocked item). Completion-voice
+guidance matches the rich-section renderer budgets.
+- **README verify path:** the `complete_goal` steps now include the
+  pending-task refusal before audit.
+- **Docs versions/voice:** INSTALL updating examples show the current
+  versions; the supervision design doc distinguishes the verbatim six-label
+  archive record from the rich chat/transcript sections and the compact
+  width-bound projection.
+- **Summary gate segmentation:** `missingCompletionSummaryLabels` segments
+  on the same last-occurrence positions as every projector, so a label
+  named inside an earlier value can no longer pass the gate while rendering
+  shifted (removed the now-dead `labelIndex`).
+- **Task-tool honesty:** completing an already-complete task reports
+  `Task <id> is already complete.` and same-status `update_task_status`
+  moves report `already <status>` instead of the not-found fallthrough or
+a no-op persist.
+- **Sidecar pending boundary:** the approval-render outbox and the
+  update-check refresh defer while sessionDir resolution is pending instead
+  of creating (or latching degraded on) a `<cwd>/.pi-glla` fallback tree.
+
+### Tests
+
+- Re-baselined `tests/context-growth-measurement.test.ts` to 22_570 chars
+  / 22_670 bytes per payload (+769 chars incl. one em dash) with exact
+  multiples preserved across probe sizes. New pins: stolen-label gate
+  agreement, already-complete/no-op task messages, sidecar pending deferral.
+  `tsc` clean.
+
 ## 0.38.48 — atomic task batches + pending-task completion gate (2026-09-11)
 
 ### Added

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.46`).
+The status line always shows the running version (`glla: … · v0.38.48`).
 When the npm registry is ahead, it also nudges:
 
 ```text
-glla: … · v0.38.45 · update v0.38.46 available
+glla: … · v0.38.47 · update v0.38.48 available
 ```
 
 The nudge comes from a daily sidecar check (`.pi-glla/update-check.json`),

package/README.md

@@ -250,12 +250,14 @@ When the agent calls `complete_goal`, GLLA:
 
 1. runs the contract's mechanical checks when a release or command check is
    specified;
-2. writes an identity-bound completion claim;
-3. starts a detached, fresh pi RPC worker for the audit;
-4. asks the worker to inspect the repository and run bounded checks;
-5. requires raw evidence for each verification-contract item through the
+2. refuses the claim before audit when committed tasks are still open
+   (tasks with a recorded deferral are exempt), naming each open task;
+3. writes an identity-bound completion claim;
+4. starts a detached, fresh pi RPC worker for the audit;
+5. asks the worker to inspect the repository and run bounded checks;
+6. requires raw evidence for each verification-contract item through the
    orchestrator-side regression shield;
-6. keeps the goal open on infrastructure failure, missing evidence, or
+7. keeps the goal open on infrastructure failure, missing evidence, or
    disapproval instead of silently archiving it.
 
 The auditor is intentionally isolated from the implementing conversation and

package/docs/DESIGN-long-running-supervision.md

@@ -110,10 +110,15 @@ status/reason, durable telemetry, captured audit verdicts, and known archive
 path. It says `not recorded` when a changed-file manifest or test result is not
 available. It never infers a passing test or invents a commit.
 
-The full recap lives in the archive and status/history surfaces. Every
-terminal goal notification—including version-bearing already-shipped claims,
-explicit goal/list cancellation, and `/glla wipe`—includes a compact
-projection of all six labels; loop notifications do the same. The terminal
+The full six-label recap lives verbatim in the archive (`## Completion summary`)
+and the status/history surfaces. The human layer in chat, transcript, and the
+archive's `## Terminal summary` renders the same facts as rich sections
+(`## Done`, Key Findings, Verification Summary table, Next, capped and clipped
+to fixed budgets). Width-bound and external surfaces (status line, widget card,
+external notifies) use the compact single-line projection of all six labels.
+Every terminal goal notification, including version-bearing already-shipped claims,
+explicit goal/list cancellation, and `/glla wipe`, carries either the rich sections
+or the compact projection; loop notifications do the same. The terminal
 notification may use a compact excerpt. The executor recap and independent
 auditor verdict stay separate: an approval is not manufactured from the
 presence of a summary.

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.48 continue through the supervisor freeze (`/glla pause`),
+  v0.35.14–v0.38.49 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

package/extensions/approval-render-store.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { appendLedger, ensureDirs, nowIso, piGlaDir, runPersistStep } from "./goal-loop-core.js";
+import { stateRootPending } from "./glla-state-root.js";
 
 /** Durable terminal-summary outbox. A toast or a live host is not delivery:
  * only a confirmed visible session message acknowledges a render. */
@@ -67,6 +68,9 @@ function readRenders(cwd: string): PendingApprovalRender[] {
 }
 
 function writeRenders(cwd: string, renders: PendingApprovalRender[]): boolean {
+  // v0.38.49 audit: pending sessionDir resolution defers every write that
+  // would otherwise recreate <cwd>/.pi-glla — the sidecar is no exception.
+  if (stateRootPending()) return false;
   const landed = runPersistStep("persistApprovalRender", () => {
     ensureDirs(cwd);
     const file = approvalRenderStorePath(cwd);

package/extensions/completion-summary.ts

@@ -31,10 +31,6 @@ export interface CompletionSummaryFacts {
   archivePath?: string;
 }
 
-function labelIndex(text: string, label: CompletionSummaryLabel): number {
-  return text.toLowerCase().indexOf(label.toLowerCase());
-}
-
 /**
  * Validation/version annotations are metadata, not recap fields. Keep them
  * out of the parser so a generated NOTE containing examples such as
@@ -45,17 +41,20 @@ function completionSummaryBody(text: string): string {
   return annotation?.index === undefined ? text : text.slice(0, annotation.index);
 }
 
-/** Return labels that are absent or have no value after the label. */
+/** Return labels that are absent or have no value after the label. Segments on
+ * the same last-occurrence positions as every projector (compact, multi-line,
+ * rich): a label named inside an earlier value must not shift the gate away
+ * from what the user will actually read. */
 export function missingCompletionSummaryLabels(text: string): CompletionSummaryLabel[] {
   const normalized = completionSummaryBody(text).trim();
+  const positions = labelPositions(normalized.toLowerCase());
   return COMPLETION_SUMMARY_LABELS.filter((label) => {
-    const start = labelIndex(normalized, label);
-    if (start < 0) return true;
-    const valueStart = start + label.length;
-    const next = COMPLETION_SUMMARY_LABELS
-      .map((candidate) => labelIndex(normalized.slice(valueStart), candidate))
-      .filter((index) => index >= 0)
-      .map((index) => valueStart + index)
+    const current = positions.find((entry) => entry.label === label);
+    if (!current) return true;
+    const valueStart = current.start + label.length;
+    const next = positions
+      .filter((entry) => entry.start > current.start)
+      .map((entry) => entry.start)
       .sort((a, b) => a - b)[0];
     return normalized.slice(valueStart, next ?? normalized.length).trim().length === 0;
   });

package/extensions/glla-update-check.ts

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { stateRootPending } from "./glla-state-root.js";
 import {
   compareVersions,
   GLLA_PACKAGE_NAME,
@@ -60,6 +61,10 @@ export function refreshUpdateCheck(
   now = Date.now(),
   spawnFn: SpawnFn = spawn as unknown as SpawnFn,
 ): void {
+  // v0.38.49 audit: while sessionDir resolution is pending there is no
+  // session root yet — skip the refresh (and its cache write) instead of
+  // creating a <cwd>/.pi-glla fallback tree.
+  if (stateRootPending()) return;
   try {
     const cached = readUpdateCheckRaw(cwd);
     if (cached && now - cached.checkedAt < UPDATE_CHECK_TTL_MS) return;

package/extensions/loops/goal-tools.ts

@@ -2213,9 +2213,14 @@ function registerAgentTools(pi: any): void {
       const tl = state.goal.taskList;
       // v0.38.48: copy-swap — the live list is never mutated in place, so a
       // kill between verify and persist (or a persist failure) cannot leave
-      // partial state. Message strings are unchanged (pinned by tests).
+      // partial state. Message strings are pinned by
+      // tests/task-atomicity-gate.test.ts.
       const t = findTask(tl, p.id);
-      if (t && t.status !== "complete") {
+      if (!t) return { content: [{ type: "text", text: `Task ${p.id} not found.` }], details: {} };
+      // v0.38.49 audit: an existing but already-complete task is a state
+      // fact, not a typo — report it instead of the not-found fallthrough.
+      if (t.status === "complete") return { content: [{ type: "text", text: `Task ${p.id} is already complete.` }], details: {} };
+      if (t) {
         const checkRes = await verifyTaskMilestone(ctx, t.verificationContract, signal);
         if (checkRes) {
           return {
@@ -2231,7 +2236,6 @@ function registerAgentTools(pi: any): void {
         }
         return { content: [{ type: "text", text: `Task ${p.id} marked complete.` }], details: {} };
       }
-      return { content: [{ type: "text", text: `Task ${p.id} not found.` }], details: {} };
     },
   }));
 
@@ -2253,8 +2257,13 @@ function registerAgentTools(pi: any): void {
         return { content: [{ type: "text", text: "No task list in this goal." }], details: {} };
       }
       const tl = state.goal.taskList;
-      // v0.38.48: copy-swap (see complete_task). Message strings unchanged.
+      // v0.38.48: copy-swap (see complete_task). Message strings are pinned
+      // by tests/task-atomicity-gate.test.ts.
       const t = findTask(tl, p.id);
+      if (!t) return { content: [{ type: "text", text: `Task ${p.id} not found.` }], details: {} };
+      // v0.38.49 audit: same-status moves are no-ops with a state-fact
+      // reply, not a persist round-trip reporting a change that happened.
+      if (t.status === p.status) return { content: [{ type: "text", text: `Task ${p.id} is already ${p.status}.` }], details: {} };
       if (t) {
         if (p.status === "complete") {
           const checkRes = await verifyTaskMilestone(ctx, t.verificationContract, signal);
@@ -2273,7 +2282,6 @@ function registerAgentTools(pi: any): void {
         }
         return { content: [{ type: "text", text: `Task ${p.id} → ${p.status}` }], details: {} };
       }
-      return { content: [{ type: "text", text: `Task ${p.id} not found.` }], details: {} };
     },
   }));
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.38.48",
+  "version": "0.38.49",
   "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",

package/prompts/goal-loop-continuation.md

@@ -55,9 +55,9 @@ 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`, `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`.
 
-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` as you go (not in a batch at the end). Limits: 20 tasks, 5 subtasks per task.
+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.
 
 When the agent calls any of these, the orchestrator tracks the call and persists state to `.pi-glla/active.jsonl`.
 
@@ -156,6 +156,8 @@ Do NOT conclude "the loop is too eager" or "I am broken" before checking what a
 
 Use tasks as PROGRESS TRACKERS during your work — not as a post-hoc checklist to batch-mark at the end.
 
+Pending-task gate: `complete_goal` is refused BEFORE the auditor when committed tasks are still open — the refusal names each open task and sends nothing to the auditor. Finish them with `complete_task` / `update_task_batch`, or record an explicit deferral with `record_goal_judgment` (`choice="deferred"` + `taskId`) for a genuinely blocked item.
+
 Before deciding that the goal is achieved, perform a completion audit against the actual current state:
 
 - Restate the objective as concrete deliverables or success criteria.
@@ -174,7 +176,7 @@ recap and synthesizes a recorded-facts-only fallback at terminalization when a
 legacy or incomplete caller omits it; never invent a commit, changed file, or
 passing test to make the recap sound complete.
 
-Then call `complete_goal`. The orchestrator will spawn an **isolated auditor** in a fresh session to verify, and either accept (mark goal complete) or reject (continue work).
+Then call `complete_goal` — only with every committed task finished or explicitly deferred, otherwise the claim is refused before audit (see the pending-task gate above). The orchestrator will spawn an **isolated auditor** in a fresh session to verify, and either accept (mark goal complete) or reject (continue work).
 
 If your work has shifted to items different from the original objective (the original was blocked, higher-ROI items emerged): pass `newObjective` to `complete_goal` to atomically update the objective and audit against the NEW one — do NOT call `complete_goal` on the original objective after shipping different work, the auditor will disapprove because the original isn't shipped. Alternatively `pause_goal` proposing a `/goal tweak` if the shift needs the user's call.
 
@@ -203,4 +205,4 @@ The orchestrator's backstop is the stall watchdog: three consecutive turns with
 
 `complete_goal` submits a nonterminal claim, not a completion verdict. While the detached audit is pending, do not say the goal is done/complete/approved or present a final success summary. Do not wait or poll. If a response is needed, give one brief pending-status sentence. GLLA posts the concrete outcome-first summary into chat after verified approval and durable archive, without needing another user prompt. Do not duplicate that summary. A rejected claim remains unfinished and repair work continues.
 
-The agent-written completionSummary is user-facing evidence, not a step log: open with the outcome in plain words, then one verifiable result per label with its proof inline (test counts, file paths, commit refs) — never raw run stats. Keep each label value to one line of ~90 chars so every chat bullet fits without a trailing …; cite human-readable proof (counts, versions, repo-relative paths, PR numbers) and never machine paths (/var/tmp logs, tarballs — those live in the archive only). Cut values at clause boundaries, never mid-word; write Next: as one concrete follow-up action or none (audit-self-referential lines like "verdict decides" are stripped at render); pass what was deliberately left out as the complete_goal leftOut parameter — it renders as the closing bullet, and is omitted when absent.
+The agent-written completionSummary is user-facing evidence, not a step log: open with the outcome in plain words, then one verifiable result per label with its proof inline (test counts, file paths, commit refs) — never raw run stats. Keep each label value to one or two short clauses so it survives the renderer's clause-boundary clipping (rich sections budget ~200 chars per value); cite human-readable proof (counts, versions, repo-relative paths, PR numbers) and never machine paths (/var/tmp logs, tarballs — those live in the archive only). Cut values at clause boundaries, never mid-word; write Next: as one concrete follow-up action or none (audit-self-referential lines like "verdict decides" are stripped at render); pass what was deliberately left out as the complete_goal leftOut parameter — it renders as the closing bullet, and is omitted when absent.