ue-mcp 1.2.3 → 1.3.0

package/dist/editor-target.js

@@ -25,6 +25,58 @@ import * as path from "node:path";
 export function bridgeLockfilePath(projectDir) {
     return path.join(projectDir, "Saved", "UE_MCP_Bridge", "port.json");
 }
+/** Where every live bridge publishes its own address, one file per process. */
+export function bridgeInstancesDir(projectDir) {
+    return path.join(projectDir, "Saved", "UE_MCP_Bridge", "instances");
+}
+/**
+ * Every readable instance record for this project, newest first.
+ *
+ * Records are read, not trusted: the caller decides which pids are still alive.
+ * A record whose process is gone is exactly the artefact that outlives a crash,
+ * and treating it as an address would resurrect the bug the lockfile pid check
+ * exists to prevent (#819).
+ */
+export function readBridgeInstanceRecords(projectDir) {
+    const dir = bridgeInstancesDir(projectDir);
+    let names;
+    try {
+        names = fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const records = [];
+    for (const name of names) {
+        if (!name.toLowerCase().endsWith(".json"))
+            continue;
+        const recordPath = path.join(dir, name);
+        try {
+            const stat = fs.statSync(recordPath);
+            const parsed = JSON.parse(fs.readFileSync(recordPath, "utf-8"));
+            const pid = parsed.pid;
+            const port = parsed.port;
+            if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0)
+                continue;
+            if (typeof port !== "number" || !Number.isInteger(port) || port <= 0 || port > 65535)
+                continue;
+            records.push({
+                port,
+                pid,
+                instanceId: typeof parsed.instanceId === "string" ? parsed.instanceId : null,
+                state: typeof parsed.state === "string" ? parsed.state : null,
+                startedAt: typeof parsed.startedAt === "string" ? parsed.startedAt : null,
+                recordPath,
+                writtenAtMs: stat.mtimeMs,
+            });
+        }
+        catch {
+            // A record being written right now, or one from a build that wrote a
+            // different shape. Neither is a reason to discard the others.
+        }
+    }
+    return records.sort((a, b) => b.writtenAtMs - a.writtenAtMs);
+}
 /** Read a project's bridge lockfile, or null when it is absent or malformed. */
 export function readBridgeLockfileIn(projectDir) {
     const file = bridgeLockfilePath(projectDir);
@@ -45,12 +97,43 @@ export function readBridgeLockfileIn(projectDir) {
         return null;
     }
 }
+/**
+ * A live editor's own published address for this project, newest first.
+ *
+ * #934: two editors of one project share a single `Saved/UE_MCP_Bridge/`, and
+ * the one that quits removes port.json on its way out. Only the instance that
+ * wrote it ever deletes it, so the survivor is left with no shared lockfile at
+ * all even though it is listening perfectly well, and recovery used to mean
+ * hand-writing port.json back. Its own `instances/<pid>.json` was on disk the
+ * whole time and names its port, so recovery is a directory read.
+ *
+ * `alive` is injected so the fallback is testable without real pids.
+ */
+export function findLiveInstanceRecord(projectDir, alive = isPidAlive) {
+    for (const record of readBridgeInstanceRecords(projectDir)) {
+        // A bind-failed record exists to explain a failure, not to be dialled.
+        if (record.state === "bind-failed")
+            continue;
+        if (!alive(record.pid))
+            continue;
+        return record;
+    }
+    return null;
+}
 /**
  * The bridge endpoint belonging to `projectDir`, or a reason naming the exact
  * file that was checked. Never returns a port that this project did not
  * publish for itself.
+ *
+ * The shared lockfile is still the first answer, and callers still check the
+ * pid it names for themselves. When there is no lockfile at all, a live
+ * instance record for this project is a strictly better answer than a refusal:
+ * the editor published it, for this project, and it names a port nobody else
+ * can overwrite (#934).
+ *
+ * `isAlive` is injected so the fallback is testable without real pids.
  */
