pi-goal-list-loop-audit 0.38.12 → 0.38.14

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.38.14 — human end-of-objective briefing (2026-09-04)
+
+### Changed
+  Every `✓ done` chat notify is now a human briefing: outcome first in its own words, only informing labels after it (`none` / `not recorded` / empty filler dropped; `none — <content>` keeps the content). Word-boundary cuts, auditor/no-audit trailer, archive keeps the full six-label record. Runbook in `audit/HUMAN-BRIEF-2026-09-04.md`.
+
+## 0.38.13 — good completion summary (2026-09-04)
+
+### Changed
+  The `✓ done` chat notify is now the six-label block (one `Label: value` line each, 240-char word-bounded values) instead of the single-line mash with mid-word cuts. New `clipSummaryValue` cuts at word boundaries everywhere (hard-cut only for spaceless tokens); widget card and external notifies keep the compact line. Fixed a post-archive null crash that silently swallowed the notify. Runbook in `audit/COMPLETION-SUMMARY-2026-09-04.md`.
+
 ## 0.38.12 — last-wins sessions + objectives (2026-09-04)
 
 ### Changed

package/docs/INDEX.md

@@ -18,7 +18,7 @@ For shipped docs, the relevant entry points are:
   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.12 continue through the supervisor freeze (`/glla pause`),
+  v0.35.14–v0.38.14 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/completion-summary.ts

@@ -77,6 +77,21 @@ export function isUsefulCompletionSummary(text: string | undefined): boolean {
  * Missing labels are retained as `not recorded` so a compact notification
  * cannot accidentally imply evidence that the durable recap did not contain.
  */
+/** Cut a summary value at a word boundary, never mid-word (the
+ * Screenshot_20260903_204003/204005 complaint: `0 o…`, `qu…`, `belo…`).
+ * Falls back to a hard cut only when the head holds no space past the
+ * halfway mark — a long token such as a commit hash must not eviscerate
+ * the whole value. Short values pass through untouched (no `…`). */
+export function clipSummaryValue(value: string, limit: number): string {
+  const clean = value.replace(/\s+/g, " ").trim();
+  const capped = Number.isFinite(limit) ? Math.max(8, Math.floor(limit)) : 72;
+  if (clean.length <= capped) return clean;
+  const head = clean.slice(0, capped - 1);
+  const space = head.lastIndexOf(" ");
+  const kept = (space > capped / 2 ? head.slice(0, space) : head).trimEnd();
+  return `${kept}…`;
+}
+
 export function compactCompletionSummary(text: string | undefined, maxValueLength = 72): string {
   const source = completionSummaryBody(text ?? "").replace(/\s+/g, " ").trim();
   if (!source) return "not recorded";
@@ -96,11 +111,78 @@ export function compactCompletionSummary(text: string | undefined, maxValueLengt
       .sort((a, b) => a - b)[0] ?? source.length;
     const rawValue = source.slice(valueStart, nextStart).trim();
     const value = rawValue || "not recorded";
-    return `${name}: ${value.length > limit ? `${value.slice(0, limit - 1)}…` : value}`;
+    return `${name}: ${clipSummaryValue(value, limit)}`;
   });
   return parts.join(" · ");
 }
 
