pi-goal-list-loop-audit 0.38.113 → 0.39.4

package/CHANGELOG.md

@@ -2,6 +2,89 @@
 
 ## Unreleased
 
+## 0.39.4 — project builder, audit recovery and opportunistic compaction (2026-10-05)
+
+### check compaction before idle loop dispatch
+
+- Metric loops and project builder turns check the configured context-token
+  threshold at their actual idle dispatch boundary, matching goal/list sends.
+  Hosts without a settled-turn event can still attempt opportunistic compaction.
+- A failed optional compaction resumes the same active loop through a fresh
+  owner context. Busy hosts, queued messages, paused work and audit dispatches
+  retain their guards; an attempted episode is not retried every turn.
+
+### preserve project audit boundaries and recovery evidence
+
+- Startup and manual audit-job cleanup preserve jobs belonging to unresolved
+  goal or project increment claims, including held work. Once those claims
+  settle, ordinary age and worker-identity retention applies again.
+- Health reports exclude claim-protected jobs from cleanup candidates. Cleanup
+  also refuses to delete jobs when the durable claim journal cannot be read.
+- Settled-turn and idle-boundary transcript compaction wait while an exact
+  project increment audit dispatch owns the boundary.
+- The project-audit heartbeat regression now exercises six actual heartbeat
+  ticks during a dispatched worker run, beyond the stall escalation threshold.
+
+### protect project increment audits from continuation stalls
+
+- The main-session heartbeat no longer counts failed continuation attempts
+  while the exact project increment audit dispatch is running. Detached worker
+  timeout handling remains responsible for the audit. A saved claim alone, a
+  replacement claim, or a cancelled dispatch cannot suppress the heartbeat.
+- Held project audits say **Audit held** and show the recorded stop reason
+  instead of displaying an ambiguous auditing phase with generic held text.
+
+### explain long audit tool waits
+
+- Audit cards keep the current tool's ticking elapsed time and timeout visible
+  when it stops producing events. The card says it is waiting on the tool,
+  rather than turning the current call into a historical "last tool" row.
+- Compact footers lead with the tool wait and its elapsed/timeout clock.
+  Waiting is distinct from fresh activity; cancelled, overdue and invalid
+  telemetry cannot claim a healthy wait. Timeout handling stays automatic.
+- Automatic and manual audit progress use the worker's effective granted tool
+  timeout, matching the watchdog rather than showing only the base budget.
+
+### respec project builder
+
+- `/loop respec [project direction]` drafts intended requirements for confirmation,
+  builds coherent increments, runs isolated audits and replans unfinished work.
+  Task claims and spec checkboxes cannot verify requirements. Later audits cover
+  previous capabilities as regressions; completion requires all adopted criteria.
+- Scope refinements require confirmation, retain removal/task history and fence
+  old verdicts by revision. Blockers stay visible; all-blocked projects park,
+  and clearing a blocker preserves pause until explicit resume.
+- Durable audit identities recover saved verdicts across restart, concurrent
+  wakes share one worker, pause/stop cancels audits, and archive failures retain
+  approved evidence for settlement retry. Completion archives the project before
+  exposing terminal state and announces waiting queue items.
+- Project audit cards show live worker/retry state, model, elapsed time and last
+  activity. `/loop status` lists every requirement and its acceptance/evidence.
+  Verified project summaries use semantic colors and bold, archive before
+  delivery, and replay unacknowledged receipts on reload.
+- Full audit fixes persistence rollback, supervisor freeze/retry gating,
+  rapid pause/resume rearming, blocked-project resume and continuous audit
+  visibility. Project receipts use the shared durable outbox across project
+  replacement; large summaries disclose omissions and retain full archives.
+  Generic loop recaps preserve verified project summaries.
+- Project cards/status expose phase, increment, verified/remaining coverage,
+  blockers, evidence and next action using the existing semantic palette.
+- Regression-shield rejection reports unfinished work and carries missing
+  contract evidence into replanning. Stale audit wakes are rejected before
+  model resolution or dispatch.
+
+### semantic summary colors
+
+- Summary emphasis uses bold, including Markdown italic emphasis and quotes;
+  summaries do not render italics.
+- Terminal completion summaries use the active theme’s semantic colors for
+  outcomes, remaining work, next actions and verification results. Unknown
+  verification stays neutral; reported or skipped checks use amber, and
+  failures use red without recoloring unrelated approval references.
+- Styling is applied by a registered renderer. Saved summary Markdown,
+  archive content, receipt identity and headless output retain plain content;
+  continuation messages continue through Pi’s default renderer.
+
 ## 0.38.113 — make background audits clear (2026-10-03)
 
 - The live audit widget uses a compact card, keeping audit state, completed

package/README.md