-export function resolveBridgeTarget(projectDir) {
+export function resolveBridgeTarget(projectDir, isAlive = isPidAlive) {
     if (!projectDir) {
         return {
             ok: false,
@@ -61,21 +144,35 @@ export function resolveBridgeTarget(projectDir) {
     }
     const lockfilePath = bridgeLockfilePath(projectDir);
     const lockfile = readBridgeLockfileIn(projectDir);
-    if (!lockfile) {
+    if (lockfile) {
         return {
-            ok: false,
+            ok: true,
+            port: lockfile.port,
+            pid: lockfile.pid,
+            writtenAtMs: lockfile.writtenAtMs,
+            lockfilePath,
+            source: "port.json",
+        };
+    }
+    const record = findLiveInstanceRecord(projectDir, isAlive);
+    if (record) {
+        return {
+            ok: true,
+            port: record.port,
+            pid: record.pid,
+            writtenAtMs: record.writtenAtMs,
             lockfilePath,
-            reason: `No bridge port published at ${lockfilePath}. The editor writes that file while its bridge is listening ` +
-                "and removes it when it exits, so either no editor is running for this project or its bridge never started. " +
-                "Lifecycle actions do not guess a port, because a guessed port reaches whichever editor happens to hold it.",
+            source: "instance-record",
+            recordPath: record.recordPath,
         };
     }
     return {
-        ok: true,
-        port: lockfile.port,
-        pid: lockfile.pid,
-        writtenAtMs: lockfile.writtenAtMs,
+        ok: false,
         lockfilePath,
+        reason: `No bridge port published at ${lockfilePath}, and no live instance record under ${bridgeInstancesDir(projectDir)}. ` +
+            "The editor writes those files while its bridge is listening and removes them when it exits, so either no " +
+            "editor is running for this project or its bridge never started. " +
+            "Lifecycle actions do not guess a port, because a guessed port reaches whichever editor happens to hold it.",
     };
 }
 /**

package/dist/editor-target.js.map

@@ -1 +1 @@
-{"version":3,"file":"editor-target.js","sourceRoot":"","sources":["../src/editor-target.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"editor-target.js","sourceRoot":"","sources":["../src/editor-target.ts"],"names":[],"mappings":"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"}

package/dist/engine-observer.d.ts

@@ -34,6 +34,29 @@ export interface EditorProcess {
     responding: boolean;
     windowTitle: string | null;
 }
+/**
+ * The .uproject argument on a process command line, absolute and resolved.
+ *
+ * #967/#970/#965: this used to be one lazy regex over the whole command line,
+ * `[A-Za-z]:[\\/][^"]*?\.uproject`. `[^"]` matches spaces, so on the unquoted
+ * command line Windows reports for a spawned editor
+ *
+ *     C:\...\UnrealEditor.exe C:\work\Demo\Demo.uproject
+ *
+ * the match started at the drive letter of the EXECUTABLE and ran all the way
+ * to the end, and every process came back with a "project path" that was the
+ * exe and the project concatenated. Nothing ever equalled that, so
+ * editorOwnsProject was false for the very editor that had the project open:
+ * stop_editor refused to stop a healthy editor while printing that same
+ * concatenation back as its evidence, and get_engine_state reported no process
+ * for a project whose editor was answering on the bridge.
+ *
+ * So: find where the .uproject argument ENDS (a token boundary, not just any
+ * occurrence of the extension), then walk back to the last place a path could
+ * have begun. That handles the quoted form, the unquoted form, `-Project=` with
+ * and without quotes, and POSIX roots, without assuming a path has no spaces.
+ */
+export declare function extractProjectPath(commandLine: string): string | null;
 /**
  * Every UnrealEditor process on this machine, with enough detail to tell an
  * interactive editor for one project apart from a headless shard for another.
@@ -86,6 +109,18 @@ export interface LogState {
  * before the plugin module exists, which is where the "editor launched but the
  * bridge never came up" reports have always come from.
  */
+/**
+ * The engine root the project was last actually opened with, from its own log.
+ *
+ * Unreal writes `LogInit: Base Directory: <engine>/Engine/Binaries/<Platform>/`
+ * in the first few lines of every run, which is the only durable record of
+ * which engine tree launched an editor. It survives the editor exiting, so it
+ * answers "which engine is this project on" while the editor is stopped, which
+ * is exactly when a full rebuild has to be resolved (#959, #974).
+ *
+ * Returns null when the log is absent, unreadable, or has no such line.
+ */
+export declare function readEngineRootFromLog(projectPath: string | null | undefined): string | null;
 export declare function readLogState(projectPath: string | null | undefined, tailLines?: number): LogState;
 export interface NativeWindow {
     handle: string;
@@ -107,6 +142,8 @@ export declare function dialogLikeWindows(windows: NativeWindow[]): NativeWindow
 export interface EngineSnapshot {
     writtenAt?: string;
     ageSeconds?: number;
+    /** Which process this snapshot describes. Absent on plugin builds before #990. */
+    pid?: number;
     phase?: string;
     /**
      * Null until the engine loop starts ticking. Startup has no tick loop to
@@ -138,11 +175,6 @@ export interface EngineSnapshot {
     } | null;
     [key: string]: unknown;
 }
-/**
- * The snapshot the plugin flushes to disk from a dedicated writer thread. It
- * keeps updating while the game thread is inside a modal loop or a slow task,
- * which is precisely when a bridge request cannot be answered.
- */
 export declare function readEngineSnapshot(projectPath: string | null | undefined): EngineSnapshot | null;
 export interface EngineState {
     running: boolean;
@@ -150,6 +182,17 @@ export interface EngineState {
     log: LogState;
     snapshot: EngineSnapshot | null;
     dialogs: NativeWindow[];
+    /**
+     * #965: the out-of-process probe could not run. Reported on its own rather
+     * than folded into an empty `processes`, because "I could not look" and
+     * "there is no editor" are different answers and only one of them is a
+     * reason to conclude the editor is down.
+     */
+    processProbeFailed: boolean;
+    /** What `running` is asserted on. A bridge reply outranks the process table. */
+    runningEvidence: "bridge-snapshot" | "process-table" | "none";
+    /** Where `snapshot` came from. */
+    snapshotSource: "bridge" | "status.json" | "none";
     /** One line an agent can act on without reading any of the above. */
     summary: string;
     /** True when something is waiting on a human answer. */
@@ -163,3 +206,14 @@ export interface EngineState {
 export declare function readEngineState(projectPath: string | null | undefined, opts?: {
     probeWindows?: boolean;
 }): Promise<EngineState>;
+/**
+ * Fold in a snapshot the editor served over its own bridge.
+ *
+ * #965: one report contained `"running": false, "processes": []` and, in the
+ * same object, a live snapshot with an uptime and a ticking game thread, served
+ * BY the editor over the bridge. An editor that answers a request is running;
+ * a process table that came back empty is a failed measurement, not a fact
+ * about the world. So a bridge reply sets `running` and the process probe's
+ * silence is reported as its own field.
+ */
+export declare function withBridgeSnapshot(state: EngineState, snapshot: EngineSnapshot): EngineState;

package/dist/engine-observer.js

@@ -44,11 +44,70 @@ function parseJsonLoose(raw) {
     }
 }
 const HEADLESS_FLAGS = ["-server", "-game", "-nullrhi", "-unattended", "-run=", "-buildmachine"];
-function extractProjectPath(commandLine) {
-    const match = commandLine.match(/"?([A-Za-z]:[\\/][^"]*?\.uproject|\/[^"\s]*?\.uproject)"?/);
-    if (!match)
+/**
+ * Where a path argument can begin on a command line: the start of the string,
+ * or straight after a separator that cannot itself be part of a path (a space,
+ * a quote, or the `=` of `-Project=`). Matching the root marker rather than the
+ * whole token is what lets an unquoted path containing spaces still be found.
+ */
+const PATH_ROOT_RE = /(?:^|[\s"'=])((?:[A-Za-z]:[\\/])|\/)/g;
+/**
+ * The .uproject argument on a process command line, absolute and resolved.
+ *
+ * #967/#970/#965: this used to be one lazy regex over the whole command line,
+ * `[A-Za-z]:[\\/][^"]*?\.uproject`. `[^"]` matches spaces, so on the unquoted
+ * command line Windows reports for a spawned editor
+ *
+ *     C:\...\UnrealEditor.exe C:\work\Demo\Demo.uproject
+ *
+ * the match started at the drive letter of the EXECUTABLE and ran all the way
+ * to the end, and every process came back with a "project path" that was the
+ * exe and the project concatenated. Nothing ever equalled that, so
+ * editorOwnsProject was false for the very editor that had the project open:
+ * stop_editor refused to stop a healthy editor while printing that same
+ * concatenation back as its evidence, and get_engine_state reported no process
+ * for a project whose editor was answering on the bridge.
+ *
+ * So: find where the .uproject argument ENDS (a token boundary, not just any
+ * occurrence of the extension), then walk back to the last place a path could
+ * have begun. That handles the quoted form, the unquoted form, `-Project=` with
+ * and without quotes, and POSIX roots, without assuming a path has no spaces.
+ */
+export function extractProjectPath(commandLine) {
+    const lower = commandLine.toLowerCase();
+    const EXT = ".uproject";
+    let end = -1;
+    for (let at = lower.indexOf(EXT); at >= 0; at = lower.indexOf(EXT, at + EXT.length)) {
+        const after = commandLine[at + EXT.length];
+        if (after === undefined || /[\s"']/.test(after)) {
+            end = at + EXT.length;
+            break;
+        }
+    }
+    if (end < 0)
+        return null;
+    const head = commandLine.slice(0, end);
+    let start = -1;
+    PATH_ROOT_RE.lastIndex = 0;
+    for (let m = PATH_ROOT_RE.exec(head); m !== null; m = PATH_ROOT_RE.exec(head)) {
+        // m[0] may include the delimiter that proved this is a token boundary;
+        // the path itself starts where the captured root does.
+        start = m.index + m[0].length - m[1].length;
+    }
+    if (start < 0)
+        return null;
+    const raw = commandLine.slice(start, end).replace(/^["']|["']$/g, "").trim();
+    if (raw.length === 0)
         return null;
-    return path.resolve(match[1]);
+    // A candidate that still swallowed the executable is the exact failure this
+    // function exists to prevent, so never return one. It can only happen when
+    // the project argument itself is relative, and there the last whitespace
+    // delimited token is the honest answer.
+    if (/\.exe(\s|$)/i.test(raw)) {
+        const token = raw.split(/\s+/).pop();
+        return token && token.toLowerCase().endsWith(EXT) ? path.resolve(token) : null;
+    }
+    return path.resolve(raw);
 }
 function classify(pid, commandLine, responding, windowTitle) {
     const lower = commandLine.toLowerCase();
@@ -89,40 +148,49 @@ let processCache = null;
  * interactive editor for one project apart from a headless shard for another.
  */
 export async function listEditorProcesses() {
+    return (await probeEditorProcesses()).processes;
+}
+async function probeEditorProcesses() {
     if (processCache && Date.now() - processCache.at < PROCESS_CACHE_MS) {
-        return processCache.value;
+        return { processes: processCache.value, failed: processCache.failed };
     }
-    const value = await queryEditorProcesses();
-    processCache = { at: Date.now(), value };
-    return value;
+    const probe = await queryEditorProcesses();
+    processCache = { at: Date.now(), value: probe.processes, failed: probe.failed };
+    return probe;
 }
 async function queryEditorProcesses() {
     try {
         if (IS_WINDOWS) {
             const raw = await powershell(WINDOWS_PROCESS_SCRIPT, 20000);
             const rows = parseJsonLoose(raw);
-            return rows
-                .filter((r) => typeof r?.pid === "number")
-                .map((r) => classify(r.pid, r.cmd ?? "", r.responding !== false, r.title ?? null));
+            return {
+                processes: rows
+                    .filter((r) => typeof r?.pid === "number")
+                    .map((r) => classify(r.pid, r.cmd ?? "", r.responding !== false, r.title ?? null)),
+                failed: false,
+            };
         }
         // POSIX: `ps` gives the full argv, which carries the .uproject and the
         // headless flags. There is no cheap "responding" equivalent, so report
         // true and let the log-staleness signal stand in for a wedge.
         const { stdout } = await execFileAsync("ps", ["-eo", "pid=,args="], { timeout: 10000, maxBuffer: 4 * 1024 * 1024 });
-        return stdout
-            .split("\n")
-            .map((line) => line.trim())
-            .filter((line) => /UnrealEditor/.test(line) && !/\bgrep\b/.test(line))
-            .map((line) => {
-            const space = line.indexOf(" ");
-            const pid = Number(line.slice(0, space));
-            return classify(pid, line.slice(space + 1), true, null);
-        })
-            .filter((p) => Number.isFinite(p.pid));
+        return {
+            processes: stdout
+                .split("\n")
+                .map((line) => line.trim())
+                .filter((line) => /UnrealEditor/.test(line) && !/\bgrep\b/.test(line))
+                .map((line) => {
+                const space = line.indexOf(" ");
+                const pid = Number(line.slice(0, space));
+                return classify(pid, line.slice(space + 1), true, null);
+            })
+                .filter((p) => Number.isFinite(p.pid)),
+            failed: false,
+        };
     }
     catch (err) {
         log.debug("engine-observer", "process probe failed", err);
-        return [];
+        return { processes: [], failed: true };
     }
 }
 /** Two .uproject paths that name the same file, whatever their spelling. */
@@ -223,6 +291,56 @@ function readTailBytes(file, bytes) {
  * before the plugin module exists, which is where the "editor launched but the
  * bridge never came up" reports have always come from.
  */
+/**
+ * The engine root the project was last actually opened with, from its own log.
+ *
+ * Unreal writes `LogInit: Base Directory: <engine>/Engine/Binaries/<Platform>/`
+ * in the first few lines of every run, which is the only durable record of
+ * which engine tree launched an editor. It survives the editor exiting, so it
+ * answers "which engine is this project on" while the editor is stopped, which
+ * is exactly when a full rebuild has to be resolved (#959, #974).
+ *
+ * Returns null when the log is absent, unreadable, or has no such line.
+ */
+export function readEngineRootFromLog(projectPath) {
+    if (!projectPath)
+        return null;
+    const file = projectLogPath(projectPath);
+    let head;
+    try {
+        const size = fs.statSync(file).size;
+        const length = Math.min(size, 64 * 1024);
+        if (length <= 0)
+            return null;
+        const buf = Buffer.alloc(length);
+        const fd = fs.openSync(file, "r");
+        try {
+            fs.readSync(fd, buf, 0, length, 0);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+        head = buf.toString("utf-8");
+    }
+    catch {
+        return null;
+    }
+    const match = head.match(/Log\w*:\s*(?:Base|Engine) Directory:\s*(.+)/i);
+    if (!match)
+        return null;
+    const directory = match[1].trim().replace(/[\\/]+$/, "");
+    if (!directory)
+        return null;
+    // Base Directory points inside Engine/Binaries/<Platform>; Engine Directory
+    // points at the Engine folder itself. Both sit under the root we want.
+    let current = path.resolve(directory);
+    while (current && current !== path.dirname(current)) {
+        if (path.basename(current).toLowerCase() === "engine")
+            return path.dirname(current);
+        current = path.dirname(current);
+    }
+    return null;
+}
 export function readLogState(projectPath, tailLines = 25) {
     const empty = {
         logPath: null,
@@ -386,10 +504,7 @@ export function dialogLikeWindows(windows) {
  * keeps updating while the game thread is inside a modal loop or a slow task,
  * which is precisely when a bridge request cannot be answered.
  */
-export function readEngineSnapshot(projectPath) {
-    if (!projectPath)
-        return null;
-    const file = path.join(path.dirname(projectPath), "Saved", "UE_MCP_Bridge", "status.json");
+function readSnapshotFile(file) {
     // The writer publishes atomically (temp file + move) four times a second, so
     // a read can land in the instant between unlink and rename. One retry turns
     // that transient miss back into a hit; without it, callers see a null and
@@ -406,10 +521,79 @@ export function readEngineSnapshot(projectPath) {
     }
     return null;
 }
+/**
+ * `status.<pid>.json` names, newest last-written first.
+ *
+ * #990: one project directory can hold the status of several processes, and a
+ * single shared `status.json` describes only whichever of them wrote last. The
+ * per-process files are the ones that describe each editor honestly. A file
+ * whose process has died stops being updated, so newest-wins picks a live
+ * editor over a crashed one without a process-table query.
+ */
+function instanceStatusFiles(dir) {
+    try {
+        return fs
+            .readdirSync(dir)
+            .filter((name) => /^status\.\d+\.json$/i.test(name))
+            .map((name) => {
+            const file = path.join(dir, name);
+            let mtimeMs = 0;
+            try {
+                mtimeMs = fs.statSync(file).mtimeMs;
+            }
+            catch {
+                // Removed between readdir and stat; sorts last and reads as null.
+            }
+            return { file, mtimeMs };
+        })
+            .sort((a, b) => b.mtimeMs - a.mtimeMs)
+            .map((entry) => entry.file);
+    }
+    catch {
+        return [];
+    }
+}
+export function readEngineSnapshot(projectPath) {
+    if (!projectPath)
+        return null;
+    const dir = path.join(path.dirname(projectPath), "Saved", "UE_MCP_Bridge");
+    // Per-process first, shared second. The shared path is still written by
+    // current plugin builds and is the only thing an older one writes, so it
+    // stays the fallback rather than being dropped.
+    for (const file of instanceStatusFiles(dir)) {
+        const snapshot = readSnapshotFile(file);
+        if (snapshot)
+            return snapshot;
+    }
+    return readSnapshotFile(path.join(dir, "status.json"));
+}
 function summarise(state) {
     const ours = state.processes;
+    if (ours.length === 0 && !state.running) {
+        return {
+            summary: state.processProbeFailed
+                ? `The process probe failed, so whether an editor is running for this project is unknown. Log phase: ${state.log.phase}.`
+                : `No editor process for this project. Log phase: ${state.log.phase}.`,
+            blocked: false,
+        };
+    }
+    // #965: an editor answered this request over the bridge while the process
+    // table came back empty, and the report said "No editor process for this
+    // project" in the same breath as it returned that editor's own snapshot.
+    // Whatever the process table managed to see, an editor that replied exists.
     if (ours.length === 0) {
-        return { summary: `No editor process for this project. Log phase: ${state.log.phase}.`, blocked: false };
+        const modal = state.snapshot?.modal;
+        if (modal) {
+            return {
+                summary: `Editor answered over the bridge and is blocked on modal "${modal.title}": ${modal.message} [${(modal.buttons ?? []).join(", ")}]`,
+                blocked: true,
+            };
+        }
+        return {
+            summary: `Editor answered over the bridge (phase: ${state.snapshot?.phase ?? state.log.phase}), but the process probe ` +
+                `${state.processProbeFailed ? "failed" : "did not find it"}, so no pid or command line is available.`,
+            blocked: false,
+        };
     }
     if (state.dialogs.length > 0) {
         const d = state.dialogs[0];
@@ -452,14 +636,50 @@ function summarise(state) {
  * be turned on when something already looks wrong.
  */
 export async function readEngineState(projectPath, opts = {}) {
-    const processes = await findInteractiveEditors(projectPath);
+    const probe = await probeEditorProcesses();
+    // Every interactive editor holding this .uproject open, not just one: two
+    // editors on one project is a legitimate state and hiding the second is how
+    // a stop lands on the wrong one (#965).
+    const processes = selectEditorsForProject(probe.processes, projectPath);
     const logState = readLogState(projectPath);
     const snapshot = readEngineSnapshot(projectPath);
     let dialogs = [];
     if (opts.probeWindows && processes.length > 0) {
         dialogs = dialogLikeWindows(await readNativeWindows(processes.map((p) => p.pid)));
     }
-    const base = { running: processes.length > 0, processes, log: logState, snapshot, dialogs };
+    const base = {
+        running: processes.length > 0,
+        processes,
+        log: logState,
+        snapshot,
+        dialogs,
+        processProbeFailed: probe.failed,
+        runningEvidence: processes.length > 0 ? "process-table" : "none",
+        snapshotSource: snapshot ? "status.json" : "none",
+    };
+    return { ...base, ...summarise(base) };
+}
+/**
+ * Fold in a snapshot the editor served over its own bridge.
+ *
+ * #965: one report contained `"running": false, "processes": []` and, in the
+ * same object, a live snapshot with an uptime and a ticking game thread, served
+ * BY the editor over the bridge. An editor that answers a request is running;
+ * a process table that came back empty is a failed measurement, not a fact
+ * about the world. So a bridge reply sets `running` and the process probe's
+ * silence is reported as its own field.
+ */
+export function withBridgeSnapshot(state, snapshot) {
+    const base = {
+        ...state,
+        // It was served in answer to this call, so its age is zero. Leaving it
+        // unset made the summary's freshness gate treat it as 999 seconds old and
+        // skip the modal and slow-task lines it was fetched to provide.
+        snapshot: { ...snapshot, ageSeconds: 0 },
+        snapshotSource: "bridge",
+        running: true,
+        runningEvidence: "bridge-snapshot",
+    };
     return { ...base, ...summarise(base) };
 }
 //# sourceMappingURL=engine-observer.js.map