+/** A recap value informs the human only when it is not an empty / none /
+ * not-recorded placeholder. `None — <real content>` (a common agent habit)
+ * keeps just the content. Returns null for filler. */
+export function briefValueContent(value: string): string | null {
+  const clean = value.replace(/\s+/g, " ").trim();
+  if (!clean) return null;
+  // System placeholder vocabulary: the `— explanation` is still a placeholder.
+  if (/^not recorded\b/i.test(clean)) return null;
+  // Agent habit: `none — <real content>` hides information behind filler.
+  const prefixed = /^none\s*[—–:\-]\s*(.+)$/i.exec(clean);
+  const body = (prefixed?.[1] ?? clean).trim();
+  if (/^(none|n\/a|nil|nothing)(\s+for\s+this\s+\w+)?\.?$/i.test(body)) return null;
+  return body;
+}
+
+export interface HumanCompletionBrief {
+  outcome: string;
+  details: string[];
+}
+
+/** The human briefing: outcome first in its own words, then only the
+ * labels that carry real content (filler like `Unresolved: none` or
+ * `Changed: not recorded` is dropped, never shown). The durable archive
+ * keeps the full six-label record; this is the end-of-objective voice
+ * that informs the user at a glance. */
+export function humanCompletionBrief(
+  text: string | undefined,
+  outcomeBudget = 140,
+  valueBudget = 120,
+): HumanCompletionBrief {
+  const lines = completionSummaryLines(text, Math.max(outcomeBudget, valueBudget));
+  const rawOutcome = (lines[0] ?? "").replace(/^Outcome:\s*/, "");
+  const outcome = clipSummaryValue(briefValueContent(rawOutcome) ?? "done", outcomeBudget);
+  const details: string[] = [];
+  for (const line of lines.slice(1)) {
+    const separator = line.indexOf(":");
+    if (separator < 0) continue;
+    const content = briefValueContent(line.slice(separator + 1));
+    if (content) details.push(`${line.slice(0, separator)}: ${clipSummaryValue(content, valueBudget)}`);
+  }
+  return { outcome, details };
+}
+
+/** Multi-line projection: one `Label: value` line per label with generous
+ * word-bounded values. This is the user-facing `✓ done` block — six short
+ * facts that stay scannable in chat. The single-line projection remains
+ * for width-bound surfaces (TUI widget card, external notifies). */
+export function completionSummaryLines(text: string | undefined, maxValueLength = 240): string[] {
+  const source = completionSummaryBody(text ?? "").replace(/\s+/g, " ").trim();
+  const lower = source.toLowerCase();
+  const positions = COMPLETION_SUMMARY_LABELS
+    .map((label) => ({ label, start: lower.indexOf(label.toLowerCase()) }))
+    .filter((entry) => entry.start >= 0);
+  return COMPLETION_SUMMARY_LABELS.map((label) => {
+    const name = label.slice(0, -1);
+    const current = positions.find((entry) => entry.label === label);
+    if (!source || !current) return `${name}: not recorded`;
+    const valueStart = current.start + label.length;
+    const nextStart = positions
+      .filter((entry) => entry.start > current.start)
+      .map((entry) => entry.start)
+      .sort((a, b) => a - b)[0] ?? source.length;
+    const rawValue = source.slice(valueStart, nextStart).trim();
+    return `${name}: ${clipSummaryValue(rawValue || "not recorded", maxValueLength)}`;
+  });
+}
+
 function safeFact(value: unknown, fallback = "not recorded"): string {
   const text = typeof value === "string" ? value.replace(/\s+/g, " ").trim() : "";
   return text || fallback;
@@ -197,6 +279,25 @@ export function compactTerminalCompletionSummary(
   return compactCompletionSummary(resolveCompletionSummary(facts, candidate).summary, maxValueLength);
 }
 
+/** Brief twin of compactTerminalCompletionSummary for the `✓ done` chat
+ * notifies: same resolved facts, outcome + informing labels only. */
+export function terminalHumanBrief(
+  facts: CompletionSummaryFacts,
+  candidate = facts.goal.completionSummary,
+): HumanCompletionBrief {
+  return humanCompletionBrief(resolveCompletionSummary(facts, candidate).summary);
+}
+
+/** Multi-line twin of compactTerminalCompletionSummary for the `✓ done`
+ * chat notifies: same resolved facts, one `Label: value` line each. */
+export function terminalCompletionSummaryLines(
+  facts: CompletionSummaryFacts,
+  candidate = facts.goal.completionSummary,
+  maxValueLength = 240,
+): string[] {
+  return completionSummaryLines(resolveCompletionSummary(facts, candidate).summary, maxValueLength);
+}
+
 /**
  * Loop terminal states use the same six-label user-facing contract. Loop
  * state is converted to the smaller Goal-shaped fact set by the caller, so

package/extensions/loops/goal-auditor-hooks.ts

@@ -240,7 +240,7 @@ import {
   pushCapped as pushRepetitionCapped,
 } from "../goal-loop-repetition.js";
 import { buildStatusText, buildWidgetLines, type AuditDisplayProgress } from "../goal-loop-display.js";
-import { compactCompletionSummary, compactTerminalCompletionSummary, isGenericCompletionSummary, missingCompletionSummaryLabels } from "../completion-summary.js";
+import { compactCompletionSummary, compactTerminalCompletionSummary, isGenericCompletionSummary, missingCompletionSummaryLabels, terminalHumanBrief } from "../completion-summary.js";
 import {
   defaultAgentDir,
   resolveEffectiveSubagentModel,
@@ -1415,6 +1415,13 @@ async function retryStoredCompletionAudit(origin: CompletionAuditOrigin = "provi
       stopReason: terminalReason,
       archivePath: path.relative(liveCtx.cwd, archivedGoalPath(liveCtx.cwd, state.goal.id)) || archivedGoalPath(liveCtx.cwd, state.goal.id),
     }, state.goal.completionSummary);
+    // Computed pre-archive: archiveCurrentGoal clears state.goal.
+    const brief = terminalHumanBrief({
+      goal: state.goal,
+      status: "complete",
+      stopReason: terminalReason,
+      archivePath: path.relative(liveCtx.cwd, archivedGoalPath(liveCtx.cwd, state.goal.id)) || archivedGoalPath(liveCtx.cwd, state.goal.id),
+    }, state.goal.completionSummary);
     const approvalVia = `${origin === "manual" ? " on /goal verify" : origin === "session-recovery" ? " after session recovery" : " on the provider retry"}${fallbackUsed ? " after an auditor-model fallback" : ""}`;
     const archived = archiveCurrentGoal(liveCtx, "complete", `auditor ${result.model} approved (${origin})`);
     if (!archived) {
@@ -1431,7 +1438,10 @@ async function retryStoredCompletionAudit(origin: CompletionAuditOrigin = "provi
       appendLedger(liveCtx.cwd, "goal_archive_failed_after_approval", { goalId, attemptId: claim.attemptId, origin });
       return;
     }
-    liveCtx.ui.notify(`✓ done: ${recap} — auditor ${result.model} approved${approvalVia}.`, "info");
+    // v0.38.14: the chat notify is the human briefing — outcome first,
+    // filler labels dropped — while the external notify keeps the compact
+    // single line (pager/sound safe).
+    liveCtx.ui.notify(`✓ done — ${brief.outcome}\n${[...brief.details, `— auditor ${result.model} approved${approvalVia}.`].join("\n")}`, "info");
     notifyExternal(liveCtx, `Goal complete (auditor approved, ${origin}): ${recap}`);
     return;
   }

package/extensions/loops/goal-tools.ts

@@ -250,7 +250,7 @@ import {
   pushCapped as pushRepetitionCapped,
 } from "../goal-loop-repetition.js";
 import { buildStatusText, buildWidgetLines, type AuditDisplayProgress } from "../goal-loop-display.js";
-import { compactCompletionSummary, compactTerminalCompletionSummary, resolveCompletionSummary } from "../completion-summary.js";
+import { compactCompletionSummary, compactTerminalCompletionSummary, resolveCompletionSummary, terminalHumanBrief } from "../completion-summary.js";
 import {
   defaultAgentDir,
   resolveEffectiveSubagentModel,
@@ -1216,9 +1216,16 @@ function registerAgentTools(pi: any): void {
               details: {},
             };
           }
-          ctx.ui.notify(`✓ done without audit (user choice): ${recap}`, "info");
+          const brief = terminalHumanBrief({
+            goal: terminalGoal,
+            status: "complete",
+            stopReason: terminalReason,
+            archivePath: path.relative(ctx.cwd, archivedGoalPath(ctx.cwd, terminalGoal.id)) || archivedGoalPath(ctx.cwd, terminalGoal.id),
+          });
+          const briefBlock = [...brief.details, `— completed without audit (your choice).`].join("\n");
+          ctx.ui.notify(`✓ done — ${brief.outcome}\n${briefBlock}`, "info");
           notifyExternal(ctx, `Goal complete without audit (user choice): ${recap}`);
-          return { content: [{ type: "text", text: `Goal marked complete without audit (user choice).\n\n${recap}` }], details: {} };
+          return { content: [{ type: "text", text: `Goal marked complete without audit (user choice).\n\n${briefBlock}` }], details: {} };
         }
         scheduleContinuation(ctx, true);
         return {
@@ -1243,6 +1250,13 @@ function registerAgentTools(pi: any): void {
           stopReason: terminalReason,
           archivePath: path.relative(ctx.cwd, archivedGoalPath(ctx.cwd, state.goal.id)) || archivedGoalPath(ctx.cwd, state.goal.id),
         }, state.goal.completionSummary);
+        // Computed pre-archive: archiveCurrentGoal clears state.goal.
+        const brief = terminalHumanBrief({
+          goal: state.goal,
+          status: "complete",
+          stopReason: terminalReason,
+          archivePath: path.relative(ctx.cwd, archivedGoalPath(ctx.cwd, state.goal.id)) || archivedGoalPath(ctx.cwd, state.goal.id),
+        }, state.goal.completionSummary);
         const archived = archiveCurrentGoal(ctx, "complete", terminalReason);
         if (!archived) {
           // The archive helper preserves the live objective and emits the
@@ -1258,7 +1272,7 @@ function registerAgentTools(pi: any): void {
           appendLedger(ctx.cwd, "goal_archive_failed_after_approval", { goalId: state.goal?.id, origin: "manual-verify", model: result.model });
           return { content: [{ type: "text", text: "The auditor approved, but the terminal archive could not be persisted. The goal is paused; fix persistence, resume, and retry complete_goal." }], details: {} };
         }
-        ctx.ui.notify(`✓ done: ${recap} — auditor ${result.model} approved.`, "info");
+        ctx.ui.notify(`✓ done — ${brief.outcome}\n${[...brief.details, `— auditor ${result.model} approved.`].join("\n")}`, "info");
         notifyExternal(ctx, `Goal complete (auditor approved): ${recap}`);
         return { content: [{ type: "text", text: `Goal approved by auditor ${result.model}.` }], details: {} };
       }

package/package.json

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