@@ -214,6 +214,8 @@ drafting flow. Ambiguous context is never queued automatically.
 /loop start "reduce flaky tests" measure="..." direction=min
 /loop start "keep improving the spec" measure=none max=20 cadence=900
 /loop audit                               # recurring project-audit cadence
+/loop respec [project direction]           # draft intended scope, build, audit and replan
+/loop refine <suggestion>                  # steer the next round; scope changes need confirmation
 /loop status
 /loop stop
 ```
@@ -238,7 +240,40 @@ There are three loop styles:
 - **Project audit:** each iteration looks for the next important finding,
   appends evidence to the audit ledger, and works through the findings.
 
-If the work has a finish line, use `/goal`, not an endless loop.
+Use `/goal` for one defined outcome, `/list` for a known task queue, and
+`/loop respec` for developing a project through evolving build and audit batches.
+
+`/loop respec` develops a project through substantial increments. It researches
+the code and root `SPEC.md` (or `spec.md`), drafts intended capabilities with
+observable acceptance criteria, and asks you to confirm that scope. Existing
+behavior and desired behavior are kept distinct; missing features become work
+to build. `## Rules` remains binding project guidance.
+
+After confirmation, the builder plans a coherent batch, implements it, and
+submits it to the isolated auditor. A task marked implemented is a claim;
+only independent approval verifies its requirements. Failed checks and unfinished
+requirements feed replanning. Each later audit also checks previously verified
+capabilities for regressions. The project finishes only when every adopted
+requirement is independently verified and the project archive is written.
+
+The widget and `/loop status` show phase, increment, verified/remaining coverage
+and blockers. During auditing, the card shows the actual worker state, model,
+elapsed time and last activity, including retries; a restored claim without
+live telemetry is shown as waiting for dispatch. `/loop status` lists every
+requirement, its acceptance criteria, blocker and verification evidence.
+Verified completion posts a semantic summary of shipped capabilities,
+acceptance checks and evidence, saved in the journal and project archive;
+unacknowledged delivery uses the durable outbox and retries on reload, even
+after a new project replaces the old loop, without rerunning the audit. Large
+summary cards name omitted requirements/reports; the archive and `/loop status`
+retain the full criteria and evidence.
+`/loop pause` holds work, `/loop resume` continues saved state, and
+`/loop stop` stops it without calling unfinished work complete. If all remaining
+work is blocked, automation parks with reasons; clearing a blocker leaves work
+paused until resume. `/loop refine <suggestion>` supplies direction for the next
+round. Changes to adopted requirements show current/proposed acceptance criteria
+and need your confirmation. Text after `respec` is project direction, not metric
+or budget option syntax. Generic `/loop start` remains the metric/bounded path.
 
 ## The autonomy model
 

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.113 continue through the supervisor freeze (`/glla pause`),
+  v0.35.14–v0.39.4 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/docs/RUNTIME-INVENTORY.md

@@ -2,25 +2,25 @@
 
 Generated by `node scripts/generate-inventory.mjs`. Run with `--check` to detect drift. Counts describe files and literal registrations, not executed coverage.
 
-- Extension/script files: 91
-- Extension/script lines: 64275
-- Top-level test files: 342
+- Extension/script files: 96
+- Extension/script lines: 64969
+- Top-level test files: 348
 - Ambient bridge names: 179 (audit baseline: 183)
 - Commands: `/glla`, `/goal`, `/list`, `/loop`, `/review`
-- Tools: `complete_goal`, `complete_task`, `list_activate`, `list_add`, `list_status`, `pause_goal`, `propose_goal_draft`, `propose_loop_draft`, `propose_loop_refine`, `propose_task_list`, `record_goal_judgment`, `resume_goal`, `update_task_batch`, `update_task_status`
+- Tools: `audit_project_increment`, `block_project_requirement`, `claim_project_task`, `complete_goal`, `complete_task`, `list_activate`, `list_add`, `list_status`, `pause_goal`, `plan_project_increment`, `propose_goal_draft`, `propose_loop_draft`, `propose_loop_refine`, `propose_project_refinement`, `propose_project_requirements`, `propose_task_list`, `record_goal_judgment`, `resume_goal`, `unblock_project_requirement`, `update_task_batch`, `update_task_status`
 
 ## Largest modules
 
 | Module | Lines |
 |---|---:|
 | [extensions/goal-loop-core.ts](../extensions/goal-loop-core.ts) | 4966 |
