pi-goal-list-loop-audit 0.34.48 → 0.34.49

package/extensions/loops/goal.ts

@@ -873,6 +873,7 @@ function tryAbsorbHostSuccessor(ctx: ExtensionContext, via: string): boolean {
   staleTerminalDone = false;
   sessionHandoffPending = false;
   sessionGeneration++; // a dead generation's delayed callbacks must not fire into the new owner
+  clearDraftingState(); // the old interview belongs to the disposed generation
   appendLedger(ctx.cwd, "session_rebind_via_live_ctx", { via, generation: sessionGeneration });
   if (interruptedAudit) {
     // The old generation's detached worker/result handler is now stale. Do
@@ -982,6 +983,19 @@ let draftingUserReplies = 0;
 let draftingBlockedProposals = 0; // v0.15.1: stuck-gate escape hatch
 let draftingSeedInFlight = false;
 
+/** Drafting is ephemeral session state, not durable goal/list state. A stale
+ * seed or an in-flight Confirm must never leave the next MAIN session behind
+ * the old interview gate. */
+function clearDraftingState(): void {
+  draftingTarget = null;
+  draftingUserReplies = 0;
+  draftingBlockedProposals = 0;
+  draftingSeedInFlight = false;
+}
+
+const DRAFT_SESSION_INTERRUPTED_MESSAGE =
+  "The drafting flow was interrupted by a pi session replacement. This is NOT a rejection — do not refine or re-propose from the old turn. Wait for a fresh session_start, then run the drafting command again.";
+
 // Dedup set for token accounting (agent_end may replay seen messages).
 const countedTokenMessages = new Set<string>();
 const countedLoopTokenMessages = new Set<string>();
@@ -3580,7 +3594,14 @@ function activateNextListItem(ctx: ExtensionContext, n = 1): boolean {
 // Drafting: /goal with no args → clarify → Confirm dialog → activate
 // =================================================================
 
-async function startDrafting(ctx: ExtensionContext, target: "goal" | "list" | "loop", seed?: string): Promise<void> {
+async function startDrafting(ctx: ExtensionContext, target: "goal" | "list" | "loop", seed?: string): Promise<boolean> {
+  // A stale/handoff-bound MAIN cannot deliver the seed. Do not leave the
+  // module in drafting mode: that orphaned gate makes later list_add and
+  // propose_goal_draft calls look like user disapprovals until restart.
+  if (sessionHandoffPending || extensionApiStale || staleTerminalDone || zombieStoodDown || probeExtensionApiStale()) {
+    clearDraftingState();
+    return false;
+  }
   draftingTarget = target;
   const prompts: Record<string, [string, string, string]> = {
     goal: ["goal-loop-draft.md", "Goal drafting", "propose_goal_draft"],
@@ -3594,12 +3615,6 @@ async function startDrafting(ctx: ExtensionContext, target: "goal" | "list" | "l
       : 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>.`;
-  ctx.ui.notify(
-    seed
-      ? seededHint
-      : `${label} started. The agent will grill until the contract is concrete, then ${tool} opens a Confirm dialog. No work begins before confirmation.`,
-    "info",
-  );
   const tmplPath = path.resolve(__dirname, "..", "..", "prompts", file);
   let tmpl: string;
   try {
@@ -3634,12 +3649,30 @@ async function startDrafting(ctx: ExtensionContext, target: "goal" | "list" | "l
     }
   }
   try {
-    safeSteerUser(ctx, tmpl);
+    const wasStale = extensionApiStale;
+    const sent = safeSteerUser(ctx, tmpl);
+    if (!sent) {
+      clearDraftingState();
+      // safeSteerUser deliberately catches stale API errors, so its caller
+      // must handle a false result explicitly rather than relying on catch.
+      if (extensionApiStale && !wasStale) {
+        appendLedger(ctx.cwd, "extension_api_stale", { where: "startDrafting seed" });
+        ctx.ui.notify("glla: can't start the drafting interview — this session's extension handle is stale (pi session replacement). A fresh session_start will rebind it; if no replacement arrives, restart pi normally, then re-run the command.", "warning");
+      }
+      return false;
+    }
+    ctx.ui.notify(
+      seed
+        ? seededHint
+        : `${label} started. The agent will grill until the contract is concrete, then ${tool} opens a Confirm dialog. No work begins before confirmation.`,
+      "info",
+    );
     draftingUserReplies = 0;
     draftingBlockedProposals = 0;
     draftingSeedInFlight = true; // our injected prompt also arrives as a user message — don't count it
+    return true;
   } catch (err) {
-    draftingTarget = null;
+    clearDraftingState();
     // v0.28.1 (E6): the seed send used to fail SILENTLY — the user pressed
     // Enter on /goal and nothing happened. Now: loud, and stale handles get
     // the honest restart guidance.
@@ -3650,6 +3683,7 @@ async function startDrafting(ctx: ExtensionContext, target: "goal" | "list" | "l
     } else {
       ctx.ui.notify(`glla: couldn't start the drafting interview (${err instanceof Error ? err.message : String(err)}) — try again.`, "warning");
     }
+    return false;
   }
 }
 
@@ -3748,6 +3782,9 @@ async function cmdSet(args: string, ctx: ExtensionContext, skipDraft = false): P
     raw = raw.slice(1, -1).trim();
   }
   if (!raw) {
+    // A stale MAIN cannot deliver the interview seed. Do not create an
+    // orphaned drafting gate after the entry warning has fired.
+    if (staleEntry) return;
     await startDrafting(ctx, "goal");
     return;
   }
@@ -3760,6 +3797,7 @@ async function cmdSet(args: string, ctx: ExtensionContext, skipDraft = false): P
   // Include an explicit "Done when: …" clause to activate instantly.
   // v0.16.0: /goal start bypasses this by explicit user command.
   if (!skipDraft && goalArgsNeedDrafting(raw)) {
+    if (staleEntry) return;
     await startDrafting(ctx, "goal", raw);
     return;
   }
@@ -6115,7 +6153,7 @@ function registerAgentTools(pi: any): void {
       const foreign2 = foreignToolGuard(execCtx);
       if (foreign2) return { content: [{ type: "text", text: foreign2 }], details: {} };
       const p = params as { objective: string; verificationContract?: string; items?: string[] };
-      const liveCtx = currentToolContext(execCtx);
+      let liveCtx = currentToolContext(execCtx);
       if (!liveCtx) return staleToolResult();
       if (draftingTarget !== "goal" && draftingTarget !== "list") {
         return {
@@ -6123,6 +6161,14 @@ function registerAgentTools(pi: any): void {
           details: {},
         };
       }
+      const draftGeneration = sessionGeneration;
+      const staleDraftEntry = draftingTarget === "list"
+        ? warnIfStaleAtEntry(liveCtx, "list drafting")
+        : warnIfStaleAtEntry(liveCtx, "goal drafting");
+      if (staleDraftEntry) {
+        clearDraftingState();
+        return { content: [{ type: "text", text: DRAFT_SESSION_INTERRUPTED_MESSAGE }], details: {} };
+      }
       // v0.28.14: one-active-thing EARLY guard — refuse the whole interview
       // when a loop is live (the post-confirm backstop below stays: state
       // can change mid-interview).
@@ -6148,8 +6194,6 @@ function registerAgentTools(pi: any): void {
           details: {},
         };
       }
-      // v0.28.1 (S3): honest staleness warning before any Confirm attempt.
-      warnIfStaleAtEntry(liveCtx, "goal drafting");
       // Multi-item list draft: one Confirm for the whole batch.
       if (p.items && p.items.length > 0) {
         // v0.23.7: show ALL items in full — the user approves the whole
@@ -6167,9 +6211,16 @@ function registerAgentTools(pi: any): void {
             "Confirm list batch",
             `${p.items.length} items:\n${preview}${batchActivates ? "\n\n(List is empty — confirming ACTIVATES item 1 immediately as the active goal.)" : ""}`,
           );
+          const afterConfirm = freshCtxForGeneration(draftGeneration);
+          if (!afterConfirm) {
+            clearDraftingState();
+            return { content: [{ type: "text", text: DRAFT_SESSION_INTERRUPTED_MESSAGE }], details: {} };
+          }
+          liveCtx = afterConfirm;
           if (c === "stale") {
             // v0.28.1 (T1): a stale dialog is NOT a rejection — nothing was
             // refused; the dialog simply can't render in a doomed process.
+            clearDraftingState();
             extensionApiStale = true;
             appendLedger(liveCtx.cwd, "extension_api_stale", { where: "batch confirm" });
             return { content: [{ type: "text", text: "The Confirm dialog could not render: pi invalidated this session's extension handle (session replacement). This is NOT a rejection — do NOT refine or re-propose. Wait for a fresh session_start, then re-run the drafting flow." }], details: {} };
@@ -6212,8 +6263,15 @@ function registerAgentTools(pi: any): void {
         appendLedger(liveCtx.cwd, "draft_autoaccepted", { kind: isListDraft ? "list" : "goal", objective: p.objective.trim().slice(0, 200) });
       } else {
         const c = await confirmDraft(liveCtx, isListDraft ? "Confirm list item" : "Confirm goal", `${sanitizeDisplayText(p.objective.trim())}${sanitizeDisplayText(contractBlock)}${activationNote}`);
+        const afterConfirm = freshCtxForGeneration(draftGeneration);
+        if (!afterConfirm) {
+          clearDraftingState();
+          return { content: [{ type: "text", text: DRAFT_SESSION_INTERRUPTED_MESSAGE }], details: {} };
+        }
+        liveCtx = afterConfirm;
         if (c === "stale") {
           // v0.28.1 (T1): a stale dialog is NOT "Draft rejected by the user".
+          clearDraftingState();
           extensionApiStale = true;
           appendLedger(liveCtx.cwd, "extension_api_stale", { where: "draft confirm" });
           return { content: [{ type: "text", text: "The Confirm dialog could not render: pi invalidated this session's extension handle (session replacement). This is NOT a rejection — do NOT refine or re-propose. Wait for a fresh session_start, then re-run the drafting flow." }], details: {} };
@@ -6307,6 +6365,10 @@ function registerAgentTools(pi: any): void {
       const p = params as { target: string; measureCmd?: string; direction?: "min" | "max"; window?: number; max?: number; time?: number; tokens?: number; branch?: boolean };
       const liveCtx = currentToolContext(execCtx);
       if (!liveCtx) return staleToolResult();
+      if (warnIfStaleAtEntry(liveCtx, "loop drafting")) {
+        clearDraftingState();
+        return { content: [{ type: "text", text: DRAFT_SESSION_INTERRUPTED_MESSAGE }], details: {} };
+      }
       if (draftingTarget !== "loop") {
         return {
           content: [{ type: "text", text: "You cannot start or draft a loop — only the user can, from the slash bar (the Confirm is the product). Do NOT write draft files or wait for the user to say 'start' in chat; that dead-ends. Instead hand the user the exact command: /loop start \"<target>\" (bare = infinite metricless; add measure=\"<cmd>\" direction=min|max for a metric loop), or /loop respec to reconcile against the root spec, or /loop with no args to draft interactively." }],
@@ -8160,6 +8222,7 @@ export default function (pi: ExtensionAPI): void {
     markSessionOwnerShutdown(ctx.cwd, shutdownReason);
     writeSessionHandoff(ctx, shutdownReason);
     sessionReplacementUntil = Date.now() + SESSION_REBIND_GRACE_MS;
+    clearDraftingState();
     clearSessionOwnedTimers();
     toolsRegistered = false;
     toolHealNotified = false;
@@ -8208,6 +8271,7 @@ export default function (pi: ExtensionAPI): void {
     deadOwnerSession = null; // v0.34.25: a real session_start supersedes the silent-swap record
     deadOwnerCwd = null;
     sessionGeneration++;
+    clearDraftingState();
     // An auditor belonging to the disposed generation cannot block the fresh
     // session's recovery gate; its finally block is generation-guarded too.
     completionAuditInFlight = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.34.48",
+  "version": "0.34.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": "MIT",
   "author": "dracon",

package/scripts/goal-auditor-worker.mjs

@@ -109,12 +109,29 @@ function toolArgsPrefix(args) {
   }
 }
 
-function appendRecentOutput(recentOutput, text) {
-  for (const raw of text.split("\n")) {
-    if (!raw) continue;
-    recentOutput.push(raw.length <= MAX_RECENT_OUTPUT_ITEM_CHARS
-      ? raw
-      : `${raw.slice(0, MAX_RECENT_OUTPUT_ITEM_CHARS - 1)}…`);
+function appendRecentOutput(recentOutput, reportLine, text, flush = false) {
+  // text_delta fragments are arbitrary provider chunks, not logical lines.
+  // Assemble them exactly like MAIN's cumulative assistant renderer; treating
+  // each fragment as a line made the HUD show one word or punctuation mark at
+  // a time (for example, `Audit summary` followed by `:`). The exact audit
+  // result remains in outputParts and is deliberately unaffected by this
+  // bounded display telemetry.
+  const combined = `${reportLine.value}${text}`;
+  const parts = combined.split("\n");
+  reportLine.value = parts.pop() ?? "";
+  for (const raw of parts) {
+    const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+    if (!line) continue;
+    recentOutput.push(line.length <= MAX_RECENT_OUTPUT_ITEM_CHARS
+      ? line
+      : `${line.slice(0, MAX_RECENT_OUTPUT_ITEM_CHARS - 1)}…`);
+  }
+  if (flush && reportLine.value) {
+    const line = reportLine.value;
+    recentOutput.push(line.length <= MAX_RECENT_OUTPUT_ITEM_CHARS
+      ? line
+      : `${line.slice(0, MAX_RECENT_OUTPUT_ITEM_CHARS - 1)}…`);
+    reportLine.value = "";
   }
   while (recentOutput.length > MAX_RECENT_OUTPUT_ITEMS) recentOutput.shift();
 }
@@ -134,6 +151,7 @@ async function main() {
   const toolCalls = [];
   const recentOutput = [];
   const outputParts = [];
+  const recentReportLine = { value: "" };
   const activeTools = new Map();
   let currentTool;
   let currentToolArgs;
@@ -172,7 +190,12 @@ async function main() {
       phase,
       elapsedMs: Date.now() - startedAt,
       ...(lastActivityAt !== undefined ? { lastActivityAt } : {}),
-      recentOutput: recentOutput.slice(-MAX_RECENT_OUTPUT_ITEMS),
+      recentOutput: [
+        ...recentOutput.slice(-MAX_RECENT_OUTPUT_ITEMS),
+        ...(recentReportLine.value ? [recentReportLine.value.length <= MAX_RECENT_OUTPUT_ITEM_CHARS
+          ? recentReportLine.value
+          : `${recentReportLine.value.slice(0, MAX_RECENT_OUTPUT_ITEM_CHARS - 1)}…`] : []),
+      ].slice(-MAX_RECENT_OUTPUT_ITEMS),
       toolCalls: toolCalls.slice(-MAX_TOOL_CALLS),
       ...(currentTool ? { currentTool } : {}),
       ...(currentToolArgs ? { currentToolArgs } : {}),
@@ -187,6 +210,9 @@ async function main() {
   const finish = async (ok, error = "") => {
     if (finalized) return;
     finalized = true;
+    // Preserve a final unterminated report line in the last progress snapshot
+    // without changing the exact result output used for verdict parsing.
+    appendRecentOutput(recentOutput, recentReportLine, "", true);
     if (deadlineTimer) clearTimeout(deadlineTimer);
     if (inactivityTimer) clearInterval(inactivityTimer);
     if (pi && pi.exitCode === null) pi.kill("SIGTERM");
@@ -313,7 +339,7 @@ async function main() {
       if (event.type === "message_update") {
         if (update?.type === "text_delta" && typeof update.delta === "string") {
           outputParts.push(update.delta);
-          appendRecentOutput(recentOutput, update.delta);
+          appendRecentOutput(recentOutput, recentReportLine, update.delta);
           void progress(phase).catch(() => {});
         } else {
           void progress("thinking").catch(() => {});