pi-goal-list-loop-audit 0.36.0 → 0.37.1

package/CHANGELOG.md

@@ -1,5 +1,106 @@
 # Changelog
 
+## 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
+  Terminal archival now records a durable intent before publication and
+  reconciles interrupted archive/state commits on startup, preventing a
+  published archive from resurrecting an active goal or permanently fencing
+  the next archive attempt.
+
+  Destructive queue operations now fail closed when sidecar cleanup cannot be
+  proven successful. List clear/cancel/remove, group close, carryover, wipe,
+  and repair-source consumption preserve recoverable durable work instead of
+  mutating memory and allowing a failed deletion to reappear after restart.
+
+  The active ledger now rotates into immutable, ownership-fenced segments and
+  keeps a complete current-state snapshot in the active file. Startup recovery
+  handles the rename-before-rewrite interruption window while forensic history
+  remains available.
+
+  Bounded scanners and streaming reducers now back list depth, log tails,
+  switch logs, postaudit cadence, and multi-project statistics. Detached
+  auditor scratch now has a read-only health report plus age-bounded cleanup
+  limited to worker identities proven dead; ambiguous directories remain
+  untouched.
+
+  The runtime-global bridge now has one compile-checked registration registry
+  and typed high-risk lifecycle fields, reducing silent name and shape drift.
+
+### Changed
+  `release:check` now packs, installs, and imports the actual npm tarball in a
+  temporary directory, including the shipped goal entry point and auditor
+  launcher/worker paths. No registry publish is performed by the smoke.
+
 ## 0.36.0 — event-driven long-running supervision (2026-08-28)
 
 ### Added

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.
@@ -259,6 +264,9 @@ templates, themes, or context files, so its model must be usable in a plain pi
 session. It is independent verification, not an OS sandbox: the auditor's
 `bash` tool can still change files if a prompt or verifier tells it to. Keep
 verification commands bounded and treat repository permissions accordingly.
+On Linux, both direct contract checks and the detached auditor enforce a
+256-process process-group ceiling to contain recursive helper/test launches;
+cross-platform timeout and process-tree cleanup remain in place as well.
 
 ## Recommended pi extensions
 
@@ -270,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
 
@@ -339,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-long-running-supervision.md

@@ -22,6 +22,11 @@ GLLA automation is **event-driven and progress-aware**, not duration-guessed.
   Detached auditors have no unconditional wall-clock expiry: legacy wall
   metadata is ignored, while confirmed silence and an individual tool timeout
   remain the bounded safety mechanisms.
+- Project verification commands run in an owned process group. On Linux, GLLA
+  also counts that group every 100ms and aborts it above 256 processes; this
+  catches recursive test/helper launches before a long wall timeout can become
+  a host-wide process or swap storm. The limit is a containment result, never
+  an automatic retry.
 - Timers remain useful for per-attempt backoff, watchdogs, and host safety. A
   timer is never evidence that work completed and is not the definition of a
   long-running process's lifetime. Detached-auditor first-event silence starts

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,34 +10,35 @@ 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.0 continue through the supervisor freeze (`/glla pause`),
+  v0.35.14–v0.37.1 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
   subagent recovery, bounded repair/replan recovery, production RPC child
   stopping, mandatory hermetic auditor-extension validation, optional provider
-  extensions, and bounded zero-stream retry containment — see CHANGELOG.md for
-  the full trail.
+  extensions, bounded zero-stream retry containment, crash-safe persistence,
+  and packed-artifact release verification — see CHANGELOG.md for the full
+  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 {