-| [extensions/loops/goal-tools.ts](../extensions/loops/goal-tools.ts) | 4147 |
-| [extensions/loops/goal-activation.ts](../extensions/loops/goal-activation.ts) | 3738 |
-| [extensions/goal-commands.ts](../extensions/goal-commands.ts) | 3526 |
-| [extensions/goal-loop-display.ts](../extensions/goal-loop-display.ts) | 2685 |
-| [extensions/goal-loop-auditor-process.ts](../extensions/goal-loop-auditor-process.ts) | 2664 |
-| [extensions/loops/goal-auditor-hooks.ts](../extensions/loops/goal-auditor-hooks.ts) | 2655 |
-| [extensions/goal-heartbeat.ts](../extensions/goal-heartbeat.ts) | 2093 |
+| [extensions/loops/goal-tools.ts](../extensions/loops/goal-tools.ts) | 4172 |
+| [extensions/loops/goal-activation.ts](../extensions/loops/goal-activation.ts) | 3740 |
+| [extensions/goal-commands.ts](../extensions/goal-commands.ts) | 3527 |
+| [extensions/goal-loop-display.ts](../extensions/goal-loop-display.ts) | 2738 |
+| [extensions/goal-loop-auditor-process.ts](../extensions/goal-loop-auditor-process.ts) | 2675 |
+| [extensions/loops/goal-auditor-hooks.ts](../extensions/loops/goal-auditor-hooks.ts) | 2656 |
+| [extensions/goal-heartbeat.ts](../extensions/goal-heartbeat.ts) | 2098 |
 | [extensions/loops/goal-session.ts](../extensions/loops/goal-session.ts) | 2062 |
 | [extensions/loops/goal-settings-ui.ts](../extensions/loops/goal-settings-ui.ts) | 2023 |
 

package/extensions/continuous-supervision.ts

@@ -55,6 +55,11 @@ function durableStateSignature(state: State, liveSubagentCount: number): string
       iteration: state.loop.iteration,
       stopReason: state.loop.stopReason,
       bestValue: state.loop.bestValue,
+      builder: state.loop.builder ? {
+        phase: state.loop.builder.phase, revision: state.loop.builder.revision,
+        cycle: state.loop.builder.cycle, attemptId: state.loop.builder.audit?.attemptId,
+        requirements: state.loop.builder.requirements?.map(r => ({ id: r.id, status: r.status })),
+      } : undefined,
     }
     : null;
   const recovery = state.mainModelRecovery
@@ -85,6 +90,7 @@ export function activeSupervisionPlanes(state: State, liveSubagentCount = 0): Su
     if (goal.status === "auditing" || !!goal.pendingCompletion) planes.push("auditor");
   }
   if (state.loop?.active) planes.push("loop");
+  if (state.loop?.builder?.phase === "auditing" && state.loop.builder.audit && !planes.includes("auditor")) planes.push("auditor");
   if ((state.list?.length ?? 0) > 0) planes.push("queue");
   if (state.mainModelRecovery) planes.push("provider-recovery");
   if (liveSubagentCount > 0) planes.push("subagent");

package/extensions/goal-commands.ts

@@ -2875,8 +2875,9 @@ function cmdAudits(args: string, ctx: ExtensionContext): void {
     const action = /\bcleanup\b/.test(args) ? "cleanup" : "health";
     ctx.ui.notify(
       `glla audit-job ${action}: ${report.total} director${report.total === 1 ? "y" : "ies"} · ${report.live} live · ${report.dead} proven dead · ${report.ambiguous} ambiguous · ${report.bytes} bytes${report.cleanupCandidates > 0 ? ` · ${report.cleanupCandidates} old dead candidate(s)` : ""}.` +
-      (report.ambiguous > 0 ? " Ambiguous locks were preserved." : ""),
-      report.ambiguous > 0 ? "warning" : "info",
+      (report.ambiguous > 0 ? " Ambiguous locks were preserved." : "") +
+      (report.retentionBlocked ? ` Cleanup held: ${report.retentionBlocked}.` : ""),
+      report.ambiguous > 0 || report.retentionBlocked ? "warning" : "info",
     );
     return;
   }

package/extensions/goal-compactor.ts

@@ -28,6 +28,7 @@ import {
 } from "./goal-loop-core.js";
 import { loadGlobalSettings, type Settings } from "./goal-settings.js";
 import { PLAN_B_MAX_ATTEMPTS, resolveCompactorModel } from "./compactor-model.js";
+import { respecBuilderAuditInFlight } from "./respec-builder-runtime.js";
 
 /** Hard cap on the persisted brief: a handoff, not a transcript. */
 export const COMPACTOR_BRIEF_MAX_CHARS = 2000;
