pi-goal-list-loop-audit 0.38.55 → 0.38.56

package/CHANGELOG.md

@@ -1,5 +1,58 @@
 # Changelog
 
+## 0.38.56 — Refine-and-resume loops, chatter-resolving tweaks (2026-09-16)
+
+### Context-inferred tweak objectives
+
+`/goal tweak`, `/list tweak`, and the bare-tweak dialog resolve chatter
+against the session context instead of adopting it (field 2026-09-16 —
+the VidPro ledger recorded `objective:"ok adjsut it"`). Self-contained
+text still adopts verbatim; an acknowledgment (`go`, `ok adjust it`)
+resolves via the discussed context and the confirm shows
+CURRENT → INFERRED; with nothing clear discussed, a guidance message
+names the shape and nothing changes. An explicit `Done when:` contract
+stays verbatim — explicit intent wins. Raw chatter never reaches the
+ledger on any adoption path (including the plain-`/goal` conflict
+update, which funnels through the same resolver).
+
+### Loop-sweep refinability
+
+`/loop refine` works on resumable-held loops (field 2026-09-16 loop
+sweep): the hint queues, then the byte-identical resume path runs —
+refine-and-resume (owner choice), with wrong-branch and active-goal
+guards keeping their voices so the loop stays held when they fire. Dead
+loops stay refused with the honest path (`/loop start` for ended runs,
+the agent `propose_loop_refine` repair for broken measures — no hint is
+queued onto a loop that can never run again). The agent tool predicate
+accepts parked loops too, so both surfaces agree (parity matrix pinned;
+broken-measure stays tool-only by design). `stop`/`pause`/`finish`/
+`status`/`resume` already handled held loops gracefully — sweep found no
+further dead spots.
+
+### Paused-goal tweak
+
+`/goal tweak` accepts a paused goal instead of stranding it behind a
+resume round-trip (field 2026-09-16, the VidPro park: tweak bounced
+with "No active goal to tweak" while the goal sat paused). Mirrors
+`/list tweak`, which is paused-only: the tweak applies, the goal stays
+paused with its pause reason intact, nothing is scheduled, and the
+result points at `/goal resume`. The nothing-to-tweak refusal now reads
+"No goal to tweak. /goal <objective> to start one."
+
+### Structured-long summaries
+
+A section-structured `Outcome` (2+ `##`–`####` headers, tables) now
+renders in full as the card's `### Summary` section — a working document
+is no longer truncated into a status ping (field 2026-09-16, the
+keyword-review close). The card answers two questions, informative over
+long: Summary carries what happened plus the horizon (slices 2–3),
+`Next` still names only the single immediate move (slice 1). Structure
+is the price of length: unstructured values keep today's budgets and
+the headline echo stays short. Delivery-only (terminal card +
+archive human layer) with a 100k pathological guard pointing at the
+archive; headline, verification, recap, and every recycled per-tick
+payload stay bounded.
+
 ## 0.38.55 — Full-parity terminal card, lenient auditor, agent resume (2026-09-16)
 
 ### Full-parity terminal card

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

@@ -289,6 +289,83 @@ export const RICH_OBJECTIVE_ECHO_CHARS = 80;
 export const RICH_TABLE_GROUP_THRESHOLD = 4;
 /** v0.38.50: evidence tokens per finding cell — density, not a dump. */
 export const RICH_EVIDENCE_TOKENS_PER_FINDING = 4;
