@tea-agent/loop-agent 0.1.0-fe-test.0

package/dist/worker/console/night-aux-ticker.js

@@ -0,0 +1,146 @@
+import { resolveSiblingAgentWorkerBin } from "./sibling-controller.js";
+import { DEFAULT_CLOCK_INTERVAL_SEC } from "../scheduler/clock.js";
+export const NIGHT_AUX_TICKER_DISCLAIMER = "仅在本 Console 进程开着时有效；关掉 Console 或睡觉后不会 tick。过夜无人值守请安装 OS clock：agent-worker scheduler clock install --repo .";
+/**
+ * Optional Console-foreground scheduler ticker.
+ * Spawns sibling `agent-worker scheduler tick` so long dispatches do not block
+ * the Console HTTP event loop the way an in-process await would.
+ */
+export class NightAuxTicker {
+    deps;
+    enabled = false;
+    timer = null;
+    inFlight = false;
+    intervalSec;
+    now;
+    lastAttemptAt = null;
+    lastCompletedAt = null;
+    lastOutcome = null;
+    lastError = null;
+    lastSummary = null;
+    constructor(deps) {
+        this.deps = deps;
+        this.intervalSec = Math.max(15, Math.min(3600, deps.intervalSec ?? DEFAULT_CLOCK_INTERVAL_SEC));
+        this.now = deps.now ?? (() => new Date());
+        if (deps.autoStart !== false) {
+            this.enabled = true;
+            this.startTimer();
+            void this.fire("enable");
+        }
+    }
+    status() {
+        return {
+            schemaVersion: 1,
+            enabled: this.enabled,
+            running: this.inFlight,
+            intervalSec: this.intervalSec,
+            scope: "console-foreground",
+            disclaimer: NIGHT_AUX_TICKER_DISCLAIMER,
+            lastAttemptAt: this.lastAttemptAt,
+            lastCompletedAt: this.lastCompletedAt,
+            lastOutcome: this.lastOutcome,
+            lastError: this.lastError,
+            lastSummary: this.lastSummary,
+        };
+    }
+    setEnabled(enabled) {
+        if (enabled === this.enabled)
+            return this.status();
+        this.enabled = enabled;
+        if (enabled) {
+            this.startTimer();
+            void this.fire("enable");
+        }
+        else {
+            this.stopTimer();
+        }
+        return this.status();
+    }
+    dispose() {
+        this.enabled = false;
+        this.stopTimer();
+    }
+    startTimer() {
+        this.stopTimer();
+        this.timer = setInterval(() => {
+            void this.fire("interval");
+        }, this.intervalSec * 1000);
+        // Do not keep the process alive solely for the aux ticker.
+        this.timer.unref?.();
+    }
+    stopTimer() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    async fire(_reason) {
+        if (!this.enabled)
+            return;
+        if (this.inFlight) {
+            this.lastOutcome = "skipped";
+            this.lastSummary = "previous tick still running";
+            return;
+        }
+        this.inFlight = true;
+        this.lastAttemptAt = this.now().toISOString();
+        this.lastError = null;
+        try {
+            const result = await (this.deps.runTick
+                ? this.deps.runTick()
+                : this.defaultRunTick());
+            this.lastCompletedAt = this.now().toISOString();
+            if (result.ok) {
+                this.lastOutcome = "ok";
+                this.lastSummary = result.summary;
+                this.lastError = null;
+            }
+            else {
+                this.lastOutcome = "error";
+                this.lastSummary = result.summary;
+                this.lastError = result.error ?? result.summary;
+            }
+        }
+        catch (error) {
+            this.lastCompletedAt = this.now().toISOString();
+            this.lastOutcome = "error";
+            this.lastError = error instanceof Error ? error.message : String(error);
+            this.lastSummary = null;
+        }
+        finally {
+            this.inFlight = false;
+        }
+    }
+    async defaultRunTick() {
+        const bin = resolveSiblingAgentWorkerBin();
+        const result = await this.deps.client.runExternal(bin, [
+            "scheduler",
+            "tick",
+            "--repo",
+            this.deps.repoRoot,
+            "--clock-source",
+            "manual",
+            "--json",
+        ], {
+            cwd: this.deps.repoRoot,
+            artifactName: "console-night-aux-tick",
+            expectJson: true,
+        });
+        if (!result.ok || result.exitCode !== 0) {
+            const message = (result.stderr || result.stdout || "").trim() ||
+                `scheduler tick exit ${result.exitCode}`;
+            return { ok: false, summary: message, error: message };
+        }
+        const json = result.json;
+        const claimed = Array.isArray(json?.claimed) ? json.claimed.length : 0;
+        const dispatched = Array.isArray(json?.dispatched)
+            ? json.dispatched.length
+            : 0;
+        const waiting = Array.isArray(json?.waiting) ? json.waiting.length : 0;
+        const skipped = Array.isArray(json?.skipped) ? json.skipped.length : 0;
+        return {
+            ok: true,
+            summary: `claimed=${claimed} dispatched=${dispatched} waiting=${waiting} skipped=${skipped}`,
+        };
+    }
+}

