pi-goal-list-loop-audit 0.38.43 → 0.38.44

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.38.44 — stale-version surfacing: running version in the status line (2026-09-10)
+
+### Fixed
+
+- **Stale-session visibility (field 20260909_161057):** a live session rendered the pre-0.38.39 summary voice while the repo shipped 0.38.42 with nothing visible saying so. The status line now always carries the running version (`glla: … · v0.38.44`) on every branch; when the registry is ahead it nudges (`· update vX available`).
+- **Cached staleness check:** new `extensions/glla-update-check.ts` — the render reads the `.pi-glla/update-check.json` sidecar only and never touches the network; a throttled (24h TTL) fire-and-forget `npm view` refresh rides the command/lifecycle contact gate and fails silently offline.
+- **`/glla version` names staleness:** appends `Registry latest` plus the concrete update path (`pi install npm:pi-goal-list-loop-audit@latest` then `/reload`) when the sidecar proves the session stale; legacy three lines unchanged with no cache.
+- **INSTALL.md `Updating` section:** documents the nudge, the update command, and the `/reload`-every-session requirement. Pure version/compare helpers live in `glla-version.ts` (no import cycle); the display module keeps zero runtime imports via a precomputed `versionTail` extra.
+
+### Verification
+
+- Full `release:check` 0 failures; `tsc --noEmit` clean.
+
 ## 0.38.43 — ship merged PR #50, drop orphaned helpers (2026-09-10)
 
 ### Fixed

package/INSTALL.md

