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

package/dist/main/ipc/bridge-router.d.ts

@@ -33,6 +33,33 @@ export interface RenderEvent {
      * Lets the current-page panel push the route without a separate lookup. */
     pagePath?: string;
 }
+/**
+ * Fires once per app session, the moment its hidden SERVICE HOST window's
+ * `service.html` document has `did-finish-load`'d — i.e. `serviceWcId` is
+ * GUARANTEED resolvable via `webContents.fromId(serviceWcId)` right now. This
+ * is document readiness, NOT mini-app runtime readiness: `injectLogicBundle`
+ * and the service's own `serviceResourceLoaded` handshake both happen AFTER
+ * this fires (see `bootServiceHost`) — a consumer that needs "the mini-app
+ * has actually booted" must not treat this as that signal.
+ *
+ * Exists so a consumer that needs to act on the service host wc THE MOMENT it
+ * becomes resolvable (e.g. attaching the right-panel DevTools front-end) has
+ * a real event to react to instead of polling `getServiceWc(appId)` on a
+ * fixed retry budget and silently giving up if that budget is exhausted
+ * before the wc resolves under load — the bug this event was added to fix
+ * (see `native-simulator-devtools-host.ts`'s `onServiceHostReady` subscriber).
+ *
+ * `appId`-keyed resolution (`getServiceWc(appId)`) is NOT equivalent to this
+ * event during same-app respawn overlap — `getServiceWc` returns the MOST
+ * RECENT live session for that appId, which may not be the specific session
+ * that just fired this event. Consumers that must target the EXACT session
+ * should resolve `serviceWcId` directly rather than re-resolving by `appId`.
+ */
+export interface ServiceHostReadyEvent {
+    appId: string;
+    appSessionId: string;
+    serviceWcId: number;
+}
 /**
  * Point-in-time counts of every resource class RouterState owns. Leak coverage
  * (unit + e2e) asserts EXACT equality of this ledger around a churn cycle —
@@ -75,8 +102,17 @@ export interface BridgeRouterHandle {
      * before the first PAGE_STACK signal. Optional: only the native-host bridge
      * provides it (the default path derives the stack from the simulator URL). */
     getPageStack?(appId?: string): PageStackEntry[] | null;
+    /** The current (or named) app session's resource-server baseUrl (serves
+     * that session's framework js/css), or null when no matching session
+     * exists. Per-session, never a global singleton — see AppSession.resourceBaseUrl. */
+    getResourceBaseUrl?(appId?: string): string | null;
     /** Subscribe to render-side activity (domReady / active-page change). */
     onRenderEvent(listener: (event: RenderEvent) => void): () => void;
+    /** Subscribe to a service host's `did-finish-load` readiness (see
+     * `ServiceHostReadyEvent`'s doc comment). A subscriber registering after
+     * the still-live session's event already fired gets a missed-signal
+     * catch-up — it never needs to poll. */
+    onServiceHostReady(listener: (event: ServiceHostReadyEvent) => void): () => void;
     /** The currently-selected device (renderer toolbar), or null pre-selection. */
     getDevice(): NativeDeviceInfo | null;
     /** Cache the selected device + push DEVICE_CHANGE to the live simulator WC(s). */

package/dist/main/ipc/bridge-router.js

@@ -166,6 +166,8 @@ export function installBridgeRouter(ctx) {
         pendingApiCalls: new Map(),
         pool: null,
         emitRenderEvent: () => { },
+        emitServiceHostReady: () => { },
+        lastServiceHostReady: null,
         connections: ctx.connections,
         debugTap: createDebugTap({ enabled: resolveDebugTapEnabled() }),
         appLifecycle: createAppLifecycleController(),
@@ -237,6 +239,22 @@ export function installBridgeRouter(ctx) {
         }
     };
     state.emitRenderEvent = emitRenderEvent;
+    // Subscribers to `ServiceHostReadyEvent` (see its doc comment). Separate
+    // from `renderEventListeners`: this is session-scoped (appSessionId +
+    // serviceWcId), not page/bridgeId-scoped like `RenderEvent`.
+    const serviceHostReadyListeners = new Set();
+    const emitServiceHostReady = (event) => {
+        state.lastServiceHostReady = event;
+        for (const listener of serviceHostReadyListeners) {
+            try {
+                listener(event);
+            }
+            catch (error) {
+                console.warn('[bridge-router] service-host-ready listener threw:', error);
+            }
+        }
+    };
+    state.emitServiceHostReady = emitServiceHostReady;
     // Expose a thin accessor over RouterState so other main services (storage,
     // automation, appdata) can resolve live render/service WebContents without
     // owning router state. Getters resolve fresh — the pre-warm pool can swap
@@ -269,6 +287,10 @@ export function installBridgeRouter(ctx) {
             const ap = resolveCurrentApp(state, ctx, appId);
             return ap?.pageStack ?? null;
         },