package/dist/worker/console/observe-health-match.js

@@ -0,0 +1,179 @@
+/**
+ * Observe link capability mapping + retired cross-process health-match stubs.
+ * Wave 5: independent observe serve (8787) is removed; doctor uses Console surface.
+ * capabilityForObserveTarget remains for Inspect deep-links / night-jobs.
+ */
+/** @deprecated Wave 5 — observe serve removed; use agent-worker console */
+export const OBSERVE_START_COMMAND = "agent-worker console --repo . --port 8790";
+/** @deprecated Wave 5 — default unified Console origin (not independent Observe) */
+export const DEFAULT_OBSERVE_BASE_URL = "http://127.0.0.1:8790";
+export function capabilityForObserveTarget(target) {
+    switch (target.kind) {
+        case "dag":
+            return "dagRun";
+        case "task":
+            return "task";
+        case "feature":
+            return "feature";
+        case "worker":
+            return "workerRun";
+        case "batch":
+            return "batch";
+        case "night":
+            return "nightJobs";
+        default: {
+            const _exhaustive = target;
+            throw new Error(`capabilityForObserveTarget: unsupported ${JSON.stringify(_exhaustive)}`);
+        }
+    }
+}
+/**
+ * Classify Console/Inspect /api/health body against local repo fingerprint + capability.
+ * Pure function — no I/O. Prefer unified Console origin (8790), not retired 8787 Observe.
+ */
+export function classifyObserveHealth(input) {
+    const url = input.healthUrl ?? `${DEFAULT_OBSERVE_BASE_URL}/api/health`;
+    const startCommand = OBSERVE_START_COMMAND;
+    const body = input.healthBody;
+    if (body === null || body === undefined || typeof body !== "object") {
+        return {
+            status: "unavailable",
+            url,
+            message: "Operator surface health body missing or not JSON object",
+            startCommand,
+            body,
+            localFingerprint: input.localFingerprint,
+            requiredCapability: input.requiredCapability,
+        };
+    }
+    const health = body;
+    if (health.ok !== true) {
+        return {
+            status: "unavailable",
+            url,
+            message: "Operator surface health ok !== true",
+            startCommand,
+            body,
+            localFingerprint: input.localFingerprint,
+            requiredCapability: input.requiredCapability,
+        };
+    }
+    const schemaVersion = typeof health.schemaVersion === "number" ? health.schemaVersion : undefined;
+    if (schemaVersion !== 1) {
+        return {
+            status: "mismatch",
+            url,
+            message: `Operator surface schemaVersion mismatch (expected 1, got ${String(health.schemaVersion)})`,
+            startCommand,
+            body,
+            localFingerprint: input.localFingerprint,
+            schemaVersion,
+            requiredCapability: input.requiredCapability,
+        };
+    }
+    const remoteFingerprint = typeof health.repoFingerprint === "string"
+        ? health.repoFingerprint
+        : undefined;
+    if (!remoteFingerprint || remoteFingerprint !== input.localFingerprint) {
+        return {
+            status: "mismatch",
+            url,
+            message: "Operator surface repoFingerprint does not match local worktree",
+            startCommand,
+            body,
+            localFingerprint: input.localFingerprint,
+            remoteFingerprint,
+            schemaVersion,
+            requiredCapability: input.requiredCapability,
+        };
+    }
+    if (input.requiredCapability) {
+        const caps = health.routeCapabilities ?? {};
+        const capabilityOk = caps[input.requiredCapability] === true;
+        if (!capabilityOk) {
+            return {
+                status: "mismatch",
+                url,
+                message: `Operator surface missing route capability: ${input.requiredCapability}`,
+                startCommand,
+                body,
+                localFingerprint: input.localFingerprint,
+                remoteFingerprint,
+                schemaVersion,
+                requiredCapability: input.requiredCapability,
+                capabilityOk: false,
+            };
+        }
+        return {
+            status: "match",
+            url,
+            message: "Operator surface health matches local repo and required capability",
+            startCommand,
+            body,
+            localFingerprint: input.localFingerprint,
+            remoteFingerprint,
+            schemaVersion,
+            requiredCapability: input.requiredCapability,
+            capabilityOk: true,
+        };
+    }
+    return {
+        status: "match",
+        url,
+        message: "Operator surface health matches local repo",
+        startCommand,
+        body,
+        localFingerprint: input.localFingerprint,
+        remoteFingerprint,
+        schemaVersion,
+    };
+}
+/**
+ * Probe /api/health and classify against local fingerprint.
+ * Network failure → unavailable. Prefer Console origin; independent Observe serve is removed.
+ */
+export async function probeAndClassifyObserve(input) {
+    const base = input.baseUrl.replace(/\/+$/, "");
+    const healthUrl = `${base}/api/health`;
+    const fetchImpl = input.fetchImpl ?? fetch;
+    const timeoutMs = input.timeoutMs ?? 1500;
+    try {
+        const response = await fetchImpl(healthUrl, {
+            method: "GET",
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!response.ok) {
+            return {
+                status: "unavailable",
+                url: healthUrl,
+                message: `HTTP ${response.status}`,
+                startCommand: OBSERVE_START_COMMAND,
+                localFingerprint: input.localFingerprint,
+                requiredCapability: input.requiredCapability,
+            };
+        }
+        let body;
+        try {
+            body = await response.json();
+        }
+        catch {
+            body = undefined;
+        }
+        return classifyObserveHealth({
+            localFingerprint: input.localFingerprint,
+            healthBody: body,
+            requiredCapability: input.requiredCapability,
+            healthUrl,
+        });
+    }
+    catch (error) {
+        return {
+            status: "unavailable",
+            url: healthUrl,
+            message: error instanceof Error ? error.message : String(error),
+            startCommand: OBSERVE_START_COMMAND,
+            localFingerprint: input.localFingerprint,
+            requiredCapability: input.requiredCapability,
+        };
+    }
+}

package/dist/worker/console/observe-link.js

@@ -0,0 +1,42 @@
+/**
+ * Deprecated Observe deep-link compatibility helpers.
+ * New unified-surface callers should use buildInspectDeepLink.
+ */
+import { buildInspectUrl, selectionFromObserveLinkTarget, } from "./operator-selection.js";
+function stripTrailingSlash(baseUrl) {
+    return baseUrl.replace(/\/+$/, "");
+}
+/**
+ * Build a browser URL into an independent Observe instance.
+ * Shape mirrors Observe hash routes (`#/dag/...`, `#/task/...`, …).
+ */
+export function buildObserveDeepLink(baseUrl, target) {
+    const base = stripTrailingSlash(baseUrl.trim());
+    if (!base) {
+        throw new Error("buildObserveDeepLink: baseUrl is required");
+    }
+    switch (target.kind) {
+        case "dag":
+            return `${base}/#/dag/${encodeURIComponent(target.dagRunId)}`;
+        case "task":
+            return `${base}/#/task/${encodeURIComponent(target.taskId)}`;
+        case "feature":
+            return `${base}/#/feature/${encodeURIComponent(target.featureId)}`;
+        case "worker":
+            return `${base}/#/run/${encodeURIComponent(target.workerRunId)}`;
+        case "batch":
+            return `${base}/#/batch/${encodeURIComponent(target.batchRunId)}`;
+        case "night":
+            return target.scheduleId
+                ? `${base}/#/night/${encodeURIComponent(target.scheduleId)}`
+                : `${base}/#/night`;
+        default: {
+            const _exhaustive = target;
+            throw new Error(`buildObserveDeepLink: unsupported target ${JSON.stringify(_exhaustive)}`);
+        }
+    }
+}
+/** Build a canonical same-origin Inspect URL for the unified Operator surface. */
+export function buildInspectDeepLink(origin, target) {
+    return buildInspectUrl(origin, selectionFromObserveLinkTarget(target));
+}

package/dist/worker/console/open-browser.js

@@ -0,0 +1,134 @@
+import { spawn } from "node:child_process";
+/**
+ * Decide whether Console should attempt to open a system browser after listen.
+ * Explicit `--no-open` wins over every automatic skip rule.
+ */
+export function shouldOpenConsoleBrowser(input) {
+    if (input.noOpen)
+        return false;
+    if (isTruthyEnv(input.env.CI))
+        return false;
+    if (input.env.SSH_CONNECTION ||
+        input.env.SSH_CLIENT ||
+        input.env.SSH_TTY) {
+        return false;
+    }
+    if (!input.stdoutIsTTY)
+        return false;
+    if (input.platform === "linux") {
+        const display = input.env.DISPLAY?.trim();
+        const wayland = input.env.WAYLAND_DISPLAY?.trim();
+        if (!display && !wayland)
+            return false;
+    }
+    return true;
+}
+/**
+ * Normalize wildcard bind hosts to a browser-reachable loopback URL.
+ * Non-wildcard hosts are left unchanged (aside from URL normalization).
+ */
+export function normalizeConsoleBrowserUrl(serverUrl) {
+    const url = new URL(serverUrl);
+    // Node may report IPv6 hostnames with or without brackets depending on version.
+    const host = url.hostname.toLowerCase().replace(/^\[|\]$/g, "");
+    if (host === "0.0.0.0") {
+        url.hostname = "127.0.0.1";
+        return url.toString();
+    }
+    if (host === "::") {
+        // Reconstruct rather than mutate hostname: some Node builds keep "[::]".
+        const port = url.port ? `:${url.port}` : "";
+        const path = `${url.pathname}${url.search}${url.hash}` || "/";
+        return `${url.protocol}//[::1]${port}${path.startsWith("/") ? path : `/${path}`}`;
+    }
+    return url.toString();
+}
+/**
+ * Open a URL with the platform system handler using fixed argv (never shell-join).
+ */
+export async function openSystemBrowser(url, deps = {}) {
+    const platform = deps.platform ?? process.platform;
+    const spawnImpl = deps.spawn ?? spawn;
+    const { command, args } = resolveOpenCommand(platform, url);
+    const options = {
+        shell: false,
+        stdio: "ignore",
+        windowsHide: true,
+    };
+    await new Promise((resolve, reject) => {
+        let settled = false;
+        const child = spawnImpl(command, args, options);
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(error);
+        };
+        child.on("error", (error) => {
+            fail(error instanceof Error
+                ? error
+                : new Error(`Failed to open browser: ${String(error)}`));
+        });
+        child.on("close", (code) => {
+            if (settled)
+                return;
+            settled = true;
+            if (code === 0 || code === null) {
+                resolve();
+                return;
+            }
+            reject(new Error(`Failed to open browser (exit ${code})`));
+        });
+        // Detach from parent lifetime; Console service must keep running.
+        child.unref?.();
+    });
+}
+/**
+ * Best-effort open after listen. Never throws; opener failures only warn on stderr.
+ */
+export async function maybeOpenConsoleBrowser(input) {
+    const env = input.env ?? process.env;
+    const platform = input.platform ?? process.platform;
+    const stdoutIsTTY = input.stdoutIsTTY ?? Boolean(process.stdout.isTTY);
+    if (!shouldOpenConsoleBrowser({
+        noOpen: input.noOpen,
+        env,
+        platform,
+        stdoutIsTTY,
+    })) {
+        return;
+    }
+    const browserUrl = normalizeConsoleBrowserUrl(input.serverUrl);
+    const openImpl = input.openImpl ??
+        ((url) => openSystemBrowser(url, { platform }));
+    const stderrWrite = input.stderrWrite ??
+        ((chunk) => {
+            process.stderr.write(chunk);
+        });
+    try {
+        await openImpl(browserUrl);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        stderrWrite(`console: failed to open system browser (${detail}). Console is still running at ${input.serverUrl}\n`);
+    }
+}
+function resolveOpenCommand(platform, url) {
+    if (platform === "win32") {
+        // `start` treats the first quoted arg as a window title; pass empty title.
+        return { command: "cmd", args: ["/c", "start", "", url] };
+    }
+    if (platform === "darwin") {
+        return { command: "open", args: [url] };
+    }
+    return { command: "xdg-open", args: [url] };
+}
+function isTruthyEnv(value) {
+    if (value === undefined)
+        return false;
+    const normalized = value.trim().toLowerCase();
+    return (normalized !== "" &&
+        normalized !== "0" &&
+        normalized !== "false" &&
+        normalized !== "no");
+}

