tickmarkr 2.2.1 → 2.4.0

package/dist/gates/run-gates.js

@@ -11,7 +11,7 @@ import { evidenceGate } from "./evidence.js";
 import { captureLlmOutput } from "./llm.js";
 import { disallowedBy } from "../route/preference.js";
 import { marginalCostRank } from "../route/router.js";
-import { reviewGate } from "./review.js";
+import { pickReviewer, reviewGate } from "./review.js";
 import { scopeGate } from "./scope.js";
 import { shGit } from "../run/git.js";
 import { withJudgeInvocationEvidence } from "../run/journal.js";
@@ -208,24 +208,42 @@ export async function runGates(task, ctx) {
     // executing is added HERE, at the call site that runs it, so a gate that runs twice (the test
     // gate's screen and its full suite) sums to its own cost and never to the span between them.
     const spans = new Map();
+    const loadSamples = new Map();
     // The test gate's two halves, kept apart as well as summed: `durationMs` alone cannot say whether
     // a slow round was a slow subset or a slow full suite, and the parked scheduler's threshold is
     // defined over the full-suite cost.
     let selectedDurationMs;
     let fullDurationMs;
-    const measure = async (gate, run) => {
+    const startMeasurement = () => {
         const at = Date.now();
-        const load1Start = loadProvider();
+        const samples = [loadProvider()];
+        const timer = setInterval(() => samples.push(loadProvider()), 1_000);
+        timer.unref();
+        return () => {
+            clearInterval(timer);
+            samples.push(loadProvider());
+            return { durationMs: Date.now() - at, samples };
+        };
+    };
+    const addMeasurement = (gate, measured) => {
+        const prior = spans.get(gate);
+        const samples = [...(loadSamples.get(gate) ?? []), ...measured.samples];
+        loadSamples.set(gate, samples);
+        spans.set(gate, {
+            durationMs: (prior?.durationMs ?? 0) + measured.durationMs,
+            load1Start: samples[0],
+            load1End: samples[samples.length - 1],
+            load1Max: Math.max(...samples),
+            load1Mean: samples.reduce((sum, value) => sum + value, 0) / samples.length,
+        });
+    };
+    const measure = async (gate, run) => {
+        const finish = startMeasurement();
         try {
             return await run();
         }
         finally {
-            const prior = spans.get(gate);
-            spans.set(gate, {
-                durationMs: (prior?.durationMs ?? 0) + (Date.now() - at),
-                load1Start: prior?.load1Start ?? load1Start,
-                load1End: loadProvider(),
-            });
+            addMeasurement(gate, finish());
         }
     };
     // The measurement is attached at the ONE seam every result leaves this function through, so a
@@ -347,12 +365,11 @@ export async function runGates(task, ctx) {
             // suppresses them anyway; split compareToBaseline only if a tool gate ever gets slow.
             // ponytail: legacy runs adjacent tools in ONE compareToBaseline call, so there is one interval
             // to measure and each of its gates carries it. Split it only if this branch ever stops batching.
-            const batchAt = Date.now();
-            const batchLoadStart = loadProvider();
+            const finish = startMeasurement();
             const toolResults = await compareToBaseline(ctx.worktree, commands, ctx.baseline, [...gates]);
-            const batch = { durationMs: Date.now() - batchAt, load1Start: batchLoadStart, load1End: loadProvider() };
+            const batch = finish();
             for (const g of gates)
-                spans.set(g, batch);
+                addMeasurement(g, batch);
             // The same refusal AFTER the commands, because a green command can dirty the tree the check
             // above just proved clean. Batched, legacy cannot say WHICH command did it, so the refusal
             // lands on the last gate that had one — the round dies there either way. A red battery is
@@ -540,7 +557,7 @@ export async function runGates(task, ctx) {
                 .sort((x, y) => TIER_RANK[y.tier] - TIER_RANK[x.tier] || marginalCostRank(x) - marginalCostRank(y))[0];
             // v1.87 T2: the failover seat obeys the same policy the primary judge just passed — a denied
             // channel is refused here too, never reached by falling through the exclusion arms below.
-            const judgePool = (ctx.judgeChannels ?? ctx.channels).filter((c) => disallowedBy(c, ctx.cfg.routing, "judge") === null);
+            const judgePool = (ctx.judgeChannels ?? []).filter((c) => disallowedBy(c, ctx.cfg.routing, "judge") === null);
             const crossAdapter = pick(judgePool.filter((c) => c.adapter !== flakedAdapter));
             const sameAdapter = pick(judgePool.filter((c) => c.adapter === flakedAdapter && channelKey(c) !== flakedKey));
             // Prefer a different adapter; if the fleet only has one adapter, retry on a different channel of
@@ -575,12 +592,10 @@ export async function runGates(task, ctx) {
             invocations.push(...captured.invocations);
             return captured.value;
         };
-        let rv = await dispatch((adapters) => reviewGate(task, ctx.worktree, ctx.baseRef, ctx.author, ctx.channels, adapters, ctx.cfg, ctx.via, ctx.excludeReviewers, ctx.artifactDir));
-        // OBS-193: an unparseable review verdict retries the REVIEW exactly once on a different reviewer —
-        // never the worker (GATE-09's judge-retry shape: straight-line single `if`, meta-only detection,
-        // the flaked verdict never enters results). The exclusion rides reviewGate's own excludeReviewers
-        // parameter, so pickReviewer's diversity rules still govern the retry seat; a fleet with no second
-        // eligible seat keeps the ORIGINAL result so the recorded cause stays truthful (OBS-196).
+        let rv = await dispatch((adapters) => reviewGate(task, ctx.worktree, ctx.baseRef, ctx.author, ctx.channels, adapters, ctx.cfg, ctx.via, ctx.excludeReviewers, ctx.artifactDir, ctx.reviewHistory));
+        // OBS-193/574: an unparseable review verdict retries the REVIEW exactly once, preferring a
+        // different adapter. Only a single-adapter eligible pool may fall back to another channel on the
+        // flaked adapter. The flaked verdict never enters results; an exhausted pool preserves its cause.
         if (rv.meta?.unparseable === true && typeof rv.meta.reviewer === "string") {
             const flaked = rv.meta.reviewer;
             const emptyOutput = rv.meta.cause === "empty-output";
@@ -594,15 +609,24 @@ export async function runGates(task, ctx) {
             const retryVia = ctx.via
                 ? { ...ctx.via, nameFor: (role, adapter) => ctx.via.nameFor(role, adapter) + "-r1" }
                 : undefined;
-            const second = await dispatch((adapters) => reviewGate(task, ctx.worktree, ctx.baseRef, ctx.author, ctx.channels, adapters, ctx.cfg, retryVia, [...(ctx.excludeReviewers ?? []), flaked], ctx.artifactDir));
+            const priorExclusions = ctx.excludeReviewers ?? [];
+            const flakedAdapter = flaked.slice(0, flaked.indexOf(":"));
+            const adapterExclusions = ctx.channels.filter((c) => c.adapter === flakedAdapter).map(channelKey);
+            const crossAdapter = pickReviewer(ctx.author, ctx.channels, [...priorExclusions, ...adapterExclusions], ctx.cfg.review.prefer ?? [], task.routingHints?.floor);
+            const exclusion = crossAdapter ? "adapter" : "channel";
+            const retryExclusions = [...priorExclusions, ...(crossAdapter ? adapterExclusions : [flaked])];
+            const second = await dispatch((adapters) => reviewGate(task, ctx.worktree, ctx.baseRef, ctx.author, ctx.channels, adapters, ctx.cfg, retryVia, retryExclusions, ctx.artifactDir, ctx.reviewHistory));
             if (second.meta?.noEligibleReviewer !== true) {
                 const retried = typeof second.meta?.reviewer === "string" ? second.meta.reviewer : "none";
+                const route = exclusion === "adapter"
+                    ? `different-adapter retry; excluded flaked adapter ${flakedAdapter}`
+                    : `same-adapter fallback; excluded flaked channel ${flaked}`;
                 rv = {
                     ...second,
                     // `details` is lifted onto the journal's gate-result row; meta.reviewRetry is not. Keep the
                     // re-route visible in the result text a reader actually opens, including on a red retry.
-                    details: `review re-route: ${flaked} produced ${emptyOutput ? "EMPTY output" : "no parseable verdict"}; replaced by ${retried}\n${second.details}`,
-                    meta: { ...second.meta, reviewRetry: { flaked, retried } },
+                    details: `review re-route (${route}): ${flaked} produced ${emptyOutput ? "EMPTY output" : "no parseable verdict"}; replaced by ${retried}\n${second.details}`,
+                    meta: { ...second.meta, reviewRetry: { flaked, retried, exclusion } },
                 };
             }
             else if (task.routingHints?.floor) {
@@ -623,11 +647,11 @@ export async function runGates(task, ctx) {
     // The check runs BEFORE any gate, so on a clean tree it belongs to no gate: charging every round's
     // first gate for it would inflate the one measurement the parked recalibrations key on. It becomes
     // that gate's interval only on the path where it IS what the gate did — the refusal below.
-    const entryAt = Date.now();
-    const entryLoad = loadProvider();
+    const finishEntry = startMeasurement();
     const entryDirt = sequence.length ? await dirtyWorktree() : undefined;
+    const entryMeasurement = finishEntry();
     if (entryDirt) {
-        spans.set(sequence[0], { durationMs: Date.now() - entryAt, load1Start: entryLoad, load1End: loadProvider() });
+        addMeasurement(sequence[0], entryMeasurement);
         await emitStart(sequence[0]);
         await record(dirtyRefusal(sequence[0], entryDirt));
         return done();

package/dist/gates/verdict-cause.d.ts

@@ -1,4 +1,8 @@
 export type VerdictDiscriminator = "approve" | "pass" | "ok" | "action";
-export type VerdictUnparseableCause = "empty-output" | "no-verdict" | "malformed-verdict";
+export type VerdictUnparseableCause = "empty-output" | "no-verdict" | "malformed-verdict" | "timeout" | "startup-failure";
+export interface VerdictProcessFacts {
+    timedOut?: boolean;
+    exitCode?: number;
+}
 export declare function hasVerdictParticipationWitness(raw: string, nonce: string, discriminator: VerdictDiscriminator): boolean;
-export declare function classifyVerdictCause(raw: string, nonce: string, discriminator: VerdictDiscriminator): VerdictUnparseableCause;
+export declare function classifyVerdictCause(raw: string, nonce: string, discriminator: VerdictDiscriminator, process?: VerdictProcessFacts): VerdictUnparseableCause;

package/dist/gates/verdict-cause.js

@@ -54,10 +54,14 @@ export function hasVerdictParticipationWitness(raw, nonce, discriminator) {
     const discriminatorPattern = new RegExp(String.raw `"${discriminator}"\s*:\s*${valuePattern}\s*[,}]`);
     return objectPrefixes(raw).some((prefix) => noncePattern.test(prefix) && discriminatorPattern.test(prefix));
 }
-export function classifyVerdictCause(raw, nonce, discriminator) {
+export function classifyVerdictCause(raw, nonce, discriminator, process = {}) {
+    if (process.timedOut)
+        return "timeout";
     if (raw.trim().length === 0)
         return "empty-output";
-    return hasVerdictParticipationWitness(raw, nonce, discriminator)
-        ? "malformed-verdict"
-        : "no-verdict";
+    if (hasVerdictParticipationWitness(raw, nonce, discriminator))
+        return "malformed-verdict";
+    if (process.exitCode !== undefined && process.exitCode !== 0)
+        return "startup-failure";
+    return "no-verdict";
 }

package/dist/route/preference.d.ts

@@ -5,6 +5,10 @@ export interface Disallowed {
     entry: string;
 }
 export type PreferenceRole = "worker" | "judge" | "review" | "consult";
+export declare function routingModelProvider(model: string, fallback?: string): string;
+export declare const modelRouteIdentity: (model: string, fallback?: string) => string;
+export declare const channelRouteIdentity: (key: string, fallback?: string) => string;
+export declare function routingEntrySeatLines(cfg: TickmarkrConfig): string[];
 export declare function excludedChannels(cfg: TickmarkrConfig, adapters: {
     id: string;
 }[] | string[], health: Record<string, AuthHealth>): {

package/dist/route/preference.js

@@ -1,6 +1,46 @@
 import { channelKey, channelsFromConfig } from "../adapters/types.js";
 import { validateGraph } from "../graph/schema.js";
 import { route, RoutingError } from "./router.js";
+const PREFERENCE_ROLES = ["worker", "judge", "review", "consult"];
+// Keep routing retries on the same identity review diversity uses: the served provider plus the
+// unprefixed model id. Gate review owns the original modelProvider policy; this dependency-leaf copy
+// avoids importing gates back into route/run and must move with that helper when the scope permits.
+export function routingModelProvider(model, fallback = "unknown") {
+    const id = model.toLowerCase();
+    const prefix = id.includes("/") ? id.slice(0, id.indexOf("/")) : "";
+    if (prefix === "openai" || prefix === "openai-codex" || /^(?:gpt|o\d)/.test(id))
+        return "openai";
+    if (prefix === "anthropic" || /^(?:claude|opus|sonnet|haiku|fable)(?:-|$)/.test(id))
+        return "anthropic";
+    if (prefix === "google" || /^gemini(?:-|$)/.test(id))
+        return "google";
+    if (prefix === "xai" || /^grok(?:-|$)/.test(id))
+        return "xai";
+    if (["zai", "zhipu", "zai-coding-plan"].includes(prefix) || /^glm(?:-|$)/.test(id))
+        return "zhipu";
+    if (["kimi-code", "moonshot"].includes(prefix) || /^kimi(?:-|$)/.test(id))
+        return "moonshot";
+    return fallback;
+}
+export const modelRouteIdentity = (model, fallback = "unknown") => `${routingModelProvider(model, fallback)}/${model.slice(model.lastIndexOf("/") + 1).toLowerCase()}`;
+export const channelRouteIdentity = (key, fallback = "unknown") => {
+    const i = key.indexOf(":");
+    return i < 0 ? key : modelRouteIdentity(key.slice(i + 1), fallback);
+};
+export function routingEntrySeatLines(cfg) {
+    const lines = [];
+    const add = (path, entries, roles) => {
+        for (const entry of entries ?? [])
+            lines.push(`${path} '${entry}' reaches seats: ${roles.join(", ")}`);
+    };
+    add("routing.allow.adapters", cfg.routing.allow?.adapters, PREFERENCE_ROLES);
+    add("routing.allow.models", cfg.routing.allow?.models, PREFERENCE_ROLES);
+    add("routing.deny.adapters", cfg.routing.deny?.adapters, PREFERENCE_ROLES);
+    add("routing.deny.models", cfg.routing.deny?.models, PREFERENCE_ROLES);
+    add("routing.deny.workers.adapters", cfg.routing.deny?.workers?.adapters, ["worker"]);
+    add("routing.deny.workers.models", cfg.routing.deny?.workers?.models, ["worker"]);
+    return lines;
+}
 const adapterIds = (adapters) => typeof adapters[0] === "string" ? adapters : adapters.map((a) => a.id);
 export function excludedChannels(cfg, adapters, health) {
     const { allow, deny } = cfg.routing;

package/dist/route/router.js

@@ -1,6 +1,6 @@
 import { channelKey, channelsFromConfig } from "../adapters/types.js";
 import { TIER_RANK } from "../config/config.js";
-import { disallowedBy } from "./preference.js";
+import { channelRouteIdentity, disallowedBy, modelRouteIdentity, routingModelProvider } from "./preference.js";
 import { cellOf, EXPLORE_CAP, explorationBonus, learnedScore, MIN_SAMPLES } from "./profile.js";
 export const NO_EXPLORE_ENV = "TICKMARKR_NO_EXPLORE";
 // OBS-89 (v1.60): the TICKMARKR_QUALITY variable is RETIRED — nothing in src reads it anymore and
@@ -337,7 +337,20 @@ export function nextChannel(current, task, cfg, channels, tried, profile, exclud
     // profile-dependent filter. NO exploration bonus here (route():110 has one; a probe on the
     // failure path would spend a real retry). Absent profile ⇒ every score is 0 ⇒ third key
     // all-ties ⇒ the stable sort preserves the exact v1.7 candidate ORDER.
-    const pool = channels.filter((c) => !tried.includes(channelKey(c)) && TIER_RANK[c.tier] >= TIER_RANK[current.tier]);
+    const triedKeys = new Set(tried);
+    const triedIdentities = new Set(tried.map((key) => {
+        const channel = channels.find((c) => channelKey(c) === key);
+        return channel ? modelRouteIdentity(channel.model, channel.vendor) : channelRouteIdentity(key);
+    }));
+    // excludeAdapter is expanded by the daemon into every channel key of the failed adapter. Once that
+    // complete set is present, the outage follows the current served provider across gateway aliases.
+    const currentAdapterExcluded = channels.some((c) => c.adapter === current.adapter)
+        && channels.filter((c) => c.adapter === current.adapter).every((c) => triedKeys.has(channelKey(c)));
+    const currentChannel = channels.find((c) => c.adapter === current.adapter && c.model === current.model);
+    const excludedProvider = currentAdapterExcluded ? routingModelProvider(current.model, currentChannel?.vendor) : undefined;
+    const pool = channels.filter((c) => !triedIdentities.has(modelRouteIdentity(c.model, c.vendor))
+        && (!excludedProvider || routingModelProvider(c.model, c.vendor) !== excludedProvider)
+        && TIER_RANK[c.tier] >= TIER_RANK[current.tier]);
     const scores = new Map(pool.map((c) => [channelKey(c), profile ? learnedScore(profile, task.shape, channelKey(c), c.channel, { availWeight: cfg.routing.learnedTuning?.availWeight }) : 0]));
     const scoreOf = (c) => scores.get(channelKey(c));
     const candidates = pool.sort((a, b) => TIER_RANK[a.tier] - TIER_RANK[b.tier] || marginalCostRank(a) - marginalCostRank(b) || scoreOf(b) - scoreOf(a));

package/dist/run/consult.d.ts

@@ -9,6 +9,7 @@ export interface ConsultVerdict {
     reason?: string;
     guidance?: string;
     excludeAdapter?: string;
+    excludeProvider?: string;
     adapter?: string;
     model?: string;
     vendor?: string;

package/dist/run/consult.js

@@ -4,7 +4,7 @@ import { getAdapter } from "../adapters/registry.js";
 import { bannerShell, paneDispatchCommand } from "../brand.js";
 import { dewrapPaneVerdict, extractVerdictJson, gateExitTrailer, gatePaneName, generateVerdictNonce, verdictNonceLine } from "../gates/llm.js";
 import { classifyVerdictCause } from "../gates/verdict-cause.js";
-import { disallowedBy } from "../route/preference.js";
+import { disallowedBy, routingModelProvider } from "../route/preference.js";
 import { sh } from "./git.js";
 import { redactSecrets } from "./redact.js";
 import { filterLlmTranscript } from "./stall.js";
@@ -59,6 +59,22 @@ export function augmentRetryBrief(feedback, opts) {
     return parts.join("\n\n");
 }
 const ACTIONS = ["retry", "reroute", "decompose", "human"];
+function excludedProviderFromDossier(d, adapter) {
+    try {
+        const events = JSON.parse(d.journalTail);
+        const assignment = [...events].reverse().find((event) => event.event === "task-dispatch"
+            && event.data?.assignment?.adapter === adapter
+            && typeof event.data.assignment.model === "string")?.data?.assignment;
+        if (typeof assignment?.model !== "string")
+            return undefined;
+        const provider = routingModelProvider(assignment.model);
+        return provider === "unknown" ? undefined : provider;
+    }
+    catch {
+        // Legacy/non-JSON dossier tails retain the adapter exclusion without inventing a provider.
+        return undefined;
+    }
+}
 export function parseConsultVerdict(out, nonce) {
     const v = extractVerdictJson(out, nonce);
     if (!v)
@@ -110,10 +126,10 @@ ${d.journalTail}
 Verdict meanings: retry = same assignment with your notes as feedback; reroute = different CLI/model;
 decompose = task too big, needs human re-planning; human = a person must look at this.
 
-On reroute only, optional excludeAdapter is an adapter id (e.g. "cursor-agent") that bans EVERY
-channel of that adapter for this task. Use it for environmental failures ("the CLI is blocked",
-trust dialog, broken install) — not when a single model produced bad code. Omit for model-level
-reroutes so other models of the same adapter remain eligible.
+On reroute only, optional excludeAdapter is the failed adapter id (e.g. "cursor-agent"). Tickmarkr
+resolves the adapter's current model to its provider and bans that provider for this task. Use it for
+environmental/provider failures ("the CLI is blocked", trust dialog, broken install) — not when a
+single model produced bad code. Omit for model-level reroutes so other models remain eligible.
 
 ${verdictNonceLine(nonce)}
 
@@ -147,6 +163,10 @@ opts = {}) {
             out = r.stdout + r.stderr;
         }
         else {
+            // Preserve the adapter contract for CLIs that cannot seed their TUI: supported adapters use
+            // the interactive form, while a declared null keeps the existing visible print fallback.
+            const command = adapter.interactiveCommand(promptFile, seatModel)
+                ?? adapter.headlessCommand(promptFile, seatModel);
             // T8: role-first pane name for fleet visibility (consult · T2); consultSeq stays on the dossier artifact only
             const slot = await driver.slot(cwd, gatePaneName("consult", d.taskId), {
                 label: `CONSULT ${d.taskId}`,
@@ -158,7 +178,7 @@ opts = {}) {
             writeFileSync(scriptPath, [
                 "export BASH_SILENCE_DEPRECATION_WARNING=1",
                 bannerShell(),
-                adapter.headlessCommand(promptFile, seatModel),
+                command,
                 gateExitTrailer(nonce),
             ].join("\n"));
             try {
@@ -226,8 +246,19 @@ opts = {}) {
     for (const [i, seat] of allowedSeats.entries()) {
         try {
             const parsed = await invokeSeat(seat.adapter, seat.model, i);
-            if (parsed.verdict)
-                return { ...parsed.verdict, ...seatIdentity(seat) };
+            if (parsed.verdict) {
+                const excludeProvider = parsed.verdict.excludeAdapter
+                    ? excludedProviderFromDossier(d, parsed.verdict.excludeAdapter)
+                    : undefined;
+                return {
+                    ...parsed.verdict,
+                    ...(excludeProvider ? {
+                        excludeProvider,
+                        notes: `${parsed.verdict.notes} — excluded provider ${excludeProvider}`,
+                    } : {}),
+                    ...seatIdentity(seat),
+                };
+            }
         }
         catch {
             // failed seat (unknown adapter, dead driver/pane, shell error) — fall to the next entry

package/dist/run/daemon.d.ts

@@ -68,6 +68,7 @@ export declare function formatSummary(s: RunSummary): string;
  *  run id (cli/commands/status.ts positionalRunId), so naming it here is what stops the board from
  *  following the newest journal in a repo that already carries a second, newer run — a board showing
  *  the wrong run is a recorded incident (skills/tickmarkr-overseer/SKILL.md). */
+export declare const daemonEntrypoint: string;
 export declare const watchCommand: (runId: string) => string;
 /**
  * R3 (OBS-186): a gate that DECLINED to run is not a gate that failed. The review gate's skip branch
@@ -102,6 +103,11 @@ export declare const gateSatisfied: (g: GateResult) => boolean;
  * A round is the gate-result span opened by each `gates` phase-start, per task.
  */
 export declare function decisiveReviewRounds(events: JournalEvent[]): JournalEvent[];
+export declare const SUITE_POLL_MS = 250;
+export declare const SUITE_WAIT_CEILING_MS = 600000;
+export declare const setSuiteWaitCeilingForTests: (ms: number) => void;
+export declare const resetSuiteWaitCeilingForTests: () => void;
+export declare const APPROVAL_POLL_MS = 250;
 export declare const EARLY_LAUNCH_LIVENESS_MS = 60000;
 /** Test seam — lowers the empty-pane liveness window without sleeping 60s per case. */
 export declare function setEarlyLaunchLivenessMsForTests(ms: number): void;
@@ -141,6 +147,16 @@ export declare function verifyIntegrationTipCached(intWt: string, commands: Reco
     lastMergedTask?: string;
     baseline?: Baseline;
 }): Promise<boolean>;
+type SuitePidProbe = (pid: number) => number | undefined;
+/** Count full-suite roots in one process-table snapshot. The probes are arguments so the ownership
+ * rules remain testable on hosts that forbid process inspection; production supplies cwd and the
+ * inherited TICKMARKR_SUITE_PARENT marker from the process itself. */
+export declare function countLiveSuites(snapshot: string, repoRoot: string, daemonPid?: number, cwdForPid?: (pid: number) => string | undefined, suiteParentForPid?: SuitePidProbe): number;
+export declare const setLiveSuiteCountForTests: (probe: (repoRoot: string) => Promise<number>) => void;
+export declare const resetLiveSuiteCountForTests: () => void;
+/** Live full-suite roots attributable to this repository or this daemon. Ancestors are excluded so
+ * a daemon invoked by vitest does not wait on its own test harness forever. */
+export declare function liveSuiteCount(repoRoot: string): Promise<number>;
 /** Test seam — exercise the production observer's total read bound with a small real tree. */
 export declare function setObserveBudgetBytesForTests(bytes: number): void;
 export declare function resetObserveBudgetBytesForTests(): void;