@@ -138,6 +139,7 @@ export function maybeCompactTranscriptAtBoundary(
   onFailure?: () => void,
 ): boolean {
   if (!flags.supervising || flags.auditInFlight || flags.paused) return false;
+  if (respecBuilderAuditInFlight(ctx.cwd)) return false;
   let idle = false;
   let pending = true;
   try {

package/extensions/goal-heartbeat.ts

@@ -44,6 +44,7 @@ import {
 } from "./goal-loop-backoff.js";
 import { isLoopActive, loopTimerPending, scheduleLoopTick } from "./goal-loop.js";
 import { auditorWorkerLiveForAttempt } from "./goal-loop-auditor-process.js";
+import { respecBuilderAuditInFlight } from "./respec-builder-runtime.js";
 import { mainModelRecoveryActive, markCompletionAuditRecoveryPending, probeMainModelRecovery } from "./goal-recovery.js";
 import type { ContinuationDispatch } from "./goal-loop-dispatch.js";
 import type { AgentPhase, AgentStatus } from "./goal-agents-panel.js";
@@ -1881,6 +1882,10 @@ function heartbeatTick(): void {
   // windows are already covered precisely — busy mid-turn, pending
   // messages, scheduled timers — plus the audit-in-flight flag below.
   if (flags.completionAuditInFlight) return;
+  // Increment audits intentionally leave the main session idle. Refiring
+  // its continuation cannot start a turn and would eventually park healthy
+  // detached work. Protect only the exact live dispatch, never an old claim.
+  if (respecBuilderAuditInFlight(ctx.cwd)) return;
   noteActivity();
   flags.consecutiveStalls++;
   appendLedger(ctx.cwd, "heartbeat_refire", { nudgesSoFar: flags.heartbeatNudges, consecutiveStalls: flags.consecutiveStalls });

package/extensions/goal-loop-auditor-process.ts

@@ -19,6 +19,8 @@ import { fileURLToPath } from "node:url";
 import {
   piGlaDir,
   appendLedger,
+  readState,
+  isPersistenceDegraded,
   stripThinkBlocks,
   captureGoalRevision,
   isRetriableInfraError,
@@ -1090,6 +1092,8 @@ export interface AuditJobHealthEntry {
    * `pid` beside it is a PARENT identity (or a reused pid) and re-verifying its
    * liveness before a reap would protect nothing. */
   provenFinished?: boolean;
+  /** Unsettled durable claims still need this job's recovery evidence. */
+  retainedForClaim?: boolean;
 }
 
 export interface AuditJobHealthReport {
@@ -1102,6 +1106,7 @@ export interface AuditJobHealthReport {
   bytes: number;
   cleanupCandidates: number;
   entries: AuditJobHealthEntry[];
+  retentionBlocked?: string;
 }
 
 /** A deliberately conservative threshold: an auditor that is merely slow is
@@ -1145,6 +1150,10 @@ export function inspectAuditJobHealth(
 ): AuditJobHealthReport {
   const root = path.join(piGlaDir(cwd), "audit-jobs");
   const entries: AuditJobHealthEntry[] = [];
+  const durable = readState(cwd);
+  const retentionBlocked = isPersistenceDegraded() ? "durable claims could not be read safely" : undefined;
+  const pendingIds = [durable.goal?.pendingCompletion?.attemptId, durable.loop?.builder?.audit?.attemptId]
+    .filter((id): id is string => typeof id === "string" && id.length > 0);
   let dirs: Array<{ name: string; isDirectory: () => boolean }> = [];
   try {
     dirs = readdirSync(root, { withFileTypes: true });
@@ -1236,22 +1245,24 @@ export function inspectAuditJobHealth(
         }
       }
     }
-    entries.push({ attemptId: entry.name, dir, ageMs, bytes, status, ...(pid !== undefined ? { pid } : {}), ...(provenFinished ? { provenFinished: true } : {}), ...(reason ? { reason } : {}) });
+    const retainedForClaim = pendingIds.some(id => entry.name === id || entry.name.startsWith(`${id}-`));
+    entries.push({ attemptId: entry.name, dir, ageMs, bytes, status, ...(retainedForClaim ? { retainedForClaim: true } : {}), ...(pid !== undefined ? { pid } : {}), ...(provenFinished ? { provenFinished: true } : {}), ...(reason ? { reason } : {}) });
   }
   const live = entries.filter((entry) => entry.status === "live").length;
   const dead = entries.filter((entry) => entry.status === "dead").length;
   const ambiguous = entries.filter((entry) => entry.status === "ambiguous").length;
   const bytes = entries.reduce((sum, entry) => sum + entry.bytes, 0);
-  const cleanupCandidates = entries.filter((entry) => entry.status === "dead" && entry.ageMs >= maxAgeMs).length;
-  return { root, scannedAt: new Date(nowMs).toISOString(), total: entries.length, live, dead, ambiguous, bytes, cleanupCandidates, entries };
+  const cleanupCandidates = retentionBlocked ? 0 : entries.filter((entry) => entry.status === "dead" && !entry.retainedForClaim && entry.ageMs >= maxAgeMs).length;
+  return { root, scannedAt: new Date(nowMs).toISOString(), total: entries.length, live, dead, ambiguous, bytes, cleanupCandidates, entries, ...(retentionBlocked ? { retentionBlocked } : {}) };
 }
 
 /** Explicit, age-bounded cleanup for only proven-dead worker identities.
  * Ambiguous locks are intentionally left for operator inspection. */
 export function cleanupDeadAuditJobs(cwd: string, maxAgeMs = AUDIT_JOB_CLEANUP_MIN_AGE_MS, nowMs = Date.now()): AuditJobHealthReport {
   const report = inspectAuditJobHealth(cwd, nowMs, maxAgeMs);
+  if (report.retentionBlocked) return report;
   for (const entry of report.entries) {
-    if (entry.status !== "dead" || entry.ageMs < maxAgeMs) continue;
+    if (entry.status !== "dead" || entry.retainedForClaim || entry.ageMs < maxAgeMs) continue;
     // A dead entry WITH a pid always re-verifies liveness first (PID reuse
     // between scan and reap). A dead entry WITHOUT a pid is only reachable
     // via the no-lock+result path above — provably finished, no pid to

package/extensions/goal-loop-display.ts

@@ -1,3 +1,4 @@
+import { getRespecAuditLive, respecAuditStatus } from "./respec-builder-ui.js";
 /**
  * pi-goal-list-loop-audit — v0.9.0
  * extensions/goal-loop-display.ts
@@ -17,6 +18,7 @@ import { auditVerdictLabel, auditLifecycleLine, auditLifecycleProjection, auditP
 
 export { isMonitorGoal };
 import { HELD_ON_RESTORE, type LoopState } from "./goal-loop-forever.js";
+import { respecCoverage } from "./respec-builder.js";
 import { normalizeFindingLead } from "./finding-lead.js";
 import { auditorSurfaceSuppressed } from "./loops/goal-auditor-surface.js";
 
@@ -460,6 +462,7 @@ export function buildDurableDeferDecisionLines(input: DurableDeferRecommendation
 export type DisplayColor = "accent" | "success" | "warning" | "error" | "muted" | "dim";
 export interface DisplayTheme {
   fg(color: DisplayColor, text: string): string;
+  bold?(text: string): string;
 }
 export const paint = (theme: DisplayTheme | undefined, color: DisplayColor, text: string): string => (theme ? theme.fg(color, text) : text);
 
@@ -998,7 +1001,20 @@ function auditorObservedPhase(audit: AuditDisplayProgress | null | undefined, ph
   }
 }
 
-function auditorPhaseForDisplay(audit: AuditDisplayProgress | null | undefined, phase: AuditorDisplayPhase, live: boolean): string {
+/** An unfinished tool is a wait, not fresh evidence of forward progress.
+ * Retain its observed clock while it is inside the dispatched timeout. */
+function auditorToolWait(audit: AuditDisplayProgress | null | undefined, phase: AuditorDisplayPhase, now: number): boolean {
+  return phase === "running" && !!audit?.currentTool
+    && (audit.phase === "running" || audit.phase === "tool_executing" || audit.phase === undefined)
+    && typeof audit.currentToolStartedAt === "number" && Number.isFinite(audit.currentToolStartedAt)
+    && audit.currentToolStartedAt <= now
+    && (audit.lastActivityAt === undefined || Number.isFinite(audit.lastActivityAt) && audit.lastActivityAt <= now)
+    && typeof audit.toolTimeoutMs === "number" && Number.isFinite(audit.toolTimeoutMs) && audit.toolTimeoutMs > 0
+    && now - audit.currentToolStartedAt < audit.toolTimeoutMs;
+}
+
+function auditorPhaseForDisplay(audit: AuditDisplayProgress | null | undefined, phase: AuditorDisplayPhase, live: boolean, now: number): string {
+  if (!live && auditorToolWait(audit, phase, now)) return `waiting on ${sanitizeDisplayText(audit!.currentTool!)}`;
   // Once a worker timestamp exists, a stale tool snapshot is historical
   // context, not a claim that the detached process is still in that call.
   if (!live && phase === "running" && audit?.lastActivityAt !== undefined && audit.currentTool) {
@@ -1340,6 +1356,10 @@ export function loopCadenceCountdown(l: { minimumIterationIntervalMs?: number; l
 }
 
 function buildStatusTextBase(state: State, audit?: AuditDisplayProgress | null, now = Date.now(), theme?: DisplayTheme, extras?: WidgetExtras, width?: number): string | undefined {
+  if (state.loop?.builder && (state.loop.active || !state.goal)) {
+    const l = state.loop, builder = l.builder!, coverage = respecCoverage(builder);
+    return `glla: project ${paint(theme, builder.phase === "complete" ? "success" : !l.active ? "warning" : "accent", !l.active && builder.phase === "auditing" ? "audit held — /loop resume" : builder.phase)}${l.active || builder.phase === "complete" || builder.phase === "auditing" ? "" : " · held"} · increment ${builder.cycle} · verified ${coverage.verified}/${coverage.total} · remaining ${coverage.remaining} · blocked ${coverage.blocked}${l.active && builder.phase === "auditing" ? ` · ${respecAuditStatus(builder, now)}` : ""}`;
+  }
   if (state.loop?.active) {
     const l = state.loop;
     // v0.26.1: surface the refire streak — a spinning supervisor is the
@@ -1393,10 +1413,12 @@ function buildStatusTextBase(state: State, audit?: AuditDisplayProgress | null,
     // settling, workerless, and contradicted-starting claims are named by
     // their durable phase; any other real progress object speaks for itself.
     const durableLabel = durablePhaseOverride(g.pendingCompletion, audit, now);
+    const toolWait = auditorToolWait(audit, phase, now);
     const observed = durableLabel
+      ?? (toolWait ? `waiting on ${sanitizeDisplayText(audit!.currentTool!)}` : undefined)
       ?? (signals && phase === "running"
-        ? (auditorProgressPhaseLabel(audit) ?? auditorPhaseForDisplay(audit, phase, live))
-        : auditorPhaseForDisplay(audit, phase, live));
+        ? (auditorProgressPhaseLabel(audit) ?? auditorPhaseForDisplay(audit, phase, live, now))
+        : auditorPhaseForDisplay(audit, phase, live, now));
     // v0.35.15: leading phase glyph + draining activity meter — a glance
     // answers "is the audit alive?" without reading the sentence.
     const phaseText = `auditor ${auditorPhaseGlyph(phase)} ${observed}`;
@@ -1413,10 +1435,10 @@ function buildStatusTextBase(state: State, audit?: AuditDisplayProgress | null,
     const quietAge = phase === "quiet" ? auditorActivityAge(audit, now) : undefined;
     const quietSuffix = quietAge !== undefined ? ` · silent ${fmtElapsed(quietAge)}` : "";
     const compactPrefix = extras?.compactAuditCard
-      ? `${paint(theme, color, durableLabel ?? (phase === "running" ? "AUDIT RUNNING" : phase === "quiet" ? "AUDIT QUIET — may be stuck" : phase === "blocked" ? "AUDIT BLOCKED" : phase === "queued" ? "AUDIT STARTING" : "AUDIT REVIEW"))} · `
+      ? `${paint(theme, color, durableLabel ?? (toolWait ? `AUDIT TOOL WAIT · ${sanitizeDisplayText(audit!.currentTool!)} ${fmtElapsed(now - audit!.currentToolStartedAt!)} / ${fmtElapsed(audit!.toolTimeoutMs!)}` : phase === "running" ? "AUDIT RUNNING" : phase === "quiet" ? "AUDIT QUIET — may be stuck" : phase === "blocked" ? "AUDIT BLOCKED" : phase === "queued" ? "AUDIT STARTING" : "AUDIT REVIEW"))} · `
       : "";
     const activityAge = auditorActivityAge(audit, now);
-    const freshness = extras?.compactAuditCard && phase !== "quiet"
+    const freshness = extras?.compactAuditCard && phase !== "quiet" && !toolWait
       ? `${activityAge !== undefined ? `activity ${fmtElapsed(activityAge)} ago` : "no worker activity yet"} · `
       : "";
     return `glla: ${compactPrefix}${freshness}${host} · ${label}${quietSuffix}${heldSuffix}`;
@@ -1783,6 +1805,7 @@ function waitingListLines(state: State, theme?: DisplayTheme, width?: number): s
 }
 
 function buildWidgetLinesInner(state: State, audit?: AuditDisplayProgress | null, now = Date.now(), theme?: DisplayTheme, width?: number, extras?: WidgetExtras): string[] | undefined {
+  if (state.loop?.builder && (state.loop.active || !state.goal)) return respecBuilderLines(state.loop, now, theme, width);
   if (state.loop?.active) return loopLines(state.loop, now, theme, width, extras);
   if (state.loop && !state.loop.active && state.mainModelRecovery?.kind === "loop") return parkedLoopRecoveryLines(state.loop, state.mainModelRecovery, now, theme, width, extras?.mainModelFallbacks);
   if (!state.goal && state.mainModelRecovery) return standaloneRecoveryLines(state.mainModelRecovery, now, theme, width, extras?.mainModelFallbacks);
@@ -1910,8 +1933,8 @@ function auditingCardBlock(g: Goal, audit: AuditDisplayProgress | null | undefin
   // on ("reading source…" / "writing report…"); the coarse label otherwise.
   const signals = extras?.auditorProgressSignals !== false;
   const phaseLabel = signals && phase === "running"
-    ? (auditorProgressPhaseLabel(audit) ?? auditorPhaseForDisplay(audit, phase, phaseLive))
-    : auditorPhaseForDisplay(audit, phase, phaseLive);
+    ? (auditorProgressPhaseLabel(audit) ?? auditorPhaseForDisplay(audit, phase, phaseLive, now))
+    : auditorPhaseForDisplay(audit, phase, phaseLive, now);
   // v0.38.99: the durable lifecycle names the state whenever in-process
   // progress cannot (see durablePhaseOverride). The coarse display phase only
   // speaks for a claim a LIVE worker is driving.
@@ -1953,7 +1976,7 @@ function auditingCardBlock(g: Goal, audit: AuditDisplayProgress | null | undefin
   // ONLY here (it moved out of the tail) so the card keeps its
   // one-current-observation rule.
   let toolSeg: string | undefined;
-  if (phase === "running" && phaseLive && audit?.currentTool) {
+  if (phase === "running" && (phaseLive || auditorToolWait(audit, phase, now)) && audit?.currentTool) {
     const target = auditorToolTarget(audit.currentToolArgs);
     const duration = audit.currentToolStartedAt !== undefined && Number.isFinite(audit.currentToolStartedAt)
       ? ` · ${fmtElapsed(now - audit.currentToolStartedAt)}`
@@ -2177,11 +2200,12 @@ function goalLines(g: Goal, state: State, audit: AuditDisplayProgress | null | u
       const age = auditorActivityAge(audit, now);
       const facts = [finished !== undefined ? `${finished} calls finished` : undefined,
         age !== undefined ? `activity ${fmtElapsed(age)} ago` : "no activity yet"].filter(Boolean);
+      const toolWait = auditorToolWait(audit, phase, now);
       const action = block.lead.find(line => line.startsWith("│ next:"));
       // No history or model plaques in the glance card: Pi clips its tail.
       // Keep state, real evidence and the user action ahead of all details.
-      const phaseLine = needsRecovery ? (phase === "quiet" ? `├─ ${paint(theme, "warning", "Audit quiet — may be stuck")}` : block.lead[0]!)
-        : `├─ ${paint(theme, "accent", phase === "running" ? `Audit running · ${(extras?.auditorProgressSignals !== false ? auditorProgressPhaseLabel(audit) : undefined) ?? auditorPhaseForDisplay(audit, phase, auditorHasLiveEvidence(audit, phase, now))} · detached worker` : phase === "queued" ? "Audit starting · detached worker" : "Audit review pending · detached worker")}`;
+      const phaseLine = toolWait ? `├─ ${paint(theme, "accent", `Waiting on ${sanitizeDisplayText(audit!.currentTool!)}${audit?.round === 2 ? " · second audit pass" : ""} · detached auditor`)}` : needsRecovery ? (phase === "quiet" ? `├─ ${paint(theme, "warning", "Audit quiet — may be stuck")}` : block.lead[0]!)
+        : `├─ ${paint(theme, "accent", phase === "running" ? `Audit running · ${(extras?.auditorProgressSignals !== false ? auditorProgressPhaseLabel(audit) : undefined) ?? auditorPhaseForDisplay(audit, phase, auditorHasLiveEvidence(audit, phase, now), now)} · detached worker` : phase === "queued" ? "Audit starting · detached worker" : "Audit review pending · detached worker")}`;
       const toolLine = block.lead.find(line => /^│ (?:last )?tool:/.test(line));
       const modelRef = auditorCardModelRef(audit, g.pendingCompletion);
       const compactToolLine = modelRef ? toolLine?.split(` · ${modelRef}`)[0] : toolLine;
@@ -2189,7 +2213,7 @@ function goalLines(g: Goal, state: State, audit: AuditDisplayProgress | null | u
         ...(facts.length ? [`│ ${facts.join(" · ")}`] : []),
         ...(elapsed !== undefined ? [`│ audit elapsed ${fmtElapsed(elapsed)}`] : []),
         ...(compactToolLine ? [compactToolLine.startsWith("│ tool:") ? compactToolLine : `│ last tool: ${lastAuditorTool(audit) ?? audit?.currentTool}`] : []),
-        ...(needsRecovery ? (action ? [action] : block.lead.slice(1)) : [`│ No action needed — review applies automatically`]),
+        ...(needsRecovery ? (action ? [action] : block.lead.slice(1)) : [toolWait ? `│ No tool completion yet — timeout handling is automatic` : `│ No action needed — review applies automatically`]),
         `└─ /goal status for full audit details`];
     }
     lines.push(...block.lead);
@@ -2623,6 +2647,35 @@ function completedGoalLines(g: Goal, now: number, theme?: DisplayTheme, width?:
   return [`${paint(theme, "dim", "─")} ${paint(theme, "dim", `${outcome} · ${truncate(recap, objBudget)} · ${tail}`)}`];
 }
 
+function respecBuilderLines(loop: LoopState, now: number, theme?: DisplayTheme, width?: number): string[] {
+  const builder = loop.builder!;
+  const coverage = respecCoverage(builder);
+  const tone = builder.phase === "complete" ? "success" : !loop.active ? "warning" : "accent";
+  const phase = !loop.active && builder.phase === "auditing" ? "Audit held" : builder.phase === "planning" ? "Planning" : builder.phase[0]!.toUpperCase() + builder.phase.slice(1);
+  const current = builder.tasks.find(t => t.status === "pending") ?? builder.tasks.at(-1);
+  const blocker = builder.requirements.find(r => r.status === "blocked");
+  const evidence = [...builder.requirements].reverse().find(r => r.evidence)?.evidence?.report ?? builder.history?.at(-1)?.report;
+  const action = builder.phase === "complete" ? "All adopted requirements independently verified" : !loop.active ? "Work held · /loop status · /loop resume when ready" : builder.phase === "auditing" ? "Independent verification pending · no action needed" : "Work continues · /loop pause · /loop refine";
+  const narrowAction = builder.phase === "complete" ? `All ${coverage.total} requirements verified` : !loop.active ? "/loop resume when ready · /loop status" : builder.phase === "auditing" ? "Independent audit pending · no action" : "Work continues · /loop pause";
+  const progress = loop.active && builder.phase === "auditing" ? getRespecAuditLive(builder) : undefined;
+  const auditLines = loop.active && builder.phase === "auditing" ? progress ? [
+    `auditor: ${progress.phase} · ${fmtElapsed(now - progress.startedAt)} · ${sanitizeDisplayText(progress.model ?? "model pending")}`,
+    `last activity: ${progress.lastActivityAt !== undefined ? `${fmtElapsed(now - progress.lastActivityAt)} ago` : "not observed"}${progress.activity ? ` · ${sanitizeDisplayText(progress.activity)}` : ""}${progress.retryAt !== undefined ? ` · retry in ${fmtElapsed(Math.max(0, progress.retryAt - now))}` : ""}`,
+  ] : ["auditor: waiting for dispatch · no live worker observed"] : [];
+  const title = paint(theme, tone, `Project · ${phase}`);
+  return [
+    `${theme?.bold ? theme.bold(title) : title}${loop.active || builder.phase === "complete" || builder.phase === "auditing" ? "" : " · held"} · increment ${builder.cycle}`,
+    `├─ ${truncate(sanitizeDisplayText(builder.vision), budgetFor(width, 3, 75))}`,
+    `├─ ${paint(theme, coverage.verified > 0 ? "success" : "dim", `verified ${coverage.verified}/${coverage.total}`)} · ${paint(theme, coverage.remaining > 0 ? "warning" : "dim", `remaining ${coverage.remaining} · blocked ${coverage.blocked}`)}`,
+    ...(current ? [`├─ ${builder.phase === "auditing" ? "claim" : "task"}: ${truncate(sanitizeDisplayText(current.text), budgetFor(width, 10, 70))}`] : []),
+    ...auditLines.map(line => `├─ ${paint(theme, progress?.phase === "retrying" ? "warning" : "accent", truncate(line, budgetFor(width, 3, 90)))}`),
+    ...(!loop.active && loop.stopReason ? [`├─ ${paint(theme, "warning", `held: ${truncate(sanitizeDisplayText(loop.stopReason), budgetFor(width, 9, 90))}`)}`] : []),
+    ...(blocker ? [`├─ ${paint(theme, "warning", "blocked")}: ${truncate(sanitizeDisplayText(blocker.blockedReason ?? "reason missing"), budgetFor(width, 12, 70))}`] : []),
+    ...(evidence ? [`├─ ${paint(theme, "dim", `evidence: ${truncate(sanitizeDisplayText(evidence), budgetFor(width, 13, 65))}`)}`] : []),
+    `└─ ${paint(theme, tone, width && width < 60 ? narrowAction : action)}`,
+  ];
+}
+
 function loopLines(l: LoopState, now: number, theme?: DisplayTheme, width?: number, extras?: WidgetExtras): string[] {
   // v0.33.0: slim loop card — header icon names the kind (∞ metricless,
   // ↓/↑ metric), all state folds into middot segments; line 2 is the live

package/extensions/goal-loop-forever.ts

@@ -14,6 +14,7 @@ import { createHash } from "node:crypto";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { piGlaDir } from "./goal-loop-core.js";
+import type { RespecBuilderState } from "./respec-builder.js";
 
 export type LoopDirection = "min" | "max";
 
@@ -167,6 +168,8 @@ export interface LoopState {
   specFile?: string;
   /** Missing-spec respec bootstrap is drafting, not reconciliation. */
   respecPhase?: "draft" | "reconcile";
+  /** Intended-project requirements and independently audited build cycles. */
+  builder?: RespecBuilderState;
   /** Sticky draft handoff: the agent emitted [RESPEC DRAFT COMPLETE] on
    * some earlier turn. Reconciliation still waits for a structurally
    * complete spec; cleared on handoff. */