@dimina-kit/devtools 0.4.0-dev.20260718095333 → 0.4.0-dev.20260728063215

package/dist/main/runtime/devtools-backend.js

@@ -1,5 +1,5 @@
 import { runDevtoolsBootstrap, createDevtoolsRuntime } from '../app/app.js';
-import { registerAppLifecycle } from '../app/lifecycle.js';
+import { isAppQuitting, registerAppLifecycle } from '../app/lifecycle.js';
 /**
  * Adapts the devtools runtime into a {@link RuntimeBackend} the framework
  * (`@dimina-kit/electron-deck`) orchestrates. The framework owns the process
@@ -21,6 +21,15 @@ import { registerAppLifecycle } from '../app/lifecycle.js';
 export function createDevtoolsBackend(config = {}) {
     // Hoisted so `onShutdown` can reach the assembled context (assigned by `assemble`).
     let instance = null;
+    // `assemble`'s own in-flight promise: `instance` is now published EARLY (see
+    // below), before `createDevtoolsRuntime`'s async body — including the host's
+    // `config.onSetup(instance)` and everything after it — has finished running.
+    // `onShutdown` must wait for THIS to settle before disposing: disposing
+    // `instance.context.registry` while `createDevtoolsRuntime` is still adding
+    // entries to that same registry (e.g. the `updateChecker`/`setupMcp` wiring
+    // that runs after `onSetup`) hits `DisposableRegistry.add()`'s "cannot add
+    // to disposed registry" throw instead of a clean teardown.
+    let assembling = null;
     return {
         // The backend builds the devtools main window itself (framework skips its own).
         // Its only construction-time needs are the host preload + `sandbox:false`
@@ -42,15 +51,51 @@ export function createDevtoolsBackend(config = {}) {
         // Setup (post-whenReady): app lifecycle (window-all-closed → quit) + the
         // full devtools assembly.
         assemble: async () => {
-            registerAppLifecycle();
-            instance = await createDevtoolsRuntime(config);
+            // `onBeforeQuit` runs synchronously at Electron's `before-quit` — main
+            // loop still fully healthy, well before `will-quit`'s unawaited
+            // `shutdown()` and any window/WebContentsView destruction. Disposing
+            // the host-scoped views (host-toolbar's WebContentsView + its
+            // MessagePortMain) here, instead of leaving them to `onShutdown`'s
+            // best-effort async teardown, keeps them from surviving into
+            // Chromium's native shutdown sequence, where a late `'destroyed'`
+            // handler closing an already-torn-down MessagePort segfaults natively.
+            // Safe to run again from `onShutdown`'s `instance.dispose()` afterwards
+            // — `views.disposeAll()` and its constituents are dispose-idempotent.
+            registerAppLifecycle(() => instance?.context.views.disposeAll());
+            // `onInstanceCreated` (not the return value) is what assigns `instance`:
+            // `createDevtoolsRuntime` awaits the host's `config.onSetup(instance)`
+            // — which may run arbitrarily long and can itself load the host toolbar
+            // (a live MessagePort) — before returning. Waiting for the return value
+            // would leave `instance` null, and the before-quit hook above a no-op,
+            // for that entire window. Publishing from the callback closes it.
+            assembling = createDevtoolsRuntime(config, (created) => {
+                instance = created;
+                // Quit may have already started (before-quit already fired) before
+                // this instance existed, so the hook above ran with nothing to
+                // dispose. Self-heal: run the same teardown now that there is.
+                if (isAppQuitting())
+                    instance.context.views.disposeAll();
+            }).then(() => { });
+            await assembling;
         },
         // Dispose the devtools context during the framework's deterministic shutdown
         // (app.on('will-quit') → shutdown() → runShutdownCleanup(), awaited once).
         // Without this, the compile session (a child process, torn down by
         // closeProject) and the IPC registry would leak on exit. The framework awaits
         // this hook, so teardown is no longer a best-effort before-quit reach-around.
-        onShutdown: () => instance?.dispose(),
+        //
+        // Waits for `assembling` first: `instance` can be non-null (published
+        // early, above) while `createDevtoolsRuntime`'s own async body — the
+        // host's `onSetup` and everything scheduled after it — is still running
+        // and still adding entries to `instance.context.registry`. Disposing
+        // that registry out from under an in-flight assembly throws instead of
+        // tearing down cleanly (`DisposableRegistry.add` rejects post-dispose).
+        // `.catch()` here: assembly failing is `assemble`'s problem to surface,
+        // not a reason to skip disposing whatever DID get constructed.
+        onShutdown: async () => {
+            await assembling?.catch(() => { });
+            await instance?.dispose();
+        },
     };
 }
 //# sourceMappingURL=devtools-backend.js.map

package/dist/main/services/compile-standby.js

@@ -21,6 +21,10 @@ export function setupCompileWorkerStandby(ctx, deps = {}) {
                 severity: EVENT_SEVERITY[ev.type] ?? 'info',
                 code: 'compile-standby',
                 message: detail,
+                // Devtools-tooling-only state, unrelated to the inspected mini-program
+                // — must never reach the right-panel (user-facing) Console panel; see
+                // console-forward/index.ts's audience gate and global-diagnostics-mirror.ts.
+                audience: 'internal',
             });
         }
         catch {

package/dist/main/services/console-forward/cdp-inject.d.ts

@@ -0,0 +1,18 @@
+import type { WebContents } from 'electron';
+import type { CdpSessionBroker } from '../cdp-session/index.js';
+/**
+ * Shared CDP injection primitive for the global mirrors (console +
+ * diagnostics): evaluate `script` in `target`'s realm over the broker's
+ * debugger session — never `target.executeJavaScript`, whose internal RPC
+ * hangs forever on a wc that is simultaneously the inspected side of
+ * `setDevToolsWebContents` AND attached by an external CDP client (see
+ * global-console-mirror.ts for the full mechanism and the real-machine
+ * repro).
+ *
+ * Resolves true only on a clean evaluation. `exceptionDetails`, a rejected
+ * send, and an unacquirable session (destroyed wc / debugger exclusively
+ * held elsewhere) all report false — createOpenGatedRelay then leaves the
+ * entry retryable instead of marking it done.
+ */
+export declare function injectViaCdp(broker: CdpSessionBroker, target: WebContents, script: string, warnTag: string): boolean | Promise<boolean>;
+//# sourceMappingURL=cdp-inject.d.ts.map

