pi-goal-list-loop-audit 0.36.1 → 0.37.2

package/CHANGELOG.md

@@ -1,5 +1,96 @@
 # Changelog
 
+## 0.37.2 — queued vs monitoring visuals and long-running daemon handling (2026-09-01)
+
+### Added
+  Monitor icon for long-running daemon/supervisor goals: goals matching
+  `daemon|supervisor|keep.*running|monitor|healthz` or with `total >1h` are
+  displayed as `👁 MONITORING` (dim) instead of `⏳ QUEUED` (accent), with
+  "next check" instead of "awaiting pi turn", and are scheduled with
+  `GLLA_MONITOR_INTERVAL_MS` (default 120s) instead of immediate continuation
+  to avoid constant queued churn.
+
+### Changed
+  `QUEUED` now renders as `⏳ QUEUED` in accent blue (distinct from `BUSY`
+  warning yellow) with `awaiting pi turn` detail, fixing the "mistook it
+  for stuck" report (note.md 2026-09-01, screenshots 190127/193438/193529).
+  `LIVE · WORKING` remains success-accent with signal.
+
+### Fixed
+  Stale `followUp` continuations that survived `archiveCurrentGoal` via Pi's
+  `followUpQueue` are sanitized at `message_end` (ExtensionRunner →
+  AgentSession) plus timer disarm at archival — `LENGTH_CONTINUE` and foreign
+  ctx are exempt.
+
+## 0.37.1 — auditor watchdogs, continuous list handoff, and audit hardening (2026-09-01)
+
+### Added
+  Configurable detached-auditor watchdog budgets (`auditorToolTimeoutMs` and
+  `auditorStallMs`, global-scope settings edited via `/glla` with plain-ms or
+  s/m/h duration input) replace the hardcoded 5-minute per-tool and 10-minute
+  no-progress defaults. Both dispatch sites now thread the configured values
+  into the parent watchdogs AND into the worker environment
+  (`GLLA_AUDITOR_TOOL_TIMEOUT_MS` / `GLLA_AUDITOR_STALL_MS`), so parent and
+  worker can never disagree about who kills first.
+
+  Adaptive timeout escalation for stalled auditor attempts: each consecutive
+  kill-and-restart of the same claim doubles the per-tool and first-event
+  budgets (capped at 4x the configured base), persisted on the durable claim
+  as `timeoutEscalation` so slow local models get a growing budget instead of
+  an identical kill-and-restart loop on every restart.
+
+  Progress-aware watchdog: the parent progress signature now includes streamed
+  report bytes, so an actively-streaming model (including extended thinking
+  between tool calls) registers as live progress instead of tripping the
+  no-progress kill; the quiet-phase UI warning is suppressed while a tool is
+  legitimately running inside its effective budget and shows the budget on
+  the live tool line.
+
+### Changed
+  The recommended parallel-orchestration companion is now **pinned**
+  `pi-subagents@0.62.0` — the power-max choice for GLLA. GLLA tracks its
+  versioned `subagent:*` lifecycle, durable async status artifacts, and v1
+  stop RPC while retaining a bounded compatibility path for older providers.
+  The model settings surface now uses the current `scout`/`researcher`/
+  `worker`/`reviewer`/`oracle`/`delegate` roles; current built-ins inherit
+  the parent model by default. Do not stack `@tintinweb/pi-subagents` or
+  `@quintinshaw/pi-dynamic-workflows` as a second orchestrator alongside it.
+  See `audit/SUBAGENT-PACKAGE-SELECTION-2026-09-01.md` (five-package power audit).
+
+### Fixed
+  Completed standalone goals now hand off to an already-waiting list and arm
+  the same bounded completion-settle window used by list-item cascades. The
+  explicit `/glla resume` surface now hydrates and starts a waiting-only queue,
+  while aborts, loop ownership, suspicious-objective, sidecar, and persistence
+  fences remain intact. Waiting-list cards name `/glla resume` as the recovery
+  action and retain `/list next` for deliberate skip/selection.
+
+  Durable state transitions and deferred settle repaints now bypass the
+  periodic UI throttle, while unchanged activity/ticker updates remain
+  cadence-limited. A replacement host therefore gets its first paint and
+  meaningful durable status changes cannot remain visually stale.
+
+  Detached-auditor payload blocks now escape XML-like delimiters in goal,
+  completion, verification, and shield data so untrusted text cannot close a
+  prompt boundary or impersonate prompt structure.
+
+  TUI jitter under scout fan-out is fixed: the above-editor widget now shows
+  only the compact one-line summary `● N agents · <busiest> silent Xm`
+  (bucketed 5s/<1m, 15s/<5m, 30s otherwise) instead of splicing 2 lines per
+  scout into the card. Detailed per-agent rows remain in `/glla agents` and
+  `--tail` as designed (docs/DESIGN-subagent-visibility.md), so height no
+  longer swings 4→10 lines and the editor layout stays stable under
+  `scout x3` / 150+ tool-use fan-outs.
+
+  Recovery and session-handoff freshness now rejects future-dated sidecars,
+  preventing an edited or clock-skewed marker from triggering an unexpected
+  resume or deferred-list replay.
+
+  Tracked child transcript tails use the persisted session id for direct
+  lookup, so older children remain inspectable without an unbounded directory
+  scan. List-audit fan-out now reads the configured state root, including
+  `sessionDir`, instead of assuming `<cwd>/.pi-glla`.
+
 ## 0.36.1 — crash-safe persistence and packed-release verification (2026-08-31)
 
 ### Fixed