package/dist/worker/console/operation-run-facts.js

@@ -0,0 +1,190 @@
+/**
+ * Trusted run-facts extraction + safe run summary projection
+ * (2026-08-14 Operator Chat DAG recovery P0).
+ *
+ * Invariants:
+ * - Only deterministic structured sources are trusted: the standard
+ *   `OperatorCommandResultV1.result.runSummary` envelope, a structured CLI
+ *   `runSummary` object, or the rerun standard `newRunId`. Free-text stdout /
+ *   non-standard JSON is NEVER scanned or guessed for run ids.
+ * - The projection uses an independent allowlist with bounded fields/arrays
+ *   and redacted text; it must never leak raw results, actionParams, CLI
+ *   args, absolute artifact paths or secrets.
+ * - A run summary is a projection only: it can never change the terminal
+ *   operation state decided by the command envelope/exit facts.
+ */
+import { scrubSecrets } from "./chat/explore-tools.js";
+const RUN_SUMMARY_MAX_NODES = 20;
+const RUN_SUMMARY_MAX_TEXT_CHARS = 600;
+const ABSOLUTE_PATH_REDACTION = "[REDACTED-ABS-PATH]";
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+function redactAbsolutePathSubstrings(value) {
+    let redacted = "";
+    let cursor = 0;
+    while (cursor < value.length) {
+        const current = value[cursor] ?? "";
+        const next = value[cursor + 1] ?? "";
+        const previous = value[cursor - 1] ?? "";
+        const windowsDrive = /[A-Za-z]/.test(current) &&
+            next === ":" &&
+            /[\\/]/.test(value[cursor + 2] ?? "") &&
+            (cursor === 0 || !/[A-Za-z0-9_]/.test(previous));
+        const uncPath = current === "\\" && next === "\\";
+        const posixPath = current === "/" &&
+            next !== "/" &&
+            (cursor === 0 || (!/[A-Za-z0-9_]/.test(previous) && previous !== "/"));
+        if (!windowsDrive && !uncPath && !posixPath) {
+            redacted += current;
+            cursor += 1;
+            continue;
+        }
+        const quote = previous === '"' || previous === "'" ? previous : undefined;
+        let end = cursor;
+        while (end < value.length) {
+            const char = value[end] ?? "";
+            if (quote ? char === quote : /["'<>()[\]{},;]/.test(char))
+                break;
+            end += 1;
+        }
+        redacted += ABSOLUTE_PATH_REDACTION;
+        cursor = end;
+    }
+    return redacted;
+}
+function boundedRedactedText(value, maxChars = RUN_SUMMARY_MAX_TEXT_CHARS) {
+    if (typeof value !== "string" || !value.trim())
+        return undefined;
+    const { scrubbed } = scrubSecrets(value);
+    const pathRedacted = redactAbsolutePathSubstrings(scrubbed);
+    return pathRedacted.length <= maxChars
+        ? pathRedacted
+        : `${pathRedacted.slice(0, maxChars)}…[truncated]`;
+}
+function safeNode(value) {
+    const rec = asRecord(value);
+    if (!rec)
+        return undefined;
+    const id = boundedRedactedText(rec.id, 200);
+    const status = boundedRedactedText(rec.status, 100);
+    if (!id || !status)
+        return undefined;
+    return { id, status };
+}
+/** Independent allowlist projection of a structured run summary. */
+export function safeRunSummaryForProjection(value) {
+    const rec = asRecord(value);
+    if (!rec)
+        return undefined;
+    const runId = boundedRedactedText(rec.runId, 200);
+    if (!runId)
+        return undefined;
+    const status = boundedRedactedText(rec.status, 100);
+    if (!status)
+        return undefined;
+    const nodes = [];
+    if (Array.isArray(rec.nodes)) {
+        for (const raw of rec.nodes) {
+            if (nodes.length >= RUN_SUMMARY_MAX_NODES)
+                break;
+            const node = safeNode(raw);
+            if (node)
+                nodes.push(node);
+        }
+    }
+    const outOfBounds = [];
+    if (Array.isArray(rec.outOfBounds)) {
+        for (const raw of rec.outOfBounds.slice(0, RUN_SUMMARY_MAX_NODES)) {
+            const entry = asRecord(raw);
+            if (!entry)
+                continue;
+            const nodeId = boundedRedactedText(entry.nodeId, 200);
+            const failureCategory = boundedRedactedText(entry.failureCategory, 200);
+            if (nodeId && failureCategory)
+                outOfBounds.push({ nodeId, failureCategory });
+        }
+    }
+    let next;
+    const nextRec = asRecord(rec.next);
+    if (nextRec) {
+        const kind = boundedRedactedText(nextRec.kind, 100);
+        if (kind) {
+            const description = boundedRedactedText(nextRec.description);
+            next = { kind, ...(description ? { description } : {}) };
+        }
+    }
+    const verdict = boundedRedactedText(rec.verdict);
+    const failureCategory = boundedRedactedText(rec.failureCategory);
+    return {
+        runId,
+        status,
+        nodes,
+        ...(verdict !== undefined ? { verdict } : {}),
+        ...(failureCategory !== undefined ? { failureCategory } : {}),
+        ...(outOfBounds.length > 0 ? { outOfBounds } : {}),
+        ...(next ? { next } : {}),
+    };
+}
+/**
+ * Deterministic trusted-source extraction:
+ * 1. `OperatorCommandResultV1.result.runSummary` (schemaVersion=1 envelope);
+ * 2. structured CLI JSON `runSummary` object (task advance / report shapes);
+ * 3. rerun standard `newRunId` (optionally with its own `runSummary`).
+ *
+ * Candidates are checked in order; a rerun `newRunId` that disagrees with the
+ * accompanying `runSummary.runId` is rejected (no guessing). Free text is
+ * never scanned.
+ */
+export function extractTrustedRunFacts(result) {
+    const root = asRecord(result.json);
+    if (!root)
+        return undefined;
+    // Envelope: { schemaVersion: 1, ok, result: { runSummary } }
+    if (root.schemaVersion === 1 && typeof root.ok === "boolean") {
+        const payload = asRecord(root.result);
+        const runSummaryRaw = payload ? asRecord(payload.runSummary) : null;
+        if (runSummaryRaw) {
+            const summary = safeRunSummaryForProjection(runSummaryRaw);
+            if (summary)
+                return { runId: summary.runId, runSummary: summary };
+        }
+        // Rerun standard newRunId inside the envelope result.
+        if (payload && typeof payload.newRunId === "string" && payload.newRunId.trim()) {
+            const runId = payload.newRunId.trim();
+            const inner = asRecord(payload.runSummary);
+            const summary = inner ? safeRunSummaryForProjection(inner) : undefined;
+            if (summary && summary.runId !== runId)
+                return undefined;
+            return summary ? { runId, runSummary: summary } : { runId };
+        }
+        return undefined;
+    }
+    // Structured CLI JSON with a top-level runSummary object.
+    const directSummary = asRecord(root.runSummary);
+    if (directSummary) {
+        const summary = safeRunSummaryForProjection(directSummary);
+        if (summary) {
+            // A rerun newRunId must agree with the summary runId.
+            if (typeof root.newRunId === "string" &&
+                root.newRunId.trim() &&
+                root.newRunId.trim() !== summary.runId) {
+                return undefined;
+            }
+            return { runId: summary.runId, runSummary: summary };
+        }
+        return undefined;
+    }
+    // Rerun standard newRunId (top level, non-envelope).
+    if (typeof root.newRunId === "string" && root.newRunId.trim()) {
+        const runId = root.newRunId.trim();
+        const inner = asRecord(root.runSummary);
+        const summary = inner ? safeRunSummaryForProjection(inner) : undefined;
+        if (summary && summary.runId !== runId)
+            return undefined;
+        return summary ? { runId, runSummary: summary } : { runId };
+    }
+    return undefined;
+}