package/dist/main/services/console-forward/cdp-inject.js

@@ -0,0 +1,30 @@
+/**
+ * Shared CDP injection primitive for the global mirrors (console +
+ * diagnostics): evaluate `script` in `target`'s realm over the broker's
+ * debugger session — never `target.executeJavaScript`, whose internal RPC
+ * hangs forever on a wc that is simultaneously the inspected side of
+ * `setDevToolsWebContents` AND attached by an external CDP client (see
+ * global-console-mirror.ts for the full mechanism and the real-machine
+ * repro).
+ *
+ * Resolves true only on a clean evaluation. `exceptionDetails`, a rejected
+ * send, and an unacquirable session (destroyed wc / debugger exclusively
+ * held elsewhere) all report false — createOpenGatedRelay then leaves the
+ * entry retryable instead of marking it done.
+ */
+export function injectViaCdp(broker, target, script, warnTag) {
+    const lease = broker.acquire(target);
+    if (!lease)
+        return false;
+    return lease.send('Runtime.evaluate', { expression: script }).then((result) => {
+        if (result?.exceptionDetails) {
+            console.warn(`[${warnTag}] Runtime.evaluate reported an exception, will retry on next reopen`);
+            return false;
+        }
+        return true;
+    }, (err) => {
+        console.warn(`[${warnTag}] injection failed, will retry on next reopen:`, err instanceof Error ? err.message : String(err));
+        return false;
+    });
+}
+//# sourceMappingURL=cdp-inject.js.map

package/dist/main/services/console-forward/global-console-mirror.d.ts