package/INSTALL.md

@@ -38,19 +38,22 @@ and confirmation UX:
 pi install npm:@juicesharp/rpiv-ask-user-question
 ```
 
-When a goal has independent repository research or focused worker tasks,
-add the optional parallel-worker companion:
+For best automation and quality, add the **pinned parallel-orchestration companion** (`pi-subagents` 0.62.0) — GLLA's power-max choice for `runs.all` fan-out, `runs.lanes` worker→review→fix chains, structured verification, worktree isolation, and durable recovery:
 
 ```bash
-pi install npm:@tintinweb/pi-subagents
+pi install npm:pi-subagents@0.62.0
 ```
 
 GLLA's main continuation, queue, recovery, and detached auditor work without
-it. Other companions are optional: `@pi-unipi/notify` sends remote
-notifications, and `pi-chrome` enables logged-in browser research. For a deeper
-completion check, choose a stronger auditor model in `/glla`; a separate advisor
-extension is not required. None of these companions is required for a basic
-GLLA goal.
+it, but parallelism pays for its coordination when a goal has independent
+research or implementation. Other companions are optional: `@pi-unipi/notify`
+sends remote notifications, and `pi-chrome` enables logged-in browser research.
+For a deeper completion check, choose a stronger auditor model in `/glla`;
+a separate advisor extension is not required. Do not run `@tintinweb/pi-subagents`
+or `@quintinshaw/pi-dynamic-workflows` as a second orchestrator alongside GLLA +
+`pi-subagents` in the same session.
+
+None of these companions is required for a basic GLLA goal.
 
 Do not run another extension that drives agent turns at the same time as GLLA.
 Likewise, avoid a second task queue or overlapping retry/compaction supervisor

package/LIST-PHILOSOPHY.md

@@ -85,6 +85,6 @@ Speculative feature branching across autonomous subagents creates **stale contex
 ### The Single-Trunk Operating Rule:
 * **Serial Queue on `main`**: All queue items drain sequentially on the single primary working tree. Item $N+1$ always executes with 100% truthful, up-to-date context left by item $N$.
 * **Transactional Green-or-Revert**: Every task either lands green (verified by tests and the detached auditor) and commits, or cleanly rolls back on `main` before the next backlog item is touched.
-* **Safe Subagent Parallelism**: Subagents are used for **read-only research fan-out** (e.g. concurrent `Explore` queries across subsystems in a single turn) or standalone verification, rather than speculative mutating branches.
+* **Safe Subagent Parallelism**: Subagents are used for **read-only research fan-out** (e.g. concurrent `scout` queries across subsystems in a single turn) or standalone verification, rather than speculative mutating branches.
 
 See `INSTALL.md` for the command surface.

package/README.md

@@ -37,7 +37,9 @@ the long-running policy.
 
 Use `/glla version` to inspect the installed version and compare it with the
 registry. This checkout may contain unreleased changes; npm is authoritative
-for published versions.
+for published versions. The npm/Pi package listing displays this README from
+the published tarball, so release the package after updating it when store
+readers need the latest guidance.
 
 ## Is GLLA the right tool?
 
@@ -157,8 +159,8 @@ quietly inventing an unbounded backlog.
 /list plan.md                              # import a checklist or plan file
 /list                                     # show active and waiting items
 /list start                                # activate the queued head, or draft one clear recent request
-/list next                                 # intentionally activate the next item
-/list next <n>                             # choose a specific item
+/list next                                 # explicitly skip/activate the next item
+/list next <n>                             # explicitly choose a specific item
 /list resume                               # explicitly retry/resume the list
 /list remove <n>
 /list clear
@@ -167,13 +169,16 @@ quietly inventing an unbounded backlog.
 
 Order is the default, not the law. Automatic advance normally uses the head of
 the queue, while `/list next <n>` or the agent's `list_activate` tool can choose
-another item. Numbering always matches `/list` output.
+another item. Numbering always matches `/list` output. After a list item is
+approved and archived, the next queued item starts automatically; no manual
+`/list next` is needed between items.
 
 If a saved item is malformed or needs a repair, the repair card preserves the
 full original target, explains the concrete recovery action, and permits one
 bounded bootstrap turn containing `propose_task_list`. Confirm the redraft;
-automatic repeats are fenced. Use `/list resume` for an intentional retry and
-`/list next` when you intentionally want another queued item. `/list start` is
+automatic repeats are fenced. Use `/list resume` or `/glla resume` for an
+intentional retry of a waiting/restored queue, and `/list next` when you
+intentionally want to skip or choose another queued item. `/list start` is
 also explicit: it activates the queued head, or—when the queue is empty—uses
 one clear recent user request as a seed for the normal Confirm-gated list
 drafting flow. Ambiguous context is never queued automatically.
@@ -273,28 +278,40 @@ GLLA is the supervisor. These companions add capabilities around it:
   previews, and Confirm dialogs for drafting and decisions. GLLA has a prose
   fallback, but this is the intended UX.
 
-### Optional parallel workers
-
-- **`@tintinweb/pi-subagents`** — recommended when a goal has independent work
-  that can genuinely run in parallel. It gives the main agent Explore, Plan,
-  and general-purpose workers for research and focused implementation. It is
-  not required for GLLA's main continuation, queue, recovery, or detached
-  auditor; a short or mostly sequential goal is often better without the
-  extra worker overhead.
+### Recommended for power — parallel orchestration (`pi-subagents`)
+
+- **`pi-subagents` 0.62.0 (pinned) — the power-max choice for GLLA.** Use it
+  when you want the best automation and quality: `runs.all` parallel fan-out,
+  `runs.lanes` worker→review→fix chains, `outputSchema` + `acceptance` structured
+  verification, `runs.host` gated shell, worktree isolation, model routing
+  (`subagents.defaultModel` / `subagentModelOverrides` / `modelScope`), durable
+  missions/schedules/recovery, and versioned control RPC. Built-ins are `scout`,
+  `researcher`, `worker`, `reviewer`, `oracle`, `delegate` plus external-CLI
+  writers (`claude-code-writer` etc.); all inherit the parent model by default
+  so there is no hidden Explore/Plan quota pool. This is the companion GLLA
+  supervises via `subagent:*` lifecycle events + durable `status.json` + versioned
+  stop RPC (ownership/generation-checked). GLLA's `subagentModelOverrides`
+  can still pin an individual role.
 
   The main pi session remains the owner of the goal/list/loop; subagents are
-  workers and cannot silently replace the parent's objective.
+  workers and cannot silently replace the parent's objective. A short or mostly
+  sequential goal can still run cleanly without workers — install when
+  parallelism will pay for its coordination and model usage.
 
-Install it when parallelism will pay for its coordination and model usage:
+Install (or keep pinned):
 
 ```bash
