pi-goal-list-loop-audit 0.28.26 → 0.28.28

package/README.md

@@ -39,6 +39,7 @@ Five top-level commands — `/goal`, `/list`, `/loop`, `/glla`, `/review`:
 /goal resume                       # resume
 /goal cancel                       # abort
 /goal decide                       # re-open the decision picker (v0.28.23)
+/goal audit                        # run the isolated auditor on the current goal now — no agent turn (v0.28.27)
 /goal tweak "<new objective>"      # edit in place (Confirm dialog)
 /goal archive                      # archived goals, newest first
 /glla                               # settings UI table · /glla key=value · /glla stats · /glla audits [N|full] · /glla postaudit · /glla autoaccept=on

package/extensions/goal-loop-core.ts

@@ -185,6 +185,10 @@ export interface Goal {
    * the retry resolves. Only consumed while paused with an "auditor quota:"
    * reason, so a stale value is unreachable by construction. */
   pendingCompletion?: { completionSummary?: string; verificationSummary?: string; at: string };
+  /** v0.28.28: provenance — who created this goal ("user", "list-cascade",
+   * "draft-confirmed", "draft-autoaccepted"). Ledgered on goal_created so
+   * "where did this come from" is answerable after the fact. */
+  createdVia?: string;
   /** v0.25.0 (contract item 22): auditor objections extracted as TODOs when
    * aggressiveMode keeps the goal active past the disapproval cap. Rendered
    * into every continuation prompt until the next audit clears them. */
@@ -212,9 +216,9 @@ export interface Goal {
 export type GoalRoute =
   | { kind: "draft" }
   | { kind: "set"; text: string }
-  | { kind: "sub"; name: "status" | "pause" | "resume" | "cancel" | "decide" | "tweak" | "archive" | "start"; rest: string };
+  | { kind: "sub"; name: "status" | "pause" | "resume" | "cancel" | "decide" | "audit" | "tweak" | "archive" | "start"; rest: string };
 
-const GOAL_EXACT_SUBS = new Set(["status", "pause", "resume", "cancel", "decide"]);
+const GOAL_EXACT_SUBS = new Set(["status", "pause", "resume", "cancel", "decide", "audit"]);
 const GOAL_ARG_SUBS = new Set(["tweak", "archive", "start"]);
 
 export function routeGoalArgs(raw: string): GoalRoute {

package/extensions/loops/goal.ts

@@ -568,6 +568,12 @@ function heartbeatTick(): void {
   // machinery below stays quiet for 3 minutes while the replaced session
   // settles (latch watchdog, wedge alert, refire counting all resume after).
   if (Date.now() < compactionGraceUntil) return;
+  // v0.28.27: a stale (session-replaced) handle can never land a send —
+  // the terminal warning already fired once. ALL stall machinery stays
+  // quiet from here on: refiring into a dead process is misleading, and
+  // worse, the stall escalation would PAUSE the goal — silently cancelling
+  // the interruptedAt → auto-resume-on-restart promise the footer shows.
+  if (extensionApiStale) return;
   // v0.26.5: pending-latch watchdog — a queued continuation whose turn
   // trigger was dropped (field-observed post-compaction: continuation
   // ACCEPTED at compact+0s, then 22 minutes of silence). The stuck latch
@@ -889,18 +895,19 @@ function notifyPersistenceState(ctx: ExtensionContext): void {
   }
 }
 
-function setGoal(goal: Goal, ctx: ExtensionContext): void {
+function setGoal(goal: Goal, ctx: ExtensionContext, via = "user"): void {
   // v0.28.14: never silently orphan a live goal — a paused/active goal
   // being replaced is archived honestly first (the old behavior left it in
   // goals/ but untracked: "older goals lying around leading to confusion").
   if (state.goal && state.goal.id !== goal.id && (state.goal.status === "active" || state.goal.status === "paused")) {
     archiveCurrentGoal(ctx, "aborted", `replaced by goal ${goal.id}`);
   }
+  goal.createdVia = via; // v0.28.28: provenance — answerable from the ledger + /glla log
   state = { ...state, goal }; // preserve list AND loop (v0.28.14: the bare reconstruction used to nuke a held/active loop whenever a goal was set)
   const file = writeGoalMd(ctx.cwd, goal);
   state.goal!.activePath = path.relative(ctx.cwd, file) || file;
   persistState(ctx);
-  appendLedger(ctx.cwd, "goal_created", { goalId: goal.id, objective: goal.objective, policy: goal.policy });
+  appendLedger(ctx.cwd, "goal_created", { goalId: goal.id, objective: goal.objective, policy: goal.policy, via });
 }
 
 function updateGoal(patch: Partial<Goal>, ctx: ExtensionContext): void {
@@ -963,15 +970,17 @@ function archiveCurrentGoal(ctx: ExtensionContext, status: Status, stopReason?:
  * infra) → hand back to the agent: resume active + continuation, verdict
  * durable in auditHistory.
  */
-async function retryStoredCompletionAudit(ctx: ExtensionContext): Promise<void> {
+async function retryStoredCompletionAudit(ctx: ExtensionContext, origin: "quota-retry" | "manual" = "quota-retry"): Promise<void> {
   const goal = state.goal;
   if (!goal?.pendingCompletion) return;
   if (completionAuditInFlight) return;
   const liveCtx = freshCtx() ?? ctx;
   const claim = goal.pendingCompletion;
   updateGoal({ status: "auditing" }, liveCtx);
-  appendLedger(liveCtx.cwd, "goal_resumed", { via: "quota-retry-direct-audit" });
-  liveCtx.ui.notify("Auditor quota window elapsed — retrying the audit with your stored completion claim (no agent turn needed).", "info");
+  appendLedger(liveCtx.cwd, "goal_resumed", { via: origin === "manual" ? "manual-audit" : "quota-retry-direct-audit" });
+  liveCtx.ui.notify(origin === "manual"
+    ? "Manual /goal audit — running the isolated auditor now (no agent turn needed)."
+    : "Auditor quota window elapsed — retrying the audit with your stored completion claim (no agent turn needed).", "info");
   const settings = loadSettings(liveCtx.cwd);
   const { model: auditorModel, error: modelError, via } = resolveAuditorModel(liveCtx, settings.auditorModel);
   if (modelError) liveCtx.ui.notify(`Auditor model issue: ${modelError}`, "warning");
@@ -1027,9 +1036,9 @@ async function retryStoredCompletionAudit(ctx: ExtensionContext): Promise<void>
   if (result.approved) {
     updateGoal({ auditHistory: history, pendingCompletion: undefined }, liveCtx);
     const objective = state.goal.objective;
-    archiveCurrentGoal(liveCtx, "complete", `auditor ${result.model} approved (quota-retry)`);
-    liveCtx.ui.notify(`Goal complete — auditor ${result.model} approved on the quota retry.`, "info");
-    notifyExternal(liveCtx, `Goal complete (auditor approved on quota-retry): ${objective.slice(0, 120)}`);
+    archiveCurrentGoal(liveCtx, "complete", `auditor ${result.model} approved (${origin})`);
+    liveCtx.ui.notify(`Goal complete — auditor ${result.model} approved${origin === "manual" ? " on /goal audit" : " on the quota retry"}.`, "info");
+    notifyExternal(liveCtx, `Goal complete (auditor approved, ${origin}): ${objective.slice(0, 120)}`);
     return;
   }
 
@@ -1051,7 +1060,7 @@ async function retryStoredCompletionAudit(ctx: ExtensionContext): Promise<void>
     liveCtx.ui.notify(`Auditor still quota-limited — next auto-retry in ${retryMin}m (your completion claim is stored; no action needed).`, "warning");
     scheduleQuotaRetry(liveCtx, quota.retryAfterSec, result.error, () => {
       if (state.goal && state.goal.status === "paused" && (state.goal.pauseReason ?? "").startsWith("auditor quota:") && state.goal.pendingCompletion) {
-        void retryStoredCompletionAudit(liveCtx);
+        void retryStoredCompletionAudit(liveCtx, origin);
       }
     });
     return;
@@ -1072,10 +1081,10 @@ async function retryStoredCompletionAudit(ctx: ExtensionContext): Promise<void>
   }, liveCtx);
   liveCtx.ui.notify(
     result.disapproved
-      ? `Auditor (quota-retry) DISAPPROVED — resuming; the report is in /goal status.`
+      ? `Auditor (${origin}) DISAPPROVED — resuming; the report is in /goal status.`
       : result.impossible
-        ? `Auditor (quota-retry): goal IMPOSSIBLE — ${(result.impossibleReason ?? "").slice(0, 100)}. Resuming; consider /goal tweak.`
-        : `Auditor (quota-retry) hit an infrastructure error — resuming; re-call complete_goal when ready.`,
+        ? `Auditor (${origin}): goal IMPOSSIBLE — ${(result.impossibleReason ?? "").slice(0, 100)}. Resuming; consider /goal tweak.`
+        : `Auditor (${origin}) hit an infrastructure error — resuming; re-call complete_goal when ready.`,
     "warning",
   );
   appendLedger(liveCtx.cwd, "quota_retry_audit_verdict", {
@@ -1134,7 +1143,7 @@ function fireReviewer(
       manual: opts.manual,
       ledgerEntries,
       sources,
-      enqueueListItems: (objectives) => enqueueItems(ctx, objectives, "reviewer"),
+      enqueueListItems: (objectives) => enqueueItems(ctx, objectives, "reviewer", { autoActivate: loadSettings(ctx.cwd).autoResume === true }),
       proposeGoal: (objective, reason) => {
         try {
           extensionApi?.sendUserMessage(
@@ -1204,7 +1213,7 @@ function activateNextListItem(ctx: ExtensionContext, n = 1): boolean {
   state = { ...state, list: rest };
   const goal = createGoal(next.objective, ctx, "list");
   if (next.verificationContract) goal.verificationContract = next.verificationContract;
-  setGoal(goal, ctx);
+  setGoal(goal, ctx, "list-cascade");
   iterationCounter = 0;
   consecutiveErrorIterations = 0;
   consecutiveAbortIterations = 0;
@@ -1309,6 +1318,30 @@ async function cmdGoal(args: string, ctx: ExtensionContext): Promise<void> {
       if (!shown) ctx.ui.notify("No pending decision — the goal isn't paused on a choice (or no UI).", "info");
       return;
     }
+    // v0.28.27: /goal audit — run the isolated auditor on the current goal
+    // RIGHT NOW, without engaging the agent. The user's "the work looks
+    // done — just verify it" handle (and the manual counterpart of the
+    // v0.28.26 stored-claim quota retry). Seeds a synthesized claim so a
+    // quota block falls into the same pendingCompletion retry machinery.
+    if (route.name === "audit") {
+      if (!state.goal) {
+        ctx.ui.notify("No active goal — /goal audit needs a goal to verify.", "warning");
+        return;
+      }
+      if (completionAuditInFlight) {
+        ctx.ui.notify("An audit is already running…", "info");
+        return;
+      }
+      updateGoal({
+        pendingCompletion: {
+          completionSummary: "Manual audit requested by the user via /goal audit (no agent completion claim). Verify the objective against the repo directly.",
+          at: nowIso(),
+        },
+      }, ctx);
+      appendLedger(ctx.cwd, "manual_audit_requested", { goalId: state.goal.id });
+      void retryStoredCompletionAudit(ctx, "manual");
+      return;
+    }
     if (route.name === "tweak") return cmdTweak(route.rest, ctx);
     if (route.name === "archive") return cmdGoals(ctx);
     // v0.16.0: /goal start <objective> — explicit skip-draft. Activates
@@ -1599,7 +1632,7 @@ async function cmdTweak(args: string, ctx: ExtensionContext): Promise<void> {
  * contract extraction) → appended to the queue → persisted → first item
  * activated when nothing is running. Returns the count enqueued.
  */
-function enqueueItems(ctx: ExtensionContext, texts: string[], source: string): number {
+function enqueueItems(ctx: ExtensionContext, texts: string[], source: string, opts?: { autoActivate?: boolean }): number {
   const items = texts.map((text) => {
     const extracted = extractVerificationContract(text);
     return { id: newGoalId(), objective: extracted.objective, verificationContract: extracted.verificationContract || undefined, addedAt: nowIso() };
@@ -1608,7 +1641,16 @@ function enqueueItems(ctx: ExtensionContext, texts: string[], source: string): n
   persistState(ctx);
   appendLedger(ctx.cwd, "list_imported", { source, count: items.length });
   if (!state.goal || state.goal.status === "complete" || state.goal.status === "aborted") {
-    activateNextListItem(ctx);
+    // v0.28.28: unsolicited sources (the reviewer) do NOT auto-start the
+    // head unless autoResume is on — "I cancelled a goal and the next one
+    // started itself" was the field complaint. User-driven imports keep
+    // the immediate-start behavior (opts default true).
+    if (opts?.autoActivate === false) {
+      ctx.ui.notify(`Queued ${items.length} item(s) from ${source} — /list next when ready (auto-start is opt-in: /glla autoresume=on).`, "info");
+      appendLedger(ctx.cwd, "list_autoactivation_held", { source, count: items.length });
+    } else {
+      activateNextListItem(ctx);
+    }
   }
   return items.length;
 }
@@ -3135,13 +3177,34 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         persistState(liveCtx);
         appendLedger(liveCtx.cwd, "list_added", { id: item.id, objective: item.objective, drafted: true });
         if (!state.goal || state.goal.status === "complete" || state.goal.status === "aborted") {
+          // v0.28.28: an AUTO-ACCEPTED draft does not auto-start unless
+          // autoResume is on — accepting a draft is not consent to start.
+          if (autoAccept && loadSettings(liveCtx.cwd).autoResume !== true) {
+            liveCtx.ui.notify(`Auto-accepted and QUEUED (autoResume off — not auto-started): ${extracted.objective.slice(0, 80)} — /list next when ready.`, "info");
+            appendLedger(liveCtx.cwd, "list_autoactivation_held", { source: "draft-autoaccepted", count: 1 });
+            return { content: [{ type: "text", text: "Draft accepted and added to the list, but NOT started (the user's autoResume setting is off — auto-accepted drafts queue, they don't auto-start). Do NOT begin work. Tell the user: /list next starts it." }], details: {} };
+          }
           activateNextListItem(liveCtx);
           return { content: [{ type: "text", text: "Confirmed and activated (list was empty). Begin work now." }], details: {} };
         }
         return { content: [{ type: "text", text: `Confirmed and added to the list (${listQueue().length} waiting). It activates when the current goal completes.` }], details: {} };
       }
       const goal = createGoal(full, liveCtx);
-      setGoal(goal, liveCtx);
+      setGoal(goal, liveCtx, autoAccept ? "draft-autoaccepted" : "draft-confirmed");
+      // v0.28.28: auto-accepted goal drafts are created HELD when autoResume
+      // is off — auto-accept delegates the Confirm click, not the decision
+      // to start. Explicit user-confirmed drafts still start immediately.
+      if (autoAccept && loadSettings(liveCtx.cwd).autoResume !== true) {
+        updateGoal({
+          status: "paused",
+          pauseKind: "blocked",
+          pauseReason: "auto-accepted draft — held for the user's go-ahead (autoResume off)",
+          pauseSuggestedAction: "/goal resume to start · /goal cancel to drop · /glla autoresume=on starts auto-accepted drafts automatically",
+        }, liveCtx);
+        appendLedger(liveCtx.cwd, "draft_held", { goalId: goal.id, reason: "autoaccept-autoresume-off" });
+        liveCtx.ui.notify(`Draft auto-accepted and HELD (autoResume off): ${goal.objective.slice(0, 80)} — /goal resume to start, /goal cancel to drop.`, "info");
+        return { content: [{ type: "text", text: "Goal accepted but HELD (the user's autoResume setting is off — auto-accepted drafts do not auto-start). Do NOT begin work. Tell the user: /goal resume starts it, /goal cancel drops it." }], details: {} };
+      }
       iterationCounter = 0;
       consecutiveErrorIterations = 0;
       consecutiveAbortIterations = 0;
@@ -4053,6 +4116,42 @@ function cmdStats(args: string, ctx: ExtensionContext): void {
  * log (.pi-glla/audits.jsonl). Default: last 10 verdicts, one line each.
  * "full" prints the latest report in full.
  */
+/**
+ * v0.28.28: /glla log [N] — human-readable tail of the event ledger (the
+ * forensic trail: who created/resumed/paused goals, from where). Skips the
+ * high-frequency noise entries (state snapshots, re-arm internals) unless
+ * "all" is passed. N defaults to 15.
+ */
+const LOG_NOISE = new Set(["state", "send_rearm_start", "heartbeat_suppressed_tick"]);
+function cmdLog(args: string, ctx: ExtensionContext): void {
+  const all = /\ball\b/.test(args);
+  const nMatch = args.match(/\b(\d+)\b/);
+  const n = Math.min(Math.max(parseInt(nMatch?.[1] ?? "15", 10) || 15, 1), 100);
+  let entries: Array<{ type: string; at?: string; value?: any }> = [];
+  try {
+    entries = parseLedgerEntries(fs.readFileSync(ledgerPath(ctx.cwd), "utf-8"));
+  } catch {
+    ctx.ui.notify("No ledger yet — .pi-glla/active.jsonl doesn't exist.", "info");
+    return;
+  }
+  const visible = all ? entries : entries.filter((e) => !LOG_NOISE.has(e.type));
+  const tail = visible.slice(-n);
+  if (tail.length === 0) {
+    ctx.ui.notify("Ledger is empty (no non-noise events yet).", "info");
+    return;
+  }
+  const lines = tail.map((e) => {
+    const t = (e.at ?? "").slice(11, 19);
+    const v = e.value ?? {};
+    const detail = Object.entries(v)
+      .filter(([k]) => k !== "goalId" && k !== "report")
+      .map(([k, val]) => `${k}=${typeof val === "string" ? val.slice(0, 60) : JSON.stringify(val)?.slice(0, 60)}`)
+      .join(" ");
+    return `${t}  ${e.type}${detail ? `  ${detail}` : ""}`;
+  });
+  ctx.ui.notify(`Ledger tail (last ${tail.length}${all ? "" : " non-noise"} events — /glla log <N> for more, /glla log all to include noise):\n${lines.join("\n")}`, "info");
+}
+
 function cmdAudits(args: string, ctx: ExtensionContext): void {
   const full = /\bfull\b/.test(args);
   const all = /\b(?:all|global|log)\b/.test(args);
@@ -4104,6 +4203,12 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
     cmdAudits(trimmed.slice("audits".length).trim(), ctx);
     return;
   }
+  // v0.28.28: /glla log [N] — the raw event trail, human-readable. "Log it
+  // so we can look back and see where we are doing things wrong."
+  if (/^log\b/.test(trimmed)) {
+    cmdLog(trimmed.slice("log".length).trim(), ctx);
+    return;
+  }
   if (/^reviewer\b/.test(trimmed)) {
     await cmdReviewerSettings(ctx);
     return;
@@ -4494,6 +4599,7 @@ export default function (pi: ExtensionAPI): void {
       ["autoresume=", "default: hold when a session is loaded, auto-resume on reload/fork; on: always auto-resume; off: never"],
       ["decisionpopup=", "on|off: decision pauses pop the select() picker (default on; the widget card always lists the options, /goal decide reopens the picker)"],
       ["auditcap=", "N: pause goal after N consecutive auditor disapprovals (default 5, 0 = unlimited)"],
+      ["log", "event-trail tail: /glla log [N] — who created/resumed/paused what, from where (v0.28.28)"],
       ["auditfeedbackchars=", "cap on executor-visible disapproval report chars (0 = full report, the default)"],
       ["aggressivemode=", "on: keep-going defaults — autoResume, cap 10, stuck 10, wedge off, quota auto-retry, cap→TODOs"],
       ["quotaretryminutes=", "N: minutes before auto-retrying a quota-exhausted auditor (default 60)"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.28.26",
+  "version": "0.28.28",
   "description": "Goal. Loop. Audit. Done. \u2014 a pi-coding-agent extension that supervises long-running work, with isolated auditor on each completion. Beat bamboozling by design: the auditor runs in a fresh session with no extensions, no skills, no editor \u2014 only the read tools needed to verify your goal.",
   "license": "MIT",
   "author": "dracon",

package/schemas/goal.schema.json

@@ -54,6 +54,7 @@
     "interruptedReason": { "type": "string" },
     "auditInfraStreak": { "type": "number" },
     "pendingCompletion": { "type": "object" },
+    "createdVia": { "type": "string" },
     "activePath": { "type": "string" },
     "archivedPath": { "type": "string" },
     "usage": {