@@ -0,0 +1,33 @@
+import type { WebContents } from 'electron';
+import type { Disposable } from '@dimina-kit/electron-deck/main';
+import type { ConsoleForwarder } from './index.js';
+import type { CdpSessionBroker } from '../cdp-session/index.js';
+/**
+ * Mirror EVERY guest console entry (both service + render layers,
+ * UNFILTERED — no isInternalLogMessage gating, see that module's doc for
+ * why this mirror deliberately skips it) into `target`'s own console, but
+ * ONLY while the standalone internal DevTools window is open.
+ *
+ * The subscription lifecycle is gated by `onHostChanged` (non-null hostWc =
+ * window just opened/rebuilt, null = just closed) rather than subscribing
+ * once for the whole app lifetime: each open re-subscribes to `forwarder`
+ * with `{replay:true}`, draining its CURRENT history buffer into `target`
+ * before continuing live, and each close disposes that subscription. This
+ * is what makes opening (or reopening) the window always show recent
+ * history — subscribing once at construction time (this module's earlier
+ * design) captured the replay burst before any window could possibly be
+ * open to receive it, silently losing it forever. `target` is the fixed
+ * INSPECTED side (mainWindow.webContents, per
+ * internal-devtools-window.ts's setDevToolsWebContents relationship) —
+ * never the hostWc the signal carries; injecting into the front-end host
+ * page would only ever reach that page's own invisible console.
+ *
+ * Reopen-dedup is handled by `createOpenGatedRelay` (real-machine e2e
+ * confirmed a naive replay-on-every-open double-injects everything already
+ * shown once, since Chromium's own console storage survives a DevTools
+ * close — see that module's doc comment).
+ */
+export declare function createGlobalConsoleMirror(forwarder: Pick<ConsoleForwarder, 'subscribe'>, target: WebContents, onHostChanged: (handler: (hostWc: WebContents | null) => void) => () => void, opts: {
+    broker: CdpSessionBroker;
+}): Disposable;
+//# sourceMappingURL=global-console-mirror.d.ts.map

package/dist/main/services/console-forward/global-console-mirror.js

@@ -0,0 +1,71 @@
+import { isFrontendSettled } from '../views/inject-when-ready.js';
+import { createOpenGatedRelay } from './open-gated-relay.js';
+import { injectViaCdp } from './cdp-inject.js';
+/** Console levels safe to re-emit; anything else maps to 'log' — mirrors
+ *  console-forward/index.ts's FORWARDABLE_LEVELS. */
+const FORWARDABLE_LEVELS = new Set(['log', 'warn', 'error', 'info', 'debug']);
+/**
+ * Build the `executeJavaScript` source that re-emits one guest console entry
+ * into the target wc's own console, tagged with its source layer. Args ride
+ * as a JSON string and are re-parsed target-side — data, never code — same
+ * discipline as console-forward/index.ts's buildForwardScript.
+ */
+function buildMirrorScript(entry) {
+    const method = FORWARDABLE_LEVELS.has(entry.level ?? '') ? entry.level : 'log';
+    const tag = entry.source === 'render' ? '[render]' : '[service]';
+    const argsJson = JSON.stringify(entry.args ?? []);
+    return `(()=>{try{const a=JSON.parse(${JSON.stringify(argsJson)});console[${JSON.stringify(method)}](${JSON.stringify(tag)},...a)}catch(_){}})()`;
+}
+/**
+ * Mirror EVERY guest console entry (both service + render layers,
+ * UNFILTERED — no isInternalLogMessage gating, see that module's doc for
+ * why this mirror deliberately skips it) into `target`'s own console, but
+ * ONLY while the standalone internal DevTools window is open.
+ *
+ * The subscription lifecycle is gated by `onHostChanged` (non-null hostWc =
+ * window just opened/rebuilt, null = just closed) rather than subscribing
+ * once for the whole app lifetime: each open re-subscribes to `forwarder`
+ * with `{replay:true}`, draining its CURRENT history buffer into `target`
+ * before continuing live, and each close disposes that subscription. This
+ * is what makes opening (or reopening) the window always show recent
+ * history — subscribing once at construction time (this module's earlier
+ * design) captured the replay burst before any window could possibly be
+ * open to receive it, silently losing it forever. `target` is the fixed
+ * INSPECTED side (mainWindow.webContents, per
+ * internal-devtools-window.ts's setDevToolsWebContents relationship) —
+ * never the hostWc the signal carries; injecting into the front-end host
+ * page would only ever reach that page's own invisible console.
+ *
+ * Reopen-dedup is handled by `createOpenGatedRelay` (real-machine e2e
+ * confirmed a naive replay-on-every-open double-injects everything already
+ * shown once, since Chromium's own console storage survives a DevTools
+ * close — see that module's doc comment).
+ */
+export function createGlobalConsoleMirror(forwarder, target, onHostChanged, opts) {
+    function inject(entry) {
+        if (target.isDestroyed())
+            return false;
+        if (!isFrontendSettled(target))
+            return false;
+        let script;
+        try {
+            script = buildMirrorScript(entry);
+        }
+        catch {
+            return false;
+        }
+        // Transport is CDP `Runtime.evaluate` over the shared debugger-session
+        // broker — NEVER `target.executeJavaScript`: Electron's internal
+        // ExecuteJavaScript RPC hangs FOREVER on a wc that is simultaneously the
+        // inspected side of `setDevToolsWebContents` (the standalone debug
+        // window) AND attached by an external CDP client (remote-debugging-port,
+        // which bootstrap's setupCdpPort enables by default when unpackaged and
+        // whenever cdp/mcp settings are on) — real-machine repro. The debugger
+        // channel is unaffected. Report the real outcome (not fire-and-forget) —
+        // createOpenGatedRelay only marks an entry permanently "injected" on a
+        // confirmed `true`, and its inject timeout bounds any residual hang.
+        return injectViaCdp(opts.broker, target, script, 'global-console-mirror');
+    }
+    return createOpenGatedRelay(onHostChanged, (sink, opts2) => forwarder.subscribe(sink, opts2), inject);
+}
+//# sourceMappingURL=global-console-mirror.js.map