-pi install npm:@tintinweb/pi-subagents
+pi install npm:pi-subagents@0.62.0
 ```
 
-GLLA supervises the parent and tracks worker activity, partial output, and
-confirmed frozen-child recovery. It also defaults Explore agents toward the
-parent model strategy so a hidden provider pin does not unexpectedly consume a
-different quota pool.
+Do not install the older `@tintinweb/pi-subagents` provider alongside this
+recommendation in the same session. Existing Tintin-era agent files are
+cleaned only when GLLA's management marker proves that GLLA owns them; old
+settings are not silently remapped to a different role. Do not stack
+`@quintinshaw/pi-dynamic-workflows` as a competing orchestrator alongside
+GLLA + `pi-subagents` in the same session — duplicate tools and competing
+orchestration events create ambiguous ownership. Use its quality helpers
+(`verify`/`judgePanel`/`loopUntilDry`) only as isolated complements if needed.
 
 ### Useful, but optional
 
@@ -342,7 +359,9 @@ tree.
 The state is inspectable: active JSONL, goal markdown, queue state, audit jobs,
 ledger history, and archived goals are kept under `.pi-glla/` (or the selected
 session root). Repository audit findings remain repository-only; the npm package
-ships the user-facing docs, not local audit history.
+ships the user-facing docs, not local audit history. The list-audit findings
+file and its fan-out follow the same selected state root, including the
+opt-in `sessionDir` root.
 
 ### Recovery behavior
 

package/docs/DESIGN.md

@@ -633,6 +633,46 @@ shapes (details in CHANGELOG.md; each is pinned by tests):
   that NEVER moves gets its own loud bounded stop. Audit loops keep their
   purpose-built deferred-baseline + reprieve semantics verbatim.
 
+## Addendum v0.36.3 (subagent orchestration — power-max pin)
+
+- **One pinned orchestrator**: `pi-subagents@0.62.0` is the power-max companion
+  for GLLA. Capability ceiling chosen over minimalism: `runs.all` parallel
+  fan-out, `runs.lanes` worker→review→fix chains, `outputSchema` +
+  `acceptance` structured verification, `runs.host` gated shell, worktree
+  isolation, model routing (`subagents.defaultModel` / `subagentModelOverrides`
+  / `modelScope`), missions/schedules, and durable recovery. GLLA supervises
+  via `subagent:async-started` + durable `status.json` + versioned stop RPC
+  (ownership/generation-checked). The 0.x pin is exact because the 93k-line
+  surface moves fast; upgrades run a compatibility canary.
+- **One owner, no stacking**: `@tintinweb/pi-subagents` (legacy),
+  `@narumitw/pi-subagents` (minimal without durable status/workflow), and
+  `@quintinshaw/pi-dynamic-workflows` (complement-only LLM-vote helpers) are
+  not stacked as second orchestrators in the same session — duplicate tools and
+  competing events create ambiguous ownership. `@juicesharp/rpiv-advisor`
+  remains a composable second-opinion reviewer.
+
+## Addendum v0.36.2 (continuous list handoff)
+
+- **A list is a continuous work plan**: after a standalone goal reaches a
+  successful terminal archive, an already-waiting queue is handed to the same
+  activation choke point used by list-item completion. The bounded
+  `LIST_COMPLETION_SETTLE_MS` window still protects the first successor
+  continuation from the host's completion acknowledgement settling. User
+  aborts do not auto-advance, and one-active-thing, suspicious-objective,
+  sidecar, persistence, carryover, and loop-owner fences remain authoritative.
+- **Resume repairs waiting queues**: `/glla resume` hydrates durable queue
+  sidecars, records `list_queue_resume`, and explicitly activates the waiting
+  head when no higher-priority goal, loop, auditor, or provider-recovery plane
+  owns the surface. Cold-load automation remains consent-gated; this command
+  is the consent boundary.
+- **Selection remains explicit**: `/list next` is still available for a
+  deliberate skip or non-head choice. It is no longer required between
+  successful list items.
+
+## Addendum v0.37.1 (folder-scoped audits)
+
+- **Primary scope is the cwd project**: `listAuditCollectTarget`, `projectAuditTarget`, and `auditTarget` now state "current project rooted at the cwd where pi was opened (treat any nested .git as a separate project boundary — do not walk into parent or sibling projects)". The TIGHT scout brief is "named directories under cwd" — external code outside cwd may be READ only to diagnose a failure that blocks the current project, and a finding about external code is valid only when it affects the current project (a typo in an unrelated sibling project is out of scope and never auto-queued). This closes the "audit the parent when you opened a subproject" leak observed when hellhunter was audited from the dracon-platform root and vice-versa.
+
 ## Files
 
 - `docs/DESIGN.md` — **this file**

package/docs/INDEX.md

@@ -10,15 +10,15 @@ shipped in the npm tarball (see "Repository-only material" below).
 
 For shipped docs, the relevant entry points are:
 
-- `../CHANGELOG.md` — user-facing changelog; the top of the file is the
-  current package version. v0.35.5 adopted the six-label completion
+- `../CHANGELOG.md` — user-facing changelog; an `Unreleased` section may lead
+  the file, followed by the current released version. v0.35.5 adopted the six-label completion
   recap; v0.35.6 added typed-boundary regression pins; v0.35.7 added
   deterministic fast-fail pre-audits, zero-pause autonomous execution, and
   task milestone gating; v0.35.8 added main-model preferred-primary
   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.36.1 continue through the supervisor freeze (`/glla pause`),
+  v0.35.14–v0.37.2 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
@@ -29,16 +29,16 @@ For shipped docs, the relevant entry points are:
   trail.
 - `../README.md` — what the plugin is, install, quickstart, and the
   architectural guarantee (drafting + confirm + detached auditor).
-- `../INSTALL.md` — manual install / symlink setup; the recommended
+- `../INSTALL.md` — source install / local development setup; the recommended
   companion plugins and the `auditor reads / writes are path-checked`
   note.
 
 ## Entry points
 - `../README.md` — what the plugin is, install, quickstart
-- `../INSTALL.md` — manual install / symlink setup
-- `../CHANGELOG.md` — user-facing changelog; current package version is
-  at the top of the file (use `/glla version` to compare with the
-  registry).
+- `../INSTALL.md` — source install / local development setup
+- `../CHANGELOG.md` — user-facing changelog; the first versioned heading is
+  the current released package version (use `/glla version` to compare with
+  the registry); post-release work may appear in `Unreleased` above it.
 
 ## Architecture
 - `DESIGN.md` — plugin design (types, state, extension lifecycle)

package/extensions/goal-agents-panel.ts

@@ -29,6 +29,8 @@ export type AgentPhase = "queued" | "active" | "hung" | "ended" | "unknown";
 
 export interface AgentsPanelRow {
   recordId: string;
+  /** Persisted pi session id, when the subagent runtime exposes it. */
+  sessionId?: string;
   agentType?: string;
   summary?: string;
   status: AgentStatus;
@@ -163,7 +165,11 @@ export function renderAgentsWidgetLines(rows: AgentsPanelRow[], now = Date.now()
   return lines;
 }
 
-/** The compact footer summary: count + the least-live child. */
+/** The compact footer summary: count + the least-live child.
+ * v0.37.1 (ui-jitter fix): bucket the silent age so the status/widget
+ * text stays stable between ticks — a per-second change made the footer
+ * and widget keys differ every 2s, forcing a TUI re-layout that looked
+ * like "jumping" under heavy scout fan-out. */
 export function renderAgentsWidgetLine(rows: AgentsPanelRow[]): string | undefined {
   const active = rows.filter((r) => r.status !== "ended");
   if (active.length === 0) return undefined;
@@ -173,7 +179,16 @@ export function renderAgentsWidgetLine(rows: AgentsPanelRow[]): string | undefin
     : busiest.status === "hung"
       ? " ⚠"
       : "";
-  return `● ${active.length} agent${active.length === 1 ? "" : "s"} · ${cleanField(busiest.agentType ?? "subagent", 18)} silent ${fmtDuration(busiest.silentMs)}${hung}`;
+  return `● ${active.length} agent${active.length === 1 ? "" : "s"} · ${cleanField(busiest.agentType ?? "subagent", 18)} silent ${fmtDuration(bucketSilentMs(busiest.silentMs))}${hung}`;
+}
+
+/** Bucket silentMs to coarser granularity for display stability:
+ * <1m → 5s buckets, <5m → 15s, otherwise 30s. The underlying
+ * hung classification still uses the exact value. */
+function bucketSilentMs(ms: number): number {
+  if (ms < 60_000) return Math.floor(ms / 5000) * 5000;
+  if (ms < 300_000) return Math.floor(ms / 15_000) * 15_000;
+  return Math.floor(ms / 30_000) * 30_000;
 }
 
 export interface TranscriptTailResult {
@@ -206,7 +221,7 @@ function parsedSessionInfoName(content: Buffer): string | undefined {
  * tail/head readers. */
 export function tailChildTranscript(
   sessionsDir: string,
-  row: { recordId: string; agentType?: string; summary?: string },
+  row: { recordId: string; sessionId?: string; agentType?: string; summary?: string },
   opts: {
     lines?: number;
     readFile?: (file: string, maxBytes?: number) => Buffer;
@@ -246,7 +261,19 @@ export function tailChildTranscript(
     .map((f) => ({ f, mtime: statMtime(f) }))
     .sort((a, b) => b.mtime - a.mtime);
   let matched: string | undefined;
-  const candidatesToScan = candidates.slice(0, 25);
+  // Pi names session files `<timestamp>_<sessionId>.jsonl`. Prefer the exact
+  // session id from the manager/event record so an old tracked child remains
+  // discoverable without turning the main-thread fallback into an unbounded
+  // full-directory scan. Identity in session_info.name remains authoritative.
+  const sessionId = row.sessionId?.trim();
+  const directCandidates = sessionId
+    ? candidates.filter(({ f }) => {
+      const base = path.basename(f);
+      return base === `${sessionId}.jsonl` || base.endsWith(`_${sessionId}.jsonl`);
+    })
+    : [];
+  const recentCandidates = candidates.filter((candidate) => !directCandidates.includes(candidate)).slice(0, 25);
+  const candidatesToScan = [...directCandidates, ...recentCandidates];
   if (expectedSessionName) for (const candidate of candidatesToScan) {
     try {
       // Check the bounded tail first so the existing scan remains the first
@@ -266,7 +293,7 @@ export function tailChildTranscript(
     return {
       ok: false,
       lines: [],
-      detail: `no session file in ${sessionsDir} matches this child (searched ${candidatesToScan.length}${candidates.length > candidatesToScan.length ? ` of ${candidates.length}` : ""} transcripts for exact identity in session_info.name: ${expectedSessionName ? `"${truncate(expectedSessionName, 32)}"` : "none"}) — the child may not persist a session, or it lives under another working directory`,
+      detail: `no session file in ${sessionsDir} matches this child (searched ${candidatesToScan.length}${candidatesToScan.length < candidates.length ? ` of ${candidates.length}` : ""} transcripts for exact identity in session_info.name: ${expectedSessionName ? `"${truncate(expectedSessionName, 32)}"` : "none"}) — the child may not persist a session, or it lives under another working directory`,
     };
   }
   try {

package/extensions/goal-commands.ts

@@ -36,7 +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 { cancelDetachedGoalCompletionAuditor, cleanupDeadAuditJobs, inspectAuditJobHealth } from "./goal-loop-auditor-process.js";
+import { 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";
 
@@ -2245,12 +2245,29 @@ async function cmdGllaResume(ctx: ExtensionContext): Promise<void> {
     scheduleLoopTick(ctx);
     return;
   }
+  // A waiting queue is resumable work even when its previous goal has already
+  // archived. `/glla resume` is explicit consent for this handoff, so it must
+  // start the head instead of reporting "Nothing to resume". Normal list
+  // completion still advances automatically; this branch covers a waiting
+  // queue left by a legacy run, a completed standalone goal, or a cold load.
+  // Hydrate sidecars too: a prior process may have published queue work after
+  // the last state snapshot, and `/glla resume` must not mistake that durable
+  // queue for an empty one.
+  hydrateListQueueFromDisk(ctx);
+  const waitingListCount = listQueue().length;
+  if (waitingListCount > 0) {
+    appendLedger(ctx.cwd, "list_queue_resume", { waiting: waitingListCount, via: "glla-resume" });
+    ctx.ui.notify(`Resuming the waiting list — starting its next item (${waitingListCount} waiting).`, "info");
+    if (activateNextListItem(ctx)) return;
+    ctx.ui.notify("The waiting list remains queued because its head could not be activated. Use /list show for the reason.", "warning");
+    return;
+  }
   if (clearedSupervisorPause) {
     // The pause was the only thing being resumed — do not follow it with a
     // misleading "Nothing to resume".
     return;
   }
-  ctx.ui.notify("Nothing to resume — no paused goal/list-item, no held loop. /goal, /list, or /loop to start something.", "info");
+  ctx.ui.notify("Nothing to resume — no paused goal/list-item, no held loop, or waiting list. /goal, /list, or /loop to start something.", "info");
 }
 
 /**
@@ -2673,6 +2690,8 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
       fmt("auditorSameSessionSwap", "auditorSameSessionSwap"),
       fmt("auditorSilent", "auditorSilent"),
       fmt("auditorProgressSignals", "auditorProgressSignals"),
+      `auditorToolTimeoutMs: ${((effectiveSettings.auditorToolTimeoutMs ?? DEFAULT_AUDITOR_TOOL_TIMEOUT_MS) / 60000).toString()}m  [${prov.auditorToolTimeoutMs?.source ?? "default"}]`,
+      `auditorStallMs: ${((effectiveSettings.auditorStallMs ?? DEFAULT_AUDITOR_STALL_MS) / 60000).toString()}m  [${prov.auditorStallMs?.source ?? "default"}]`,
       fmt("hourlyRetryProbe", "hourlyRetryProbe"),
       fmt("subagentModelStrategy", "subagentModelStrategy"),
       fmt("subagentModelOverrides", "subagentModelOverrides"),

package/extensions/goal-continuation.ts

@@ -47,6 +47,7 @@ import {
   isStaleApiError,
   supervisorPaused,
   objectiveIsUserSeeded,
+  isMonitorGoal,
   type Goal,
   type ObjectiveRepairTarget,
 } from "./goal-loop-core.js";
@@ -63,6 +64,12 @@ import {
 } from "./goal-loop-dispatch.js";
 import { BACKOFF_IDLE_RETRY_MS, HEARTBEAT_MAX_NUDGES } from "./goal-loop-backoff.js";
 import { LENGTH_CONTINUE_MAX, LENGTH_CONTINUE_TEXT } from "./length-continue.js";
+
+const DEFAULT_MONITOR_CHECK_INTERVAL_MS = 120_000;
+const configuredMonitorIntervalMs = Number(process.env.GLLA_MONITOR_INTERVAL_MS);
+const MONITOR_CHECK_INTERVAL_MS = Number.isFinite(configuredMonitorIntervalMs) && configuredMonitorIntervalMs > 0
+  ? Math.max(1_000, configuredMonitorIntervalMs)
+  : DEFAULT_MONITOR_CHECK_INTERVAL_MS;
 import { VISION_ASSIST_GUIDANCE } from "./vision-assist.js";
 import { loadSettings } from "./goal-settings.js";
 import { clearLoopTimer, isLoopActive } from "./goal-loop.js";
@@ -991,6 +998,10 @@ export function scheduleContinuation(ctx: ExtensionContext, force = false, delay
   } catch {
     return;
   }
+  // v0.37.x: monitor goals (daemon, long-running >1h) check less frequently to avoid constant QUEUED churn.
+  if (delayMs === undefined && state.goal && isMonitorGoal(state.goal)) {
+    delay = Math.max(delay, MONITOR_CHECK_INTERVAL_MS);
+  }
   // v0.34.104 ([Image-#1]): the post-list-completion settle window delays
   // the first continuation after a queue auto-advance. Any real agent
   // activity during the window clears `postCompletionSettleUntil`, so a
@@ -1259,7 +1270,7 @@ export function continuationPrompt(goal: Goal): string {
   }
   if (effSettings.aggressiveMode && isFullAuditObjective(goal.objective)) {
     directives.push(
-      "## FULL-AUDIT MODE (aggressiveMode + survey objective)\n\nThis objective is a survey, not a single fix. Spawn 3+ `Explore` subagents NOW — one per subsystem, in a single message so they run in parallel — synthesize their findings, and call `propose_task_list` with the result. Do not start fixing before the task list exists.",
+      "## FULL-AUDIT MODE (aggressiveMode + survey objective)\n\nThis objective is a survey, not a single fix. Spawn 3+ `scout` subagents NOW — one per subsystem, in a single message so they run in parallel — synthesize their findings, and call `propose_task_list` with the result. Do not start fixing before the task list exists.",
     );
   }
   // v0.35.x: include the latest auditor report in the continuation prompt so