+/** Structured-long doctrine (field 2026-09-16 — the keyword-review close):
+ * a section-structured label value is a working document, not a status
+ * ping, and truncating it destroys its purpose. Structure is the price
+ * of length: at least this many `##`–`####` section headers keeps the
+ * value on the structured path; anything else keeps today's budgets.
+ * Delivery-only: the terminal card and the archive human layer. Recycled
+ * per-tick payloads (continuation, handoff, checkpoint) stay bounded. */
+export const RICH_STRUCTURED_MIN_HEADERS = 2;
+/** Structured-long guard against pathological megabytes: the tool call
+ * carries no length bound, so the structured path still ends — with an
+ * honest truncation note pointing at the archive, never silent soup. */
+export const RICH_STRUCTURED_VALUE_BUDGET = 100_000;
+
+/** Count markdown section headers (`##`–`####` with text) in raw text.
+ * H1 (`# `) is a document title, not a section — it does not count. */
+export function countSectionHeaders(text: string): number {
+  const matches = (text ?? "").match(/^#{2,4}\s+\S/gm);
+  return matches ? matches.length : 0;
+}
+
+export function isSectionStructured(text: string): boolean {
+  return countSectionHeaders(text) >= RICH_STRUCTURED_MIN_HEADERS;
+}
+
+const STRUCTURED_LABELS = ["Outcome:", "Changed:", "Evidence:", "Tests:", "Unresolved:", "Next:"];
+
+/** Raw (newline-preserving) label value for the structured path. Labels
+ * anchor to line starts and the last restatement wins — the same
+ * doctrine as labelPositions on the flattened path (v0.38.45). Residual
+ * ambiguity (a structured doc quoting `Changed:` at a line start) cuts
+ * the value early and the detector usually falls back to clipped
+ * rendering — doubt resolves to today's behavior, never to invention. */
+export function rawLabelValue(text: string, label: string): string | null {
+  const source = text ?? "";
+  if (!source) return null;
+  const openings: number[] = [];
+  const openPattern = new RegExp(`^${label}`, "gim");
+  for (const match of source.matchAll(openPattern)) openings.push(match.index ?? 0);
+  if (openings.length === 0) return null;
+  const start = openings[openings.length - 1]! + label.length;
+  const restPattern = new RegExp(`^(${STRUCTURED_LABELS.filter((entry) => entry !== label).join("|")})`, "gim");
+  restPattern.lastIndex = start;
+  const next = restPattern.exec(source);
+  const end = next ? (next.index ?? source.length) : source.length;
+  const value = source.slice(start, end).trim();
+  return value || null;
+}
+
+/** Machine-token strip for structured lines. chatSafeDetailValue also
+ * collapses multi-space runs, which would damage markdown table
+ * alignment padding — structured lines keep their spacing and drop
+ * only the archive-only tokens. */
+function stripMachineTokens(line: string): string {
+  return line
+    .replace(/(?:\/var)?\/tmp\/\S+/g, "")
+    .replace(/\S+\.tgz\b/g, "")
+    .replace(/\(\s*\)/g, "")
+    .replace(/\s+$/u, "");
+}
+
+/** Full Outcome body for the `### Summary` card section, or null when
+ * the value is not section-structured (caller keeps today's budgets).
+ * Newlines and tables survive; machine paths stay archive-only; the
+ * pathological guard ends with an honest pointer, never silent soup. */
+export function structuredSummaryLines(summary: string | undefined, label = "Outcome:"): string[] | null {
+  const raw = rawLabelValue(summary ?? "", label);
+  if (!raw || !isSectionStructured(raw)) return null;
+  const lines = raw.split("\n").map(stripMachineTokens);
+  while (lines.length > 0 && !(lines[0] ?? "").trim()) lines.shift();
+  while (lines.length > 0 && !(lines[lines.length - 1] ?? "").trim()) lines.pop();
+  let text = lines.join("\n");
+  const units = [...text];
+  if (units.length > RICH_STRUCTURED_VALUE_BUDGET) {
+    text = `${units.slice(0, RICH_STRUCTURED_VALUE_BUDGET).join("")}\n\n… (truncated for chat — full text in the archived record.)`;
+  }
+  return text.split("\n");
+}
 
 export interface RichTerminalParts {
   /** v0.38.55 (full parity): verdict banner — `## Done — auditor
@@ -303,6 +380,11 @@ export interface RichTerminalParts {
   /** v0.38.55 (full parity): final repository state section lines.
    * Empty when the state could not be read (absent stays absent). */
   repoLines: string[];
+  /** Structured-long body (field 2026-09-16): full Outcome text with
+   * newlines preserved, rendered as `### Summary`. Empty unless the
+   * value earned the structured path — never a second copy of the
+   * clipped headline echo. */
+  summaryLines: string[];
 }
 
 function escapeTableCell(value: string): string {
@@ -472,6 +554,10 @@ export function buildRichTerminalParts(args: {
    * tree cleanliness) from the render call site, which owns cwd access.
    * Absent keeps the section out — never invented. */
   repoState?: string[];
+  /** Structured-long body lines from structuredSummaryLines. Absent
+   * keeps the `### Summary` section out (unstructured summaries keep
+   * today's headline-echo shape). */
+  summaryLines?: string[];
 }): RichTerminalParts {
   const { findings, tests, next } = partitionRichDetails(args.details);
   const outcome = args.outcome;
@@ -573,6 +659,7 @@ export function buildRichTerminalParts(args: {
     tableLines,
     nextLines,
     repoLines: args.repoState ?? [],
+    summaryLines: args.summaryLines ?? [],
   };
 }
 
@@ -587,6 +674,14 @@ export function composeRichTerminalLines(parts: RichTerminalParts): string[] {
   const lines = [parts.banner ?? parts.headline, ""];
   if (parts.headline !== lines[0]) lines.push(parts.headline, "");
   if (parts.durationLine) lines.push(parts.durationLine, "");
+  // Structured-long (field 2026-09-16): the full Outcome body rides its
+  // own section between the headline and the findings — findings-first
+  // order is preserved (findings, verification, Next keep their relative
+  // order), the headline echo stays short, and the one-action Next rule
+  // is untouched.
+  if (parts.summaryLines.length > 0) {
+    lines.push("### Summary", ...parts.summaryLines, "");
+  }
   if (parts.findingLines.length > 0) {
     lines.push("### Key Findings & Remediation", ...parts.findingLines, "");
   }
@@ -611,6 +706,7 @@ export function buildRichArchiveSection(goal: Goal, status: Status, archivePath:
   const facts: CompletionSummaryFacts = { goal, status, archivePath };
   const summary = resolveCompletionSummary(facts, goal.completionSummary).summary;
   const brief = humanCompletionBrief(summary, 140, RICH_FULL_VALUE_BUDGET);
+  const structured = structuredSummaryLines(summary);
   const history = goal.auditHistory ?? [];
   const latest = history[history.length - 1];
   const approval = latest
@@ -628,6 +724,7 @@ export function buildRichArchiveSection(goal: Goal, status: Status, archivePath:
     gates: gateRows,
     // v0.38.55: aborted records never wear a Done banner/headline.
     kind: status === "complete" ? "Done" : "Aborted",
+    ...(structured ? { summaryLines: structured } : {}),
   });
   return [
     ...composeRichTerminalLines(parts),
@@ -778,6 +875,11 @@ export function buildTerminalApprovalRender(input: TerminalApprovalRenderInput):
     140,
     RICH_FULL_VALUE_BUDGET,
   );
+  // Structured-long (field 2026-09-16): a section-structured Outcome
+  // earns the full `### Summary` section on the terminal card (and the
+  // archive human layer). Headline echo, verification, Next, recap, and
+  // every recycled payload keep their bounds.
+  const structured = structuredSummaryLines(resolveCompletionSummary(facts, candidate).summary);
   // v0.38.37 (audit 2026-09-08): the deliberate non-do comes from the
   // agent's complete_goal leftOut claim — never invented. Filler ("none")
   // drops via the same briefValueContent filter; absent stays absent.
@@ -821,6 +923,7 @@ export function buildTerminalApprovalRender(input: TerminalApprovalRenderInput):
     groups: input.findingGroups,
     gates: input.gateRows,
     ...(input.repoState ? { repoState: input.repoState } : {}),
+    ...(structured ? { summaryLines: structured } : {}),
   });
   const chatBody = composeRichTerminalLines(richParts);
   const transcriptBody = composeRichTerminalLines(richParts);

package/extensions/goal-commands.ts

@@ -39,7 +39,7 @@ import { formatGllaVersion } from "./glla-version.js";
 import { cmdGllaOwner, cmdGllaTakeover } from "./state-root-owner.js";
 import { AUDIT_JOB_CLEANUP_MIN_AGE_MS, cancelDetachedGoalCompletionAuditor, cleanupDeadAuditJobs, inspectAuditJobHealth, DEFAULT_AUDITOR_STALL_MS, DEFAULT_AUDITOR_TOOL_TIMEOUT_MS } from "./goal-loop-auditor-process.js";
 import { releaseAuditorSurface } from "./loops/goal-auditor-surface.js";
-import { inferStartFromSession, type StartContextInference } from "./start-context.js";
+import { inferStartFromSession, resolveTweakReplacement, type StartContextInference } from "./start-context.js";
 
 /** Child pi sessions live under the shared session store, munged by cwd
  * (verified layout: ~/.pi/agent/sessions/--home-user-proj--/*.jsonl). */
@@ -755,11 +755,17 @@ export async function cmdTweak(
     && current?.policy === "list"
     && (current.status === "active" || current.status === "auditing");
   const expectedStatus = mode === "list" ? "paused" : "active";
-  if (!current || (current.status !== expectedStatus && !liveListConflict) || (mode === "list" && current.policy !== "list")) {
+  // Field 2026-09-16 (the VidPro park): /goal tweak accepts a paused goal
+  // instead of stranding it behind a resume round-trip. Mirrors /list
+  // tweak, which is paused-only and stays paused.
+  const tweakable = mode === "list"
+    ? current?.status === expectedStatus
+    : current?.status === "active" || current?.status === "paused";
+  if (!current || (!tweakable && !liveListConflict) || (mode === "list" && current.policy !== "list")) {
     ctx.ui.notify(
       mode === "list"
         ? "No paused list item to tweak. /list tweak <replacement objective, optional 'Done when: ...' clause>"
-        : "No active goal to tweak. /goal <objective> to start one.",
+        : "No goal to tweak. /goal <objective> to start one.",
       "info",
     );
     return false;
@@ -797,7 +803,29 @@ export async function cmdTweak(
     }
     raw = v.trim();
   }
-  const proposed = extractVerificationContract(raw);
+  // Field 2026-09-16 (VidPro ledger — `/goal tweak` adopted "ok adjsut it"
+  // as the objective): chatter is a pointer at the session context, not a
+  // replacement. Resolve it against what was actually discussed; guide when
+  // nothing clear was discussed. Raw chatter never reaches the ledger.
+  // This sits in cmdTweak because all adoption paths funnel here: /goal
+  // tweak, /list tweak, and the plain-/goal "Update current objective"
+  // conflict choice (via updateWholeObjectiveFromConflict).
+  const replacement = resolveTweakReplacement(raw, ctx.sessionManager);
+  let adopted = raw;
+  let inferredNote = "";
+  if (replacement.kind === "inferred") {
+    adopted = replacement.text;
+    inferredNote = ` (inferred from ${replacement.source === "recent-context" ? "recent discussion" : "your message"} — yours read "${displaySlice(raw, 80)}"; cancel and re-run with exact wording if this is wrong)`;
+  } else if (replacement.kind === "unresolvable") {
+    const surface = mode === "list" ? "list item" : "goal";
+    let guidance = `That reads as an acknowledgment rather than a replacement ("${displaySlice(raw, 80)}") — nothing changed. The ${surface} keeps: ${displaySlice(current.objective, 120)}. Say what it should become as full replacement text.`;
+    if (replacement.reason === "ambiguous" && replacement.candidates.length > 0) {
+      guidance += ` It could mean: ${replacement.candidates.slice(0, 2).map((c) => `"${displaySlice(c, 100)}"`).join(" / ")} — re-run with one in full.`;
+    }
+    ctx.ui.notify(guidance, "info");
+    return false;
+  }
+  const proposed = extractVerificationContract(adopted);
   const newObjective = proposed.objective;
   if (!newObjective) {
     // (a bare input of "Done when: ..." only yields this — the replacement
@@ -833,7 +861,7 @@ export async function cmdTweak(
   try {
     confirmed = await ctx.ui.confirm(
       mode === "list" ? "Tweak list item?" : "Tweak goal?",
-      `CURRENT:\n${sanitizeDisplayText(current.objective)}\n\nNEW:\n${sanitizeDisplayText(newObjective)}` +
+      `CURRENT:\n${sanitizeDisplayText(current.objective)}\n\nNEW${inferredNote}:\n${sanitizeDisplayText(newObjective)}` +
       (hasNewContract
         ? `\n\nNew contract:\n${sanitizeDisplayText(proposed.verificationContract)}`
         : clearsContract
@@ -862,7 +890,7 @@ export async function cmdTweak(
     return false;
   }
   const priorProvenance = latest.objectiveProvenance;
-  const userSeeds = [...(priorProvenance?.userSeeds ?? []), raw].slice(-10);
+  const userSeeds = [...(priorProvenance?.userSeeds ?? []), adopted].slice(-10);
   const replacingLiveList = liveListConflict
     && latest.policy === "list"
     && (latest.status === "active" || latest.status === "auditing");
@@ -921,6 +949,14 @@ export async function cmdTweak(
     ctx.ui.notify("List item tweaked; it remains paused. /list resume to continue.", "info");
     return true;
   }
+  // A paused goal stays paused — the tweak must not wake the loop (field
+  // 2026-09-16: the VidPro park re-parked on every wake, which is the
+  // hamster wheel in the report). The user resumes explicitly when the
+  // blocker clears.
+  if (latest.status === "paused") {
+    ctx.ui.notify("Goal tweaked; it remains paused. /goal resume to continue.", "info");
+    return true;
+  }
   ctx.ui.notify("Goal tweaked. The loop continues against the new objective.", "info");
   scheduleContinuation(ctx, true);
   return true;

package/extensions/goal-loop-forever.ts

@@ -57,7 +57,12 @@ export function isLifecycleHeldLoopReason(reason?: string): boolean {
 /** A stopped loop can be respecified without discarding its history when the
  * stop is a recoverable work failure or an explicit time/token window. Max
  * iterations and clean/user stops remain terminal until a fresh `/loop start`.
- */
+ * Field 2026-09-16 (loop sweep): parked loops (user pause, restore-hold,
+ * zero-stream abort, user-stop-with-em-dash) are refinable too — parity with
+ * the slash-side RESUMABLE_STOP so both surfaces agree on what can be
+ * rescoped. `measure command broken` stays tool-only by design: the agent
+ * fixes the measure here, while slash resume must not restart a broken
+ * loop until it is fixed. */
 export function isRefinableStoppedLoopReason(reason?: string): boolean {
   return !!reason && (
     reason.startsWith("time bound reached")
@@ -68,6 +73,10 @@ export function isRefinableStoppedLoopReason(reason?: string): boolean {
     || reason.startsWith("measure command broken —")
     || reason.startsWith("provider errors —")
     || reason.startsWith("stalled:")
+    || reason === HELD_ON_RESTORE
+    || reason.startsWith("paused by user (/loop pause)")
+    || reason.startsWith("stopped: automatic zero-stream abort")
+    || reason.startsWith("stopped by user —")
   );
 }
 

package/extensions/goal-loop.ts

@@ -215,6 +215,46 @@ function isLoopActive(): boolean {
   return !!state.loop?.active;
 }
 
+// Resumable-stop predicate, hoisted to module scope (field 2026-09-16,
+// loop sweep): /loop resume and /loop refine share it so a held loop is
+// refinable wherever it is resumable.
+// v0.29.20: plain plateau stops are resumable too — pre-gate plateaus
+// could be false (hegemon/polis stopped 2026-07-31 with open findings
+// on 429-dead turns), and an explicit resume is the user's call; the
+// v0.29.19 gate + re-armed counters make the resumed run honest.
+export const RESUMABLE_STOP = (r?: string): boolean =>
+  r === HELD_ON_RESTORE ||
+  !!r?.startsWith("provider errors —") ||
+  !!r?.startsWith("stopped by user —") ||
+  !!r?.startsWith("plateau —") ||
+  !!r?.startsWith("stalled:") ||
+  !!r?.startsWith("stuck —") ||
+  !!r?.startsWith("time bound reached") ||
+  !!r?.startsWith("token budget exhausted") ||
+  // v0.35.54 (collect-pass HIGH finding): the v0.35.31 "metric never
+  // moved" stop message promises "/loop resume retries or /loop stop",
+  // but this predicate never matched that prefix — the promised command
+  // answered "No held loop to resume" and, with propose_loop_refine
+  // gated on an ACTIVE loop, the only recovery was /loop stop + a fresh
+  // start discarding iteration history. Same class as the v0.35.25
+  // issue-#14 zombie prefix (fixed there, missed for this brand-new
+  // prefix). Resuming re-arms the counters; if the metric is still dead
+  // it re-stops loudly after its window — and a measure-changing
+  // propose_loop_refine (usable again once resumed) re-scopes the era so
+  // the never-moved grace re-arms.
+  !!r?.startsWith("metric never moved —") ||
+  // v0.35.25 (issue #14): abortZombieRun parks with
+  // "stopped: automatic zero-stream abort — … (/loop resume to retry)"
+  // and its user-facing message PROMISES that resume command. The
+  // predicate it lands in never matched the prefix, so /loop resume
+  // answered "No held loop to resume" and the preserved iteration,
+  // best value, and history were unreachable without re-drafting.
+  !!r?.startsWith("stopped: automatic zero-stream abort") ||
+  // v0.38.27 (ported from Bjynt's PR #46): /loop pause is a soft-hold
+  // parallel to /goal pause. The loop stays resumable; finishLoopGit
+  // was skipped, so resume picks up iteration/best/history verbatim.
+  !!r?.startsWith("paused by user (/loop pause)");
+
 async function resolveLoopStartConflict(ctx: ExtensionContext, target: string): Promise<boolean> {
   const current = liveObjectives(state);
   if (current.length === 0) return true;
@@ -994,42 +1034,6 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
       return;
     }
     const stored = state.loop;
-    // v0.29.20: plain plateau stops are resumable too — pre-gate plateaus
-    // could be false (hegemon/polis stopped 2026-07-31 with open findings
-    // on 429-dead turns), and an explicit resume is the user's call; the
-    // v0.29.19 gate + re-armed counters make the resumed run honest.
-    const RESUMABLE_STOP = (r?: string): boolean =>
-      r === HELD_ON_RESTORE ||
-      !!r?.startsWith("provider errors —") ||
-      !!r?.startsWith("stopped by user —") ||
-      !!r?.startsWith("plateau —") ||
-      !!r?.startsWith("stalled:") ||
-      !!r?.startsWith("stuck —") ||
-      !!r?.startsWith("time bound reached") ||
-      !!r?.startsWith("token budget exhausted") ||
-      // v0.35.54 (collect-pass HIGH finding): the v0.35.31 "metric never
-      // moved" stop message promises "/loop resume retries or /loop stop",
-      // but this predicate never matched that prefix — the promised command
-      // answered "No held loop to resume" and, with propose_loop_refine
-      // gated on an ACTIVE loop, the only recovery was /loop stop + a fresh
-      // start discarding iteration history. Same class as the v0.35.25
-      // issue-#14 zombie prefix (fixed there, missed for this brand-new
-      // prefix). Resuming re-arms the counters; if the metric is still dead
-      // it re-stops loudly after its window — and a measure-changing
-      // propose_loop_refine (usable again once resumed) re-scopes the era so
-      // the never-moved grace re-arms.
-      !!r?.startsWith("metric never moved —") ||
-      // v0.35.25 (issue #14): abortZombieRun parks with
-      // "stopped: automatic zero-stream abort — … (/loop resume to retry)"
-      // and its user-facing message PROMISES that resume command. The
-      // predicate it lands in never matched the prefix, so /loop resume
-      // answered "No held loop to resume" and the preserved iteration,
-      // best value, and history were unreachable without re-drafting.
-      !!r?.startsWith("stopped: automatic zero-stream abort") ||
-      // v0.38.27 (ported from Bjynt's PR #46): /loop pause is a soft-hold
-      // parallel to /goal pause. The loop stays resumable; finishLoopGit
-      // was skipped, so resume picks up iteration/best/history verbatim.
-      !!r?.startsWith("paused by user (/loop pause)");
     if (stored && !stored.active && RESUMABLE_STOP(stored.stopReason)) {
       // Branch-mode stop returns HEAD to originalBranch. Refuse a resume from
       // there rather than letting the next tick commit loop work to the
@@ -1202,10 +1206,25 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
     // queues the operator's suggestion into the next iteration's prompt.
     // ("polish" accepted as an alias: the widget footer advertised it
     // before the command existed — now it does.)
-    if (!isLoopActive()) {
+    // Field 2026-09-16 (loop sweep): a resumable-held loop is refinable —
+    // the hint rides the next iteration whenever it resumes. A dead loop
+    // (user stop/finish/maxed) stays refused with the honest fresh-start
+    // path; queuing onto it would promise a prompt that never comes.
+    const stored = state.loop;
+    if (!stored) {
       ctx.ui.notify("No active loop to refine — /loop start first.", "warning");
       return;
     }
+    if (!stored.active && !RESUMABLE_STOP(stored.stopReason)) {
+      // A broken measure is fixed from the agent side, not by restarting:
+      // point there instead of at a fresh start.
+      if (stored.stopReason?.startsWith("measure command broken —")) {
+        ctx.ui.notify("That loop stopped on a broken measure — the hint was not queued. Have the agent repair it via propose_loop_refine (it test-runs the new measure), then /loop resume.", "warning");
+        return;
+      }
+      ctx.ui.notify(`That loop ended (${stored.stopReason ?? "stopped"}) — the hint was not queued. /loop start begins a fresh run.`, "warning");
+      return;
+    }
     const hint = rest.trim();
     if (!hint) {
       ctx.ui.notify("Usage: /loop refine <what the spec should capture better> — the suggestion rides the next iteration's prompt; the agent proposes via propose_loop_refine and you confirm.", "info");
@@ -1214,6 +1233,13 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
     state.loop!.refineHint = hint.slice(0, 300);
     persistState(ctx);
     appendLedger(ctx.cwd, "loop_refine_hint", { iteration: state.loop!.iteration, hint: state.loop!.refineHint });
+    if (!stored.active) {
+      // Refine-and-resume (owner choice): the hint is queued first, then
+      // the byte-identical resume path runs — wrong-branch and active-goal
+      // guards keep their voices and the loop stays held when they fire.
+      ctx.ui.notify("Refine hint queued — it rides the next iteration's prompt. Resuming the held loop now.", "info");
+      return cmdLoop("resume", ctx);
+    }
     ctx.ui.notify("Refine hint queued — it rides the next iteration's prompt.", "info");
     return;
   }

package/extensions/loops/goal-tools.ts

@@ -524,6 +524,8 @@ function registerAgentTools(pi: any): void {
           "Outcome: <what was delivered> · Changed: <files/behavior/decision> · Evidence: <key commit/report/result> · " +
           "Tests: <bounded commands + pass/fail, or `not run — <reason>`> · Unresolved: <remaining risk, or `none`> · " +
           "Next: <one follow-up hint, or `none`>. " +
+          "A section-structured Outcome (##/### headers) renders in full as the card Summary section — " +
+          "structure is the price of length. " +
           "See audit/COMPLETION-SUMMARY-POLICY-2026-08-19.md and docs/DESIGN-long-running-supervision.md. Free-form prose is allowed but discouraged; incomplete input receives a recorded-facts-only fallback at terminalization.",
       })),
       verificationSummary: Type.Optional(Type.String({

package/extensions/start-context.ts

@@ -297,3 +297,44 @@ export function inferStartFromSession(sessionManager: unknown): StartContextInfe
     currentPromptTruncated: window.currentPromptTruncated,
   });
 }
+
+/** Acknowledgment openers: the user is responding to a proposal, not
+ * stating an objective. `\b` keeps "goals"/"going" out. */
+const ACK_PREFIX_RE = /^(?:ok(?:ay)?|yes|yeah|yep|sure|go|fine|great|perfect|thanks?|thank\s+you)\b[\s,—–-]*/i;
+
+/** Field 2026-09-16 (VidPro ledger: `/goal tweak` adopted "ok adjsut it"
+ * as the objective): chatter is an acknowledgment / pronoun / bare vague
+ * action — possibly behind an ack opener ("ok adjust it") — never a
+ * self-contained objective. Deliberately NOT length-based: short-but-real
+ * objectives ("fix typo in X") pass through untouched. Questions pass
+ * through too — only the acknowledgment shapes divert. */
+export function isChatterReplacement(text: string): boolean {
+  const clean = normalizeWhitespace(text ?? "");
+  if (!clean) return false;
+  if (GENERIC_REPLY_RE.test(clean) || PRONOUN_ONLY_RE.test(clean) || VAGUE_ACTION_RE.test(clean)) return true;
+  const stripped = clean.replace(ACK_PREFIX_RE, "").trim();
+  if (stripped !== clean) return stripped ? classifyCandidate(stripped) !== "clear" : true;
+  return false;
+}
+
+export type TweakReplacement =
+  | { kind: "verbatim" }
+  | { kind: "inferred"; text: string; source: "current-prompt" | "recent-context" }
+  | { kind: "unresolvable"; reason: "ambiguous" | "none"; candidates: string[] };
+
+/** Resolve a tweak/update replacement against what was actually discussed.
+ * Self-contained text is adopted verbatim (today's path, byte-identical).
+ * Chatter ("go fix it", "ok adjsut it") resolves via the session
+ * context into the discussed objective — the user pointed at the context,
+ * so the context supplies the words. When nothing clear was discussed,
+ * the caller guides instead of adopting garbage: raw chatter must never
+ * land in the ledger as an objective again. */
+export function resolveTweakReplacement(raw: string, sessionManager: unknown): TweakReplacement {
+  if (!isChatterReplacement(raw)) return { kind: "verbatim" };
+  const inference = inferStartFromSession(sessionManager);
+  if (inference.kind === "clear") return { kind: "inferred", text: inference.objective, source: inference.source };
+  if (inference.kind === "ambiguous") {
+    return { kind: "unresolvable", reason: "ambiguous", candidates: inference.candidates };
+  }
+  return { kind: "unresolvable", reason: "none", candidates: [] };
+}

package/package.json

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