package/dist/main/services/console-forward/global-diagnostics-mirror.d.ts

@@ -0,0 +1,33 @@
+import type { WebContents } from 'electron';
+import type { Disposable } from '@dimina-kit/electron-deck/main';
+import type { DiagnosticsBus } from '../diagnostics/index.js';
+import type { CdpSessionBroker } from '../cdp-session/index.js';
+/**
+ * Mirror EVERY diagnostic (both `audience:'user'` and `audience:'internal'`,
+ * UNFILTERED — the same "see everything" contract `createGlobalConsoleMirror`
+ * applies to guest console entries) into `target`'s own console, but ONLY
+ * while the standalone internal DevTools window is open.
+ *
+ * The subscription lifecycle is gated by `onHostChanged` (non-null hostWc =
+ * window just opened/rebuilt, null = just closed) rather than subscribing
+ * once for the whole app lifetime: each open re-subscribes to `diagnostics`
+ * with `{replay:true}`, draining its CURRENT buffer into `target` before
+ * continuing live, and each close disposes that subscription. This is what
+ * makes opening (or reopening) the window always show history — subscribing
+ * once at construction time (this module's earlier design) captured the
+ * replay burst before any window could possibly be open to receive it
+ * (construction happens at app boot; the window is user-opened, always
+ * later), silently losing it forever — the exact reported bug (e.g. the
+ * earliest compile-standby events at boot never showing up). `target` is the
+ * fixed INSPECTED side (mainWindow.webContents) — never the hostWc the
+ * signal carries.
+ *
+ * Reopen-dedup is handled by `createOpenGatedRelay` (real-machine e2e
+ * confirmed a naive replay-on-every-open double-injects everything already
+ * shown once, since Chromium's own console storage survives a DevTools
+ * close — see that module's doc comment).
+ */
+export declare function createGlobalDiagnosticsMirror(diagnostics: Pick<DiagnosticsBus, 'subscribe'>, target: WebContents, onHostChanged: (handler: (hostWc: WebContents | null) => void) => () => void, opts: {
+    broker: CdpSessionBroker;
+}): Disposable;
+//# sourceMappingURL=global-diagnostics-mirror.d.ts.map

package/dist/main/services/console-forward/global-diagnostics-mirror.js