+        getResourceBaseUrl: (appId) => {
+            const ap = resolveCurrentApp(state, ctx, appId);
+            return ap?.resourceBaseUrl ?? null;
+        },
         getActiveRenderWc: (appId) => {
             const ap = resolveCurrentApp(state, ctx, appId);
             if (!ap)
@@ -280,6 +302,35 @@ export function installBridgeRouter(ctx) {
             renderEventListeners.add(listener);
             return () => renderEventListeners.delete(listener);
         },
+        onServiceHostReady: (listener) => {
+            serviceHostReadyListeners.add(listener);
+            // Missed-signal catch-up (mirrors host-toolbar-port-channel.ts's
+            // `onReady`): a subscriber registering AFTER the session it cares
+            // about already booted must not wait forever for an event that
+            // already happened. Scheduled on a microtask (never synchronous —
+            // matches the same-tick-dispose/re-attach safety the host-toolbar
+            // pattern documents) and RE-VALIDATED at fire time: the session must
+            // still be live and still bound to the SAME serviceWcId the event
+            // captured, so a session that respawned/closed between registration
+            // and the microtask can't resurrect a stale attach.
+            const candidate = state.lastServiceHostReady;
+            if (candidate) {
+                queueMicrotask(() => {
+                    if (!serviceHostReadyListeners.has(listener))
+                        return;
+                    const ap = state.appSessions.get(candidate.appSessionId);
+                    if (!ap || ap.serviceWc.isDestroyed() || ap.serviceWc.id !== candidate.serviceWcId)
+                        return;
+                    try {
+                        listener(candidate);
+                    }
+                    catch (error) {
+                        console.warn('[bridge-router] service-host-ready catch-up listener threw:', error);
+                    }
+                });
+            }
+            return () => serviceHostReadyListeners.delete(listener);
+        },
         getDevice: () => currentDevice,
         setDevice: (device) => {
             currentDevice = device;
@@ -970,6 +1021,11 @@ async function bootServiceHost(state, ap, ctx) {
     // any diagnostic queued for this session (or the global bucket) into its now
     // resolvable console. Safe to call even when nothing is queued.
     ctx.consoleForwarder?.notifyServiceHostReady?.(ap.appSessionId);
+    // Same authoritative moment, exposed as a general subscribable event (see
+    // `ServiceHostReadyEvent`'s doc comment) — other main-process consumers
+    // (the right-panel DevTools attach) need this exact signal too and must
+    // not poll `getServiceWc` on a fixed retry budget for it.
+    state.emitServiceHostReady({ appId: ap.appId, appSessionId: ap.appSessionId, serviceWcId: ap.serviceWc.id });
     ap.logicInjected = await injectLogicBundle(ap);
     if (!ap.logicInjected) {
         // The compiled logic.js never executed, so `modDefine` registered nothing.

package/dist/main/ipc/index.d.ts

@@ -4,5 +4,6 @@ export { registerPopoverIpc, popoverModule } from './popover.js';
 export { registerProjectsIpc, projectsModule } from './projects.js';
 export { registerSessionIpc, sessionModule } from './session.js';
 export { registerSettingsIpc, settingsModule } from './settings.js';
+export { registerInternalDevtoolsIpc } from './internal-devtools.js';
 export { simulatorModule } from './simulator-module.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/main/ipc/index.js

@@ -4,5 +4,6 @@ export { registerPopoverIpc, popoverModule } from './popover.js';
 export { registerProjectsIpc, projectsModule } from './projects.js';
 export { registerSessionIpc, sessionModule } from './session.js';
 export { registerSettingsIpc, settingsModule } from './settings.js';
+export { registerInternalDevtoolsIpc } from './internal-devtools.js';
 export { simulatorModule } from './simulator-module.js';
 //# sourceMappingURL=index.js.map

package/dist/main/ipc/internal-devtools.d.ts

@@ -0,0 +1,15 @@
+import type { Disposable } from '@dimina-kit/electron-deck/main';
+import { type SenderPolicy } from '../utils/ipc-registry.js';
+import type { InternalDevtoolsWindow } from '../windows/internal-devtools-window/index.js';
+/**
+ * Standalone internal (app-wide) DevTools debug window. The simulator
+ * toolbar's "debug" button opens (or focuses) it via the window controller —
+ * a module-local narrow deps interface, not `WorkbenchContext`, per the
+ * shrink-only WorkbenchContext-import gate (see eslint.config.js).
+ */
+export interface InternalDevtoolsIpcDeps {
+    internalDevtoolsWindow?: InternalDevtoolsWindow;
+    senderPolicy: SenderPolicy;
+}
+export declare function registerInternalDevtoolsIpc(ctx: InternalDevtoolsIpcDeps): Disposable;
+//# sourceMappingURL=internal-devtools.d.ts.map

package/dist/main/ipc/internal-devtools.js

@@ -0,0 +1,9 @@
+import { InternalDevtoolsChannel } from '../../shared/ipc-channels.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
+export function registerInternalDevtoolsIpc(ctx) {
+    return new IpcRegistry(ctx.senderPolicy)
+        .handle(InternalDevtoolsChannel.Open, () => {
+        ctx.internalDevtoolsWindow?.open();
+    });
+}
+//# sourceMappingURL=internal-devtools.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