@@ -29,6 +29,26 @@ GLLA loads into new pi sessions. If pi is already open, reload that session:
 /reload
 ```
 
+## Updating
+
+The status line always shows the running version (`glla: … · v0.38.44`).
+When the npm registry is ahead, it also nudges:
+
+```text
+glla: … · v0.38.43 · update v0.38.44 available
+```
+
+The nudge comes from a daily sidecar check (`.pi-glla/update-check.json`),
+refreshed on command contact and never blocking a turn. To update:
+
+```bash
+pi install npm:pi-goal-list-loop-audit@latest
+```
+
+Then `/reload` every open pi session — a session keeps running the
+version it loaded with until reloaded. `/glla version` says whether the
+current session is stale and repeats the update command.
+
 ### Recommended companions
 
 The structured-question companion is recommended for the intended drafting

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.43 continue through the supervisor freeze (`/glla pause`),
+  v0.35.14–v0.38.44 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/glla-update-check.ts

@@ -0,0 +1,106 @@
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { compareVersions, GLLA_PACKAGE_NAME, updateCheckPath } from "./glla-version.js";
+
+export { compareVersions, updateCheckPath };
+
+/**
+ * v0.38.44 (field 20260909_161057): a live session rendered the
+ * pre-0.38.39 summary voice while the repo shipped 0.38.42 — nothing
+ * visible told the session it runs old GLLA. Shipped fixes only reach
+ * sessions that know they are stale, so the status line carries the
+ * running version plus a nudge when the registry is ahead.
+ *
+ * Render discipline: the status/card render reads the sidecar cache ONLY
+ * and never touches the network. A throttled fire-and-forget refresh
+ * rides the command/lifecycle contact gate; failures (offline, slow
+ * registry, missing npm) leave the old cache in place and never surface.
+ */
+
+export const UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1_000;
+export const UPDATE_CHECK_TIMEOUT_MS = 15_000;
+
+export interface UpdateCheckCache {
+  latest: string;
+  checkedAt: number;
+}
+
+/** Read the cache; null when missing, unreadable, malformed, or future-dated. */
+export function readUpdateCheck(cwd: string): UpdateCheckCache | null {
+  try {
+    const parsed: unknown = JSON.parse(fs.readFileSync(updateCheckPath(cwd), "utf8"));
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const record = parsed as Record<string, unknown>;
+    if (typeof record.latest !== "string" || !record.latest.trim()) return null;
+    if (typeof record.checkedAt !== "number" || !Number.isFinite(record.checkedAt)) return null;
+    if (record.checkedAt > Date.now() + 60_000) return null;
+    return { latest: record.latest.trim(), checkedAt: record.checkedAt };
+  } catch {
+    return null;
+  }
+}
+
+export type SpawnFn = (
+  command: string,
+  args: string[],
+  options: { timeout: number },
+) => { on(event: "close", listener: (code: number | null) => void): void; stdout: { on(event: "data", listener: (chunk: Buffer) => void): void } };
+
+/**
+ * Throttled fire-and-forget refresh: returns immediately in every case.
+ * Skips when the cache is within TTL; otherwise shells `npm view` with a
+ * bounded timeout and rewrites the cache on success. Never throws — an
+ * offline session simply keeps rendering without a nudge.
+ */
+export function refreshUpdateCheck(
+  cwd: string,
+  now = Date.now(),
+  spawnFn: SpawnFn = spawn as unknown as SpawnFn,
+): void {
+  try {
+    const cached = readUpdateCheck(cwd);
+    if (cached && now - cached.checkedAt < UPDATE_CHECK_TTL_MS) return;
+    const child = spawnFn("npm", ["view", GLLA_PACKAGE_NAME, "version"], { timeout: UPDATE_CHECK_TIMEOUT_MS });
+    let out = "";
+    child.stdout.on("data", (chunk) => {
+      out += chunk.toString();
+      if (out.length > 256) out = out.slice(-256);
+    });
+    child.on("close", (code) => {
+      try {
+        if (code !== 0) return;
+        const latest = out.trim().split(/\s+/).pop() ?? "";
+        if (!latest) return;
+        const dir = path.dirname(updateCheckPath(cwd));
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(updateCheckPath(cwd), JSON.stringify({ latest, checkedAt: Date.now() }));
+      } catch {
+        // Cache write failure is invisible by design.
+      }
+    });
+  } catch {
+    // Spawn failure (no npm, no shell) is invisible by design.
+  }
+}
+
+/**
+ * The status-tail segment: `· v<running>` always (so the running
+ * version is visible on every branch), plus `· update v<latest>
+ * available` only when the cache proves the registry is ahead.
+ * Empty string when the running version is unknown.
+ */
+export function buildVersionTail(running: string, latest: string | null): string {
+  if (!running || running === "unknown") return "";
+  const nudge = latest ? staleUpdateNudge(running, { latest, checkedAt: 0 }) : null;
+  return `· v${running}${nudge ? ` · ${nudge}` : ""}`;
+}
+
+/** The nudge proper: null when there is nothing to say (no cache yet,
+ * unparseable versions, or already current). "unknown" running versions
+ * never nudge — a damaged manifest must not cry wolf. */
+export function staleUpdateNudge(running: string, cached: UpdateCheckCache | null): string | null {
+  if (!cached || running === "unknown") return null;
+  if (compareVersions(cached.latest, running) > 0) return `update v${cached.latest} available`;
+  return null;
+}

package/extensions/glla-version.ts

@@ -4,6 +4,28 @@ import { fileURLToPath } from "node:url";
 
 export const GLLA_PACKAGE_NAME = "pi-goal-list-loop-audit";
 
+/** Sidecar path shared with the update check (kept here so both
+ * glla-version and glla-update-check resolve it without a cycle). */
+export function updateCheckPath(cwd: string): string {
+  return path.join(cwd, ".pi-glla", "update-check.json");
+}
+
+/** Numeric semver-ish compare: 1 when a > b, -1 when a < b, 0 when equal
+ * or unparseable. Pure — shared by the version command and the nudge. */
+export function compareVersions(a: string, b: string): number {
+  const pa = a.trim().replace(/^v/, "").split(".").map((part) => Number.parseInt(part, 10));
+  const pb = b.trim().replace(/^v/, "").split(".").map((part) => Number.parseInt(part, 10));
+  if (pa.some((n) => !Number.isFinite(n)) || pb.some((n) => !Number.isFinite(n))) return 0;
+  const len = Math.max(pa.length, pb.length);
+  for (let i = 0; i < len; i++) {
+    const x = pa[i] ?? 0;
+    const y = pb[i] ?? 0;
+    if (x > y) return 1;
+    if (x < y) return -1;
+  }
+  return 0;
+}
+
 const PACKAGE_JSON_PATH = path.resolve(
   path.dirname(fileURLToPath(import.meta.url)),
   "../package.json",
@@ -38,10 +60,33 @@ export function readGllaVersionInfo(): GllaVersionInfo {
   return { name: GLLA_PACKAGE_NAME, version: "unknown" };
 }
 
-export function formatGllaVersion(info: GllaVersionInfo = readGllaVersionInfo()): string {
-  return [
+export function formatGllaVersion(cwd?: string, info: GllaVersionInfo = readGllaVersionInfo()): string {
+  const lines = [
     `${info.name} v${info.version}`,
     "Installed package version.",
     `Compare with registry latest: npm view ${info.name} version`,
-  ].join("\n");
+  ];
+  // v0.38.44 (field 20260909_161057): when the update sidecar has a
+  // cached registry latest, say whether this session is stale and how
+  // to fix it. No cache (offline / never checked) keeps the legacy
+  // three lines — absence of evidence is not evidence of freshness.
+  if (cwd) {
+    try {
+      const parsed: unknown = JSON.parse(fs.readFileSync(updateCheckPath(cwd), "utf8"));
+      const latest = typeof parsed === "object" && parsed !== null
+        ? (parsed as Record<string, unknown>).latest
+        : undefined;
+      if (typeof latest === "string" && latest.trim()) {
+        lines.push(`Registry latest: v${latest.trim()}.`);
+        lines.push(
+          compareVersions(latest, info.version) > 0
+            ? `This session is stale — update: pi install npm:${info.name}@latest then /reload.`
+            : "This session is up to date.",
+        );
+      }
+    } catch {
+      // Sidecar read failure keeps the legacy output.
+    }
+  }
+  return lines.join("\n");
 }

package/extensions/goal-commands.ts

@@ -36,6 +36,7 @@ import type { SettingsSectionId } from "./settings-menu.js";
 import { cmdLoop, clearLoopTimer, finishLoopGit, isLoopActive, scheduleLoopTick } from "./goal-loop.js";
 import { chooseObjectiveConflict, liveObjectives } from "./goal-objective-conflict.js";
 import { formatGllaVersion } from "./glla-version.js";
+import { readUpdateCheck } from "./glla-update-check.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";
@@ -2385,7 +2386,7 @@ function cmdAudits(args: string, ctx: ExtensionContext): void {
 // version lookup next to the command surface makes an installed extension
 // identify itself even when its host session is stale or no live goal exists.
 function cmdGllaVersion(ctx: ExtensionContext): void {
-  ctx.ui.notify(formatGllaVersion(), "info");
+  ctx.ui.notify(formatGllaVersion(ctx.cwd), "info");
 }
 
 // v0.35.72: /glla bug — lightweight failure capture that never touches

package/extensions/goal-loop-display.ts

@@ -216,6 +216,12 @@ export interface WidgetExtras {
   auditorProgressSignals?: boolean;
   /** Effective global main-model backup order for truthful recovery HUDs. */
   mainModelFallbacks?: string[];
+  /** v0.38.44 (field 20260909_161057): precomputed status-tail version
+   * segment (`· v<running>` plus the update nudge when the cache proves
+   * the registry is ahead). Resolved at render contact by the caller —
+   * this module keeps zero runtime imports, so the pure compare/nudge
+   * logic lives in glla-update-check.ts. */
+  versionTail?: string;
   /** Truthful model-selection provenance for the active goal card/footer. */
   modelProvenance?: ModelProvenanceDisplay;
   /** Deterministic durable-vs-defer decision surface. Kept optional so the
@@ -1137,8 +1143,15 @@ export function buildStatusText(state: State, audit?: AuditDisplayProgress | nul
   const withAgentSummary = base && extras?.agents?.line
     ? `${base} · ${extras.agents.line.replace(/^●\s*/, "")}`
     : base;
-  if (!withAgentSummary || typeof state.supervisorPausedAt !== "number") return truncateStatusToWidth(withAgentSummary, width);
-  return truncateStatusToWidth(withAgentSummary.replace(/^glla:/, `glla: ${paint(theme, "warning", "⏸ supervisor")} ·`), width);
+  // v0.38.44 (field 20260909_161057): the running version rides the tail
+  // of EVERY branch — a stale session must be visible at a glance, not
+  // discoverable via a command. The update nudge appears only when the
+  // sidecar cache proves the registry is ahead; render never touches the
+  // network (refresh rides the command-contact gate).
+  const versionTail = extras?.versionTail ? ` ${extras.versionTail}` : "";
+  const withVersion = withAgentSummary && versionTail ? `${withAgentSummary}${versionTail}` : withAgentSummary;
+  if (!withVersion || typeof state.supervisorPausedAt !== "number") return truncateStatusToWidth(withVersion, width);
+  return truncateStatusToWidth(withVersion.replace(/^glla:/, `glla: ${paint(theme, "warning", "⏸ supervisor")} ·`), width);
 }
 
 /** Status-line width budget — the auditing/paused/loop branches concatenate

package/extensions/loops/goal-activation.ts

@@ -125,6 +125,7 @@ isGoalRevisionCurrent,
   type ListItem,
 } from "../goal-loop-core.js";
 import { replayUndeliveredApprovalRenders } from "../approval-render-store.js";
+import { refreshUpdateCheck } from "../glla-update-check.js"; // v0.38.44 stale-version nudge
 import {
   createContinuationDispatch,
   dispatchMatchesOwner,
@@ -739,6 +740,10 @@ export function __testOnlyClassifyStaleContinuation(content: string, cwd: string
 /** Commands and lifecycle contacts share the same ownership and delivery gates. */
 function replayApprovalSummariesOnContact(ctx: ExtensionContext): void {
   if (shouldSkipApprovalRenderReplay(ctx)) return;
+  // v0.38.44 (field 20260909_161057): the update-sidecar refresh rides
+  // the same contact gate — throttled + fire-and-forget inside, so this
+  // never blocks the turn and never surfaces on failure.
+  refreshUpdateCheck(ctx.cwd);
   replayUndeliveredApprovalRenders(ctx, (entry) => sendTerminalCompletionNotice(ctx, {
     goalId: entry.goalId, outcome: entry.objective, details: [], chatLines: entry.chatLines,
   }));

package/extensions/loops/goal-ui.ts

@@ -259,6 +259,8 @@ import {
   type ModelPickItem,
 } from "../model-picker.js";
 import { consumeRecoveryResume } from "../goal-recovery.js"; // decomposition step 3 (v0.34.111)
+import { buildVersionTail, readUpdateCheck } from "../glla-update-check.js"; // v0.38.44 version tail
+import { readGllaVersionInfo } from "../glla-version.js"; // v0.38.44 version tail
 import {
   createGoalHeartbeat,
   endSubagentHangProbe,
@@ -500,6 +502,14 @@ let lastUIRenderAt = 0;
 let lastUIRenderContext: ExtensionContext | null = null;
 let lastUIStatusText: string | undefined;
 let lastUIWidgetKey: string | undefined;
+// v0.38.44: the running version is fixed for the process lifetime (the
+// loaded code IS the version), so resolve package.json once instead of on
+// every render tick.
+let cachedRunningGllaVersion: string | null = null;
+function runningGllaVersion(): string {
+  if (cachedRunningGllaVersion === null) cachedRunningGllaVersion = readGllaVersionInfo().version;
+  return cachedRunningGllaVersion;
+}
 
 /**
  * Completion-auditor progress is ephemeral, but it still has an owner. A
@@ -826,6 +836,11 @@ function refreshUI(ctx: ExtensionContext, force = false): void {
       modelProvenance,
       ...(durableDeferRecommendation ? { durableDeferRecommendation } : {}),
       ...(lastAuditorQuietStretch ? { auditorQuietStretch: lastAuditorQuietStretch } : {}),
+      // v0.38.44 (field 20260909_161057): precomputed version tail for
+      // the status line — package.json running version + update-sidecar
+      // latest. Render never touches the network; the sidecar refresh
+      // rides the command-contact gate.
+      versionTail: buildVersionTail(runningGllaVersion(), readUpdateCheck(ctx.cwd)?.latest ?? null),
     };
     const statusText = buildStatusText(state, latestAuditProgress, now, theme, extras, width);
     const widgetLines = buildWidgetLines(state, latestAuditProgress, now, theme, width, extras);

package/package.json

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