@@ -0,0 +1,73 @@
+import { isFrontendSettled } from '../views/inject-when-ready.js';
+import { createOpenGatedRelay } from './open-gated-relay.js';
+import { injectViaCdp } from './cdp-inject.js';
+/** `Diagnostic.severity` → the literal `console.<method>` call — same mapping
+ *  console-forward/index.ts's DIAGNOSTIC_CONSOLE_CALL uses (kept local since
+ *  that constant isn't exported; both must stay in sync with `Diagnostic`). */
+const DIAGNOSTIC_CONSOLE_CALL = {
+    error: 'console.error',
+    warn: 'console.warn',
+    info: 'console.info',
+};
+/**
+ * Build the `executeJavaScript` source that injects one diagnostic into the
+ * target wc's own console, prefixed `[dimina-kit] ` — same shape as
+ * console-forward/index.ts's `buildDiagnosticScript`, minus that function's
+ * `RENDER_FORWARD_SOURCE_URL` loop-safety sentinel: that sentinel exists to
+ * stop the service-host's OWN CDP capture from re-broadcasting the injected
+ * line, and nothing here re-captures `mainWindow.webContents`'s console.
+ */
+function buildMirrorScript(severity, message) {
+    const call = DIAGNOSTIC_CONSOLE_CALL[severity];
+    const argsJson = JSON.stringify([`[dimina-kit] ${message}`]);
+    return `(()=>{try{const a=JSON.parse(${JSON.stringify(argsJson)});${call}(...a)}catch(_){}})()`;
+}
+/**
+ * Mirror EVERY diagnostic (both `audience:'user'` and `audience:'internal'`,
+ * UNFILTERED — the same "see everything" contract `createGlobalConsoleMirror`
+ * applies to guest console entries) into `target`'s own console, but ONLY
+ * while the standalone internal DevTools window is open.
+ *
+ * The subscription lifecycle is gated by `onHostChanged` (non-null hostWc =
+ * window just opened/rebuilt, null = just closed) rather than subscribing
+ * once for the whole app lifetime: each open re-subscribes to `diagnostics`
+ * with `{replay:true}`, draining its CURRENT buffer into `target` before
+ * continuing live, and each close disposes that subscription. This is what
+ * makes opening (or reopening) the window always show history — subscribing
+ * once at construction time (this module's earlier design) captured the
+ * replay burst before any window could possibly be open to receive it
+ * (construction happens at app boot; the window is user-opened, always
+ * later), silently losing it forever — the exact reported bug (e.g. the
+ * earliest compile-standby events at boot never showing up). `target` is the
+ * fixed INSPECTED side (mainWindow.webContents) — never the hostWc the
+ * signal carries.
+ *
+ * Reopen-dedup is handled by `createOpenGatedRelay` (real-machine e2e
+ * confirmed a naive replay-on-every-open double-injects everything already
+ * shown once, since Chromium's own console storage survives a DevTools
+ * close — see that module's doc comment).
+ */
+export function createGlobalDiagnosticsMirror(diagnostics, target, onHostChanged, opts) {
+    function inject(d) {
+        if (target.isDestroyed())
+            return false;
+        if (!isFrontendSettled(target))
+            return false;
+        let script;
+        try {
+            script = buildMirrorScript(d.severity, d.message);
+        }
+        catch {
+            return false;
+        }
+        // Transport is CDP `Runtime.evaluate` over the shared debugger-session
+        // broker — never `target.executeJavaScript`, whose internal RPC hangs
+        // forever under the setDevToolsWebContents + external-CDP-client double
+        // attach (see cdp-inject.ts / global-console-mirror.ts; same target,
+        // same failure). Report the real outcome — createOpenGatedRelay only
+        // marks an entry permanently "injected" on a confirmed `true`.
+        return injectViaCdp(opts.broker, target, script, 'global-diagnostics-mirror');
+    }
+    return createOpenGatedRelay(onHostChanged, (sink, opts2) => diagnostics.subscribe(sink, opts2), inject);
+}
+//# sourceMappingURL=global-diagnostics-mirror.js.map

package/dist/main/services/console-forward/index.d.ts

@@ -30,8 +30,22 @@ export interface ConsoleForwarder extends Disposable {
      * Register an external sink (e.g. automation WS broadcast). Returns a
      * Disposable that unregisters it. Sinks see EVERY entry (both layers) — the
      * render→service forward is internal and not exposed as a sink.
+     *
+     * A bounded history buffer (200 entries, oldest dropped first — mirrors
+     * `DiagnosticsBus`'s `DEFAULT_BUFFER_CAP` ring-buffer style) records every
+     * entry regardless of whether anyone is subscribed. `opts.replay` (default
+     * `false`, UNLIKE `DiagnosticsBus` whose default is `true`) opts a new
+     * subscriber into draining that buffer, in order, before receiving live
+     * entries. Default stays non-replaying because the existing automation
+     * subscriber (`services/automation/index.ts`) wants only entries from the
+     * moment it subscribes — a history dump on an existing WS connection would
+     * be a surprise duplicate broadcast. `{replay:true}` exists for the global
+     * console mirror, whose whole point is to catch up a standalone debug
+     * window opened well after boot.
      */
-    subscribe(sink: ConsoleSink): Disposable;
+    subscribe(sink: ConsoleSink, opts?: {
+        replay?: boolean;
+    }): Disposable;
     /**
      * Flush any diagnostic queued for `appSessionId` (plus the global,
      * session-less queue) into that session's now-ready service-host wc.

package/dist/main/services/console-forward/index.js

@@ -1,5 +1,6 @@
 import { DisposableRegistry, toDisposable } from '@dimina-kit/electron-deck/main';
 import { RENDER_FORWARD_SOURCE_URL } from '../service-console/console-api.js';
+import { isInternalLogMessage } from './internal-log.js';
 /** Console levels we re-emit into the service host. Anything else maps to 'log'. */
 const FORWARDABLE_LEVELS = new Set(['log', 'warn', 'error', 'info', 'debug']);
 /**
@@ -46,6 +47,12 @@ function buildDiagnosticScript(severity, message) {
 export function createConsoleForwarder(bridge, diagnostics) {
     const sinks = new Set();
     const registry = new DisposableRegistry();
+    // Bounded history ring buffer backing `subscribe(sink, {replay:true})` —
+    // see the interface doc comment above. Every entry is recorded regardless
+    // of whether anyone is subscribed, so a replaying subscriber that arrives
+    // long after boot (the standalone global debug window) still catches up.
+    const CONSOLE_BUFFER_CAP = 200;
+    const buffer = [];
     // Diagnostics queued because no live service-host wc could be resolved yet,
     // bucketed by the owning appSessionId; diagnostics with no appSessionId land
     // in `pendingGlobal` instead. `notifyServiceHostReady` drains both into the
@@ -73,6 +80,16 @@ export function createConsoleForwarder(bridge, diagnostics) {
      * missing/destroyed/not-yet-ready host is a normal state, not an error.
      */
     function handleDiagnostic(d) {
+        // Internal-audience diagnostics (e.g. compile-standby's warm-pool
+        // lifecycle) are devtools-tooling-only state — never inject them into a
+        // project's service host (the right-panel CDP is natively attached
+        // there), and never queue them either: queuing exists so a diagnostic
+        // survives until ITS session's host becomes resolvable, which is
+        // meaningless for something that must never reach any service host.
+        // (See global-diagnostics-mirror.ts for where these actually surface —
+        // the independent, unfiltered "debug the whole app" panel.)
+        if (d.audience === 'internal')
+            return;
         if (d.appSessionId) {
             const wc = readySessions.has(d.appSessionId) && bridge.getServiceWcForBridge
                 ? bridge.getServiceWcForBridge(d.appSessionId)
@@ -105,9 +122,20 @@ export function createConsoleForwarder(bridge, diagnostics) {
      * page (multi-app safe), falling back to the active app's service host when
      * the bridgeId is unknown — that's the host the embedded DevTools inspects.
      * No-op on a destroyed/missing host so we never write to a torn-down wc (pool
-     * reuse / session swap can swap the host out under us).
+     * reuse / session swap can swap the host out under us). Skips dimina
+     * framework-internal render-layer log lines (`isInternalLogMessage`) —
+     * those must never reach the project's right-panel console at all (the
+     * global console mirror still sees them via the `sinks` broadcast in
+     * `emit()`, which runs before this function). This is the source-level fix
+     * for the render half of the noise console-filter.ts's front-end text
+     * filter used to paper over; the service-layer half (`[service]` lines,
+     * native CDP-observed, no interception point available — see
+     * service-host/preload.cjs's "console.* is deliberately NOT patched"
+     * comment) still needs that filter.
      */
     function forwardRenderToServiceHost(entry) {
+        if (isInternalLogMessage(entry))
+            return;
         let wc = null;
         if (entry.bridgeId && bridge.getServiceWcForBridge) {
             wc = bridge.getServiceWcForBridge(entry.bridgeId);
@@ -135,6 +163,9 @@ export function createConsoleForwarder(bridge, diagnostics) {
         // (render only — see loop-safety invariant in the module header).
         emit(raw) {
             const entry = (raw ?? {});
+            buffer.push(entry);
+            if (buffer.length > CONSOLE_BUFFER_CAP)
+                buffer.shift();
             for (const sink of sinks) {
                 try {
                     sink(entry);
@@ -147,7 +178,15 @@ export function createConsoleForwarder(bridge, diagnostics) {
             if (entry.source === 'render')
                 forwardRenderToServiceHost(entry);
         },
-        subscribe(sink) {
+        subscribe(sink, opts) {
+            if (opts?.replay) {
+                for (const entry of buffer) {
+                    try {
+                        sink(entry);
+                    }
+                    catch { /* isolate a replay throw same as a live one */ }
+                }
+            }
             sinks.add(sink);
             return registry.add(toDisposable(() => { sinks.delete(sink); }));
         },
@@ -176,6 +215,7 @@ export function createConsoleForwarder(bridge, diagnostics) {
         },
         dispose() {
             sinks.clear();
+            buffer.length = 0;
             pendingBySession.clear();
             pendingGlobal.length = 0;
             readySessions.clear();

package/dist/main/services/console-forward/internal-log.d.ts

@@ -0,0 +1,11 @@
+import type { GuestConsoleEntry } from './index.js';
+/**
+ * Judges whether a guest console entry is dimina framework-internal output
+ * (a bridge/lifecycle log the framework itself prints) rather than the
+ * mini-app author's own business `console.*` call. Only the FIRST arg is
+ * inspected — framework logs always lead with the literal tag; a
+ * business log that happens to mention the tag later in its args must not
+ * be swept up.
+ */
+export declare function isInternalLogMessage(entry: GuestConsoleEntry): boolean;
+//# sourceMappingURL=internal-log.d.ts.map

package/dist/main/services/console-forward/internal-log.js

@@ -0,0 +1,23 @@
+/** dimina framework internal-log first-arg prefixes, from the framework
+ *  source literals (dimina/fe/packages/service/src/core/message.js:26 and
+ *  siblings use `'[service]'`; dimina/fe/packages/render/src/core/message.js:18
+ *  and siblings use `'[system]'`). */
+const SERVICE_PREFIX = '[service]';
+const RENDER_PREFIX = '[system]';
+/**
+ * Judges whether a guest console entry is dimina framework-internal output
+ * (a bridge/lifecycle log the framework itself prints) rather than the
+ * mini-app author's own business `console.*` call. Only the FIRST arg is
+ * inspected — framework logs always lead with the literal tag; a
+ * business log that happens to mention the tag later in its args must not
+ * be swept up.
+ */
+export function isInternalLogMessage(entry) {
+    const first = entry.args?.[0];
+    if (typeof first !== 'string')
+        return false;
+    if (first === RENDER_PREFIX)
+        return true;
+    return first === SERVICE_PREFIX || first.startsWith(`${SERVICE_PREFIX} `);
+}
+//# sourceMappingURL=internal-log.js.map

package/dist/main/services/console-forward/open-gated-relay.d.ts

@@ -0,0 +1,67 @@
+import type { Disposable } from '@dimina-kit/electron-deck/main';
+/**
+ * Generic open/close-gated replay-subscription primitive shared by
+ * `createGlobalConsoleMirror` and `createGlobalDiagnosticsMirror` — both
+ * gate their subscription to a buffered+replayable source
+ * (`ConsoleForwarder`/`DiagnosticsBus`) on whether the standalone "debug the
+ * whole Electron app" window is currently open (`onHostChanged`): each open
+ * re-subscribes with `{replay:true}` so history is never lost even if the
+ * window opens long after boot, and each close disposes that subscription.
+ *
+ * ── Dedup (the e2e-confirmed bug this fixes) ────────────────────────────────
+ * Naively re-subscribing with `{replay:true}` on every reopen double-injects
+ * history: Chromium's own per-frame `ConsoleMessageStorage` is NOT cleared by
+ * closing DevTools (only by navigation), so it natively re-delivers entries
+ * already shown during a PREVIOUS open to the freshly-attached front-end —
+ * and if this relay ALSO blindly replays and re-injects the same buffered
+ * objects, every entry shown once ends up displayed twice on reopen, the
+ * duplicate carrying a fresh (wrong) "just reopened" timestamp instead of
+ * when it actually happened.
+ *
+ * Fix: `state` is a `WeakMap` keyed by OBJECT REFERENCE (never content — two
+ * content-identical-but-distinct entries must each still get injected once)
+ * that persists across the relay's ENTIRE lifetime, not reset by open/close.
+ * A replay that re-delivers an already-CONFIRMED-injected object is skipped;
+ * only entries never physically (and successfully) passed to `inject()`
+ * before (e.g. ones that arrived while the window was closed) actually call
+ * `inject()`. Chromium's own native re-delivery is left to show the
+ * once-injected ones — that is what makes reopening not double them up. This
+ * also composes correctly with the source's own bounded ring buffer: an
+ * evicted entry is simply absent from the next replay batch entirely, so it
+ * can never be double-counted regardless of what `state` holds.
+ *
+ * ── inject() is fallible — only a CONFIRMED success may ever mark "done" ───
+ * `inject()` wraps an async `executeJavaScript` against a possibly-destroyed
+ * or not-yet-settled target, so it reports whether the entry was ACTUALLY
+ * delivered via `boolean | Promise<boolean>`. Marking an entry "injected"
+ * before that outcome is known (the original bug here) means a single
+ * transient failure — target destroyed, front-end not settled, a rejected
+ * `executeJavaScript` — permanently black-holes that entry: every future
+ * replay skips it forever, even though it was never actually shown anywhere
+ * (violates this repo's "state must be marked at the moment the fact
+ * actually happens" principle — this was marking INTENT, not the fact). So
+ * `state` tracks three phases per entry: absent (never attempted, or a prior
+ * attempt failed and was cleared — eligible for `inject()`), `'pending'`
+ * (an `inject()` call is in flight — a concurrent replay of the SAME entry
+ * must not trigger a second concurrent call), `'done'` (confirmed success —
+ * permanently skipped from here on). A `false` result or a rejection resets
+ * the entry back to absent, so the next replay (e.g. the next window reopen)
+ * gets a real retry instead of a silent, permanent loss.
+ */
+export interface OpenGatedRelayOptions {
+    /**
+     * Bounds how long ONE in-flight `inject()` attempt may hold an entry
+     * `'pending'`. An `inject()` promise that never settles (real incident:
+     * `executeJavaScript` against a wc that is simultaneously the inspected
+     * side of `setDevToolsWebContents` AND attached by an external CDP client
+     * hangs forever) would otherwise black-hole the entry permanently — never
+     * shown, never retried. Past this bound the entry becomes retryable again
+     * on the next replay. The timed-out attempt's promise may still settle
+     * LATE; its settlement is generation-stamped and ignored when stale.
+     */
+    injectTimeoutMs?: number;
+}
+export declare function createOpenGatedRelay<TEntry extends object, THost = unknown>(onHostChanged: (handler: (host: THost | null) => void) => () => void, subscribe: (sink: (entry: TEntry) => void, opts: {
+    replay: true;
+}) => Disposable, inject: (entry: TEntry) => boolean | Promise<boolean>, opts?: OpenGatedRelayOptions): Disposable;
+//# sourceMappingURL=open-gated-relay.d.ts.map

package/dist/main/services/console-forward/open-gated-relay.js

@@ -0,0 +1,55 @@
+const DEFAULT_INJECT_TIMEOUT_MS = 10_000;
+export function createOpenGatedRelay(onHostChanged, subscribe, inject, opts) {
+    const injectTimeoutMs = opts?.injectTimeoutMs ?? DEFAULT_INJECT_TIMEOUT_MS;
+    // Generation stamp per attempt: only the attempt matching the entry's
+    // CURRENT pending generation may act on settling — a stale (timed-out,
+    // superseded) attempt's late result must neither mark the entry done nor
+    // disturb a newer attempt's pending status.
+    const state = new WeakMap();
+    let generationSeq = 0;
+    const inFlightTimers = new Set();
+    let live = null;
+    function deliver(entry) {
+        if (state.has(entry))
+            return;
+        const generation = ++generationSeq;
+        state.set(entry, { phase: 'pending', generation });
+        const timer = setTimeout(() => {
+            inFlightTimers.delete(timer);
+            const cur = state.get(entry);
+            if (cur && cur.phase === 'pending' && cur.generation === generation)
+                state.delete(entry);
+        }, injectTimeoutMs);
+        timer.unref?.();
+        inFlightTimers.add(timer);
+        const settle = (ok) => {
+            clearTimeout(timer);
+            inFlightTimers.delete(timer);
+            const cur = state.get(entry);
+            if (!cur || cur.phase !== 'pending' || cur.generation !== generation)
+                return;
+            if (ok)
+                state.set(entry, { phase: 'done', generation });
+            else
+                state.delete(entry);
+        };
+        Promise.resolve()
+            .then(() => inject(entry))
+            .then((ok) => settle(ok === true), () => settle(false));
+    }
+    const unregister = onHostChanged((host) => {
+        live?.dispose();
+        live = host !== null ? subscribe(deliver, { replay: true }) : null;
+    });
+    return {
+        dispose: () => {
+            for (const timer of inFlightTimers)
+                clearTimeout(timer);
+            inFlightTimers.clear();
+            live?.dispose();
+            live = null;
+            unregister();
+        },
+    };
+}
+//# sourceMappingURL=open-gated-relay.js.map