@dimina-kit/devtools 0.4.0-dev.20260728065133 → 0.4.0-dev.20260728095034

package/dist/main/ipc/settings.js

@@ -20,6 +20,10 @@ export function registerSettingsIpc(ctx) {
         .handle(WorkbenchSettingsChannel.SetTheme, (_, ...args) => {
         const [theme] = validate(WorkbenchSettingsChannel.SetTheme, WorkbenchSettingsSetThemeSchema, args);
         applyTheme(theme);
+    })
+        .handle(WorkbenchSettingsChannel.Restart, () => {
+        app.relaunch();
+        app.quit();
     })
         .handle(WorkbenchSettingsChannel.GetCdpStatus, () => {
         const settings = loadWorkbenchSettings();

package/dist/main/services/mcp/server.d.ts

@@ -7,5 +7,6 @@
  * only wires up transports and lifecycle.
  */
 import { type Disposable } from '@dimina-kit/electron-deck/main';
-export declare function startMcpServer(resolvedCdpPort: number, mcpPort: number): Disposable;
+import { type McpProjectHost } from './tools/project-tools.js';
+export declare function startMcpServer(resolvedCdpPort: number, mcpPort: number, projectHost: McpProjectHost): Disposable;
 //# sourceMappingURL=server.d.ts.map

package/dist/main/services/mcp/server.js

@@ -15,11 +15,12 @@ import { connectTarget, setCdpPort } from './target-manager.js';
 import { recordMcpFailed, recordMcpStarted, recordMcpStopped } from './status.js';
 import { registerCommonTargetTools } from './tool-registry.js';
 import { registerContextTools } from './tools/context-tools.js';
+import { registerProjectTools } from './tools/project-tools.js';
 import { registerSimulatorTools } from './tools/simulator-tools.js';
 import { registerWorkbenchTools } from './tools/workbench-tools.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../../../../package.json');
-function buildServer() {
+function buildServer(projectHost) {
     const server = new McpServer({
         name: '@dimina-kit/devtools',
         version: pkg.version,
@@ -32,9 +33,11 @@ function buildServer() {
     registerWorkbenchTools(server);
     // Cross-target: AI orientation overview
     registerContextTools(server);
+    // Project lifecycle (open/close/status/wait/compile logs).
+    registerProjectTools(server, projectHost);
     return server;
 }
-export function startMcpServer(resolvedCdpPort, mcpPort) {
+export function startMcpServer(resolvedCdpPort, mcpPort, projectHost) {
     setCdpPort(resolvedCdpPort);
     // Connect to both targets (non-blocking)
     connectTarget('simulator').catch(() => { });
@@ -55,7 +58,7 @@ export function startMcpServer(resolvedCdpPort, mcpPort) {
                 // closures over already-shared module-level state (target-manager's
                 // CDP connections/listeners) — it has no per-call side effects, so
                 // building N servers is cheap and duplicates nothing.
-                await buildServer().connect(transport);
+                await buildServer(projectHost).connect(transport);
             }
             catch (err) {
                 transports.delete(transport.sessionId);

package/dist/main/services/mcp/tools/project-tools.d.ts

@@ -0,0 +1,49 @@
+/**
+ * MCP project lifecycle tools: open (launch the mini-program in the
+ * simulator), close, query compile status, await the compile settling, and
+ * pull compile logs incrementally.
+ *
+ * `project_open` does NOT call `workspace.openProject` directly: the renderer
+ * owns the open path (mounting ProjectRuntime is what compiles AND attaches
+ * the simulator), so the tool pushes a `window:openProject` event and then
+ * awaits the session-status store — the same main-process authority the
+ * notifier tap feeds from the renderer-driven compile.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CompileLogBuffer } from '../../workspace/compile-log-buffer.js';
+import type { SessionStatusStore } from '../../workspace/session-status-store.js';
+/**
+ * Narrow structural slice of WorkspaceService the project tools need.
+ * Structural (not a Pick of the real interface) so tests can hand in a
+ * plain object and this module never imports workbench-context.
+ */
+export interface McpProjectWorkspace {
+    validateProjectDir(dirPath: string): Promise<string | null>;
+    hasProject(dirPath: string): Promise<boolean>;
+    addProject(dirPath: string): Promise<{
+        name: string;
+        path: string;
+    }>;
+    listProjects(): Promise<{
+        name: string;
+        path: string;
+    }[]>;
+    closeProject(): Promise<void>;
+    getProjectPath(): string;
+    hasActiveSession(): boolean;
+}
+/** Everything `registerProjectTools` needs, assembled by app bootstrap. */
+export interface McpProjectHost {
+    workspace: McpProjectWorkspace;
+    sessionStatus: SessionStatusStore;
+    compileLogs: CompileLogBuffer;
+    /** Push the renderer to open the project (the user-click-equivalent path). */
+    requestOpenInUi(project: {
+        name: string;
+        path: string;
+    }): void;
+    /** Push the renderer back to the project list after a close. */
+    requestNavigateBack(): void;
+}
+export declare function registerProjectTools(server: McpServer, host: McpProjectHost): void;
+//# sourceMappingURL=project-tools.d.ts.map

package/dist/main/services/mcp/tools/project-tools.js

@@ -0,0 +1,121 @@
+/**
+ * MCP project lifecycle tools: open (launch the mini-program in the
+ * simulator), close, query compile status, await the compile settling, and
+ * pull compile logs incrementally.
+ *
+ * `project_open` does NOT call `workspace.openProject` directly: the renderer
+ * owns the open path (mounting ProjectRuntime is what compiles AND attaches
+ * the simulator), so the tool pushes a `window:openProject` event and then
+ * awaits the session-status store — the same main-process authority the
+ * notifier tap feeds from the renderer-driven compile.
+ */
+import path from 'node:path';
+import { z } from 'zod';
+const DEFAULT_OPEN_TIMEOUT_MS = 180_000;
+const DEFAULT_WAIT_TIMEOUT_MS = 60_000;
+function text(payload) {
+    return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
+}
+function errorText(message) {
+    return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
+}
+/**
+ * Public phase: a settled store snapshot with no live session means no
+ * project is open ('idle'), while 'error'/'compiling' pass through as-is —
+ * `hasActiveSession()` is false during a compile and after a failed open,
+ * so those phases are the truthful answer even without a session.
+ */
+function publicPhase(snapshot, sessionActive) {
+    if (!sessionActive && snapshot.phase === 'ready')
+        return 'idle';
+    return snapshot.phase;
+}
+function statusPayload(host) {
+    const snapshot = host.sessionStatus.get();
+    const sessionActive = host.workspace.hasActiveSession();
+    return {
+        phase: publicPhase(snapshot, sessionActive),
+        message: snapshot.message,
+        projectPath: host.workspace.getProjectPath(),
+        sessionActive,
+        watcherAlive: snapshot.watcherAlive,
+        updatedAt: snapshot.updatedAt,
+        generation: snapshot.generation,
+    };
+}
+export function registerProjectTools(server, host) {
+    server.tool('project_open', 'Open a mini-program project: registers the directory if needed, launches it in the simulator (compile + attach), and waits until the compile settles. Returns the settled status; on compile error, pull stderr via compile_logs.', {
+        path: z.string().describe('Absolute path to the mini-program project directory'),
+        timeoutMs: z.number().optional().default(DEFAULT_OPEN_TIMEOUT_MS)
+            .describe('Max time to wait for the compile to settle'),
+    }, async ({ path: rawPath, timeoutMs }) => {
+        const dir = path.resolve(rawPath);
+        // Already open and settled: report instead of re-triggering a compile.
+        const current = host.sessionStatus.get();
+        if (host.workspace.getProjectPath() === dir
+            && host.workspace.hasActiveSession()
+            && current.phase === 'ready') {
+            return text({ ...statusPayload(host), note: 'project already open' });
+        }
+        const invalid = await host.workspace.validateProjectDir(dir);
+        if (invalid)
+            return errorText(invalid);
+        let project;
+        if (await host.workspace.hasProject(dir)) {
+            const known = (await host.workspace.listProjects()).find((p) => p.path === dir);
+            project = known ?? { name: path.basename(dir), path: dir };
+        }
+        else {
+            project = await host.workspace.addProject(dir);
+        }
+        // Snapshot the generation BEFORE the trigger so a previous session's
+        // settled state can never be mistaken for this open's result.
+        const afterGeneration = host.sessionStatus.get().generation;
+        host.requestOpenInUi({ name: project.name, path: project.path });
+        let settled;
+        try {
+            settled = await host.sessionStatus.waitForSettled({ afterGeneration, timeoutMs });
+        }
+        catch (err) {
+            return errorText(err instanceof Error ? err.message : String(err));
+        }
+        if (settled.phase === 'error') {
+            return errorText(`compile failed: ${settled.message} — call compile_logs (stream: "stderr") for details`);
+        }
+        return text(statusPayload(host));
+    });
+    server.tool('project_close', 'Close the currently open project session and return the workbench to the project list.', {}, async () => {
+        if (!host.workspace.getProjectPath() && !host.workspace.hasActiveSession()) {
+            return text({ closed: false, note: 'no project is open' });
+        }
+        await host.workspace.closeProject();
+        host.requestNavigateBack();
+        return text({ closed: true });
+    });
+    server.tool('project_status', 'Query the current project compile status (phase: idle | compiling | ready | error). Includes `generation` — pass it to project_wait_ready to await the NEXT settled state.', {}, async () => text(statusPayload(host)));
+    server.tool('project_wait_ready', 'Wait until the compile pipeline settles (phase leaves "compiling"). Watcher rebuilds emit no "compiling" phase, so to await a rebuild after editing files pass the `generation` from a prior project_status.', {
+        afterGeneration: z.number().optional()
+            .describe('Only accept states recorded after this generation (from project_status). Omit to accept the current state when already settled.'),
+        timeoutMs: z.number().optional().default(DEFAULT_WAIT_TIMEOUT_MS)
+            .describe('Max time to wait'),
+    }, async ({ afterGeneration, timeoutMs }) => {
+        try {
+            await host.sessionStatus.waitForSettled({ afterGeneration, timeoutMs });
+        }
+        catch (err) {
+            return errorText(err instanceof Error ? err.message : String(err));
+        }
+        return text(statusPayload(host));
+    });
+    server.tool('compile_logs', 'Pull compile log lines incrementally. Pass the previous call\'s nextCursor as `cursor` to receive only new lines. The buffer resets on each fresh project open; watcher rebuilds append to the same timeline.', {
+        cursor: z.number().optional().default(0)
+            .describe('Return only lines after this cursor (0 = from the start of the buffer)'),
+        limit: z.number().optional().default(100).describe('Max lines to return'),
+        stream: z.enum(['stdout', 'stderr']).optional()
+            .describe('Only lines from this stream (stderr carries compile errors)'),
+    }, async ({ cursor, limit, stream }) => {
+        const read = host.compileLogs.read({ afterSeq: cursor, limit, stream });
+        return text(read);
+    });
+}
+//# sourceMappingURL=project-tools.js.map

package/dist/main/services/notifications/renderer-notifier.d.ts

@@ -94,6 +94,17 @@ export interface RendererNotifier {
     compileLog(payload: CompileLogPayload): void;
     /** Ask the main renderer to navigate back to its landing screen. */
     windowNavigateBack(): void;
+    /**
+     * Ask the main renderer to open a project (mount the project runtime and
+     * start the compile), exactly as if the user clicked it in the list. The
+     * renderer owns the open path — the simulator only mounts when the
+     * ProjectRuntime component does — so main-side callers (MCP `project_open`)
+     * push this instead of calling `workspace.openProject` directly.
+     */
+    windowOpenProject(payload: {
+        name: string;
+        path: string;
+    }): void;
     /** Tell the main renderer the compile popover has been closed. */
     popoverClosed(): void;
     /** Ask the main renderer to relaunch the simulator with a new config. */

package/dist/main/services/notifications/renderer-notifier.js

@@ -33,6 +33,9 @@ export function createRendererNotifier(ctx) {
         windowNavigateBack() {
             sendToMain(WindowChannel.NavigateBack);
         },
+        windowOpenProject(payload) {
+            sendToMain(WindowChannel.OpenProject, payload);
+        },
         popoverClosed() {
             sendToMain(PopoverChannel.Closed);
         },

package/dist/main/services/workbench-context.d.ts

@@ -12,6 +12,8 @@ import type { SyncStorageChange } from '../../shared/ipc-channels.js';
 import { DisposableRegistry, type ConnectionRegistry } from '@dimina-kit/electron-deck/main';
 import type { SenderPolicy } from '../utils/ipc-registry.js';
 import { type RendererNotifier } from './notifications/renderer-notifier.js';
+import { type CompileLogBuffer } from './workspace/compile-log-buffer.js';
+import { type SessionStatusStore } from './workspace/session-status-store.js';
 import { type ViewManager } from './views/view-manager.js';
 import { type WindowService } from './window-service.js';
 import { type WorkspaceService } from './workspace/workspace-service.js';
@@ -47,6 +49,18 @@ export interface WorkbenchContext {
     windows: WindowService;
     /** Unified main → renderer event dispatcher */
     notify: RendererNotifier;
+    /**
+     * Authoritative, queryable compile status of the active session. Fed by the
+     * notifier tap (every `notify.projectStatus` is recorded here first), read
+     * by MCP `project_status` / awaited by `project_open` / `project_wait_ready`.
+     */
+    sessionStatus: SessionStatusStore;
+    /**
+     * Cursor-readable ring buffer over the compile log lines. Fed by the
+     * notifier tap (every `notify.compileLog` is appended here first), read
+     * incrementally by MCP `compile_logs`.
+     */
+    compileLogBuffer: CompileLogBuffer;
     /**
      * Open (or re-focus) the standalone workbench-settings window. First-class
      * member so contract holders (`MiniappRuntime` / `MenuContext`) can open

package/dist/main/services/workbench-context.js

@@ -3,6 +3,9 @@ import { createConnectionRegistry, DisposableRegistry, } from '@dimina-kit/elect
 import { createWorkbenchSenderPolicy } from '../utils/sender-policy.js';
 import { defaultAdapter } from './default-adapter.js';
 import { createRendererNotifier, } from './notifications/renderer-notifier.js';
+import { createCompileLogBuffer, } from './workspace/compile-log-buffer.js';
+import { createSessionStatusStore, } from './workspace/session-status-store.js';
+import { tapNotifierIntoStores } from './workspace/status-tap.js';
 import { createViewManager } from './views/view-manager.js';
 import { createWindowService } from './window-service.js';
 import { openSettingsWindow } from '../windows/settings-window/index.js';
@@ -38,7 +41,12 @@ export function createWorkbenchContext(opts) {
     // the one place that releases the HOST-scoped toolbar (its view and the
     // ref-counted session-runtime preload) when the app/context winds down.
     ctx.registry.add(() => ctx.views.disposeAll());
-    ctx.notify = createRendererNotifier(ctx);
+    ctx.sessionStatus = createSessionStatusStore();
+    ctx.compileLogBuffer = createCompileLogBuffer();
+    // Tap the notify gate: the two compile-state pushes land in the
+    // main-process authorities above BEFORE the renderer broadcast, so MCP
+    // reads and the renderer view derive from the same single site.
+    ctx.notify = tapNotifierIntoStores(createRendererNotifier(ctx), ctx.sessionStatus, ctx.compileLogBuffer);
     // Lazy closure (not a bound snapshot): reads ctx.windows/notify/rendererDir
     // at call time through the live context, which structurally satisfies the
     // helper's narrow OpenSettingsWindowDeps.

package/dist/main/services/workspace/compile-log-buffer.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Ring buffer over the per-line dmcc compile log, readable by cursor.
+ *
+ * The renderer gets each line pushed (`notify.compileLog`); MCP clients pull
+ * incrementally instead: pass the previous read's `nextCursor` to receive
+ * only lines that arrived since. `seq` is monotonic for the buffer's whole
+ * lifetime — `clear()` (a fresh project open) drops the entries but never
+ * resets the counter, so a stale cursor from before the clear simply reads
+ * the new compile's lines instead of duplicating old ones.
+ */
+export interface CompileLogRecord {
+    /** Monotonic id (1-based); never reused, survives clear(). */
+    seq: number;
+    /** Main-process capture time of the line. */
+    at: number;
+    stream: 'stdout' | 'stderr';
+    text: string;
+}
+export interface CompileLogRead {
+    /** Oldest-first entries with seq > afterSeq (post stream-filter), capped at limit. */
+    entries: CompileLogRecord[];
+    /** Pass back as the next read's afterSeq; unchanged when nothing new matched. */
+    nextCursor: number;
+}
+export interface CompileLogBuffer {
+    append(entry: {
+        at: number;
+        stream: 'stdout' | 'stderr';
+        text: string;
+    }): void;
+    read(opts?: {
+        afterSeq?: number;
+        limit?: number;
+        stream?: 'stdout' | 'stderr';
+    }): CompileLogRead;
+    /** Drop all entries (fresh compile timeline); seq keeps growing. */
+    clear(): void;
+}
+export declare function createCompileLogBuffer(capacity?: number): CompileLogBuffer;
+//# sourceMappingURL=compile-log-buffer.d.ts.map

package/dist/main/services/workspace/compile-log-buffer.js

@@ -0,0 +1,41 @@
+/**
+ * Ring buffer over the per-line dmcc compile log, readable by cursor.
+ *
+ * The renderer gets each line pushed (`notify.compileLog`); MCP clients pull
+ * incrementally instead: pass the previous read's `nextCursor` to receive
+ * only lines that arrived since. `seq` is monotonic for the buffer's whole
+ * lifetime — `clear()` (a fresh project open) drops the entries but never
+ * resets the counter, so a stale cursor from before the clear simply reads
+ * the new compile's lines instead of duplicating old ones.
+ */
+const DEFAULT_CAPACITY = 1000;
+const DEFAULT_READ_LIMIT = 100;
+export function createCompileLogBuffer(capacity = DEFAULT_CAPACITY) {
+    const entries = [];
+    let seq = 0;
+    return {
+        append(entry) {
+            entries.push({ seq: ++seq, ...entry });
+            if (entries.length > capacity)
+                entries.splice(0, entries.length - capacity);
+        },
+        read({ afterSeq = 0, limit = DEFAULT_READ_LIMIT, stream } = {}) {
+            const matched = [];
+            for (const entry of entries) {
+                if (entry.seq <= afterSeq)
+                    continue;
+                if (stream && entry.stream !== stream)
+                    continue;
+                matched.push(entry);
+                if (matched.length >= limit)
+                    break;
+            }
+            const last = matched[matched.length - 1];
+            return { entries: matched, nextCursor: last ? last.seq : afterSeq };
+        },
+        clear() {
+            entries.length = 0;
+        },
+    };
+}
+//# sourceMappingURL=compile-log-buffer.js.map

package/dist/main/services/workspace/session-status-store.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Authoritative, queryable record of the active project's compile status in
+ * the main process.
+ *
+ * `notify.projectStatus` is a fire-and-forget push to the renderer; MCP
+ * clients instead need to QUERY the latest state and AWAIT the next settled
+ * state. The notifier tap (see `status-tap.ts`) records every payload here
+ * BEFORE it is broadcast — the store is the authority, the renderer push is
+ * derived from the same single gate.
+ *
+ * "Settled" means the compile pipeline is not mid-flight: every phase except
+ * `'compiling'`. `generation` is a monotonic per-record counter so a waiter
+ * can ignore states recorded before its own trigger (e.g. `project_open`
+ * must not accept the PREVIOUS session's `'ready'` as its own result).
+ */
+export type SessionPhase = 'idle' | 'compiling' | 'ready' | 'error';
+export interface SessionStatusSnapshot {
+    phase: SessionPhase;
+    message: string;
+    /** False once the file watcher died mid-session (saves no longer trigger a rebuild). Reset when the next compile starts. */
+    watcherAlive: boolean;
+    /** Wall-clock time of the last recorded transition; 0 before the first one. */
+    updatedAt: number;
+    /** Monotonic counter bumped on every record. */
+    generation: number;
+}
+export interface SessionStatusStore {
+    get(): SessionStatusSnapshot;
+    /** Record one `projectStatus` payload (the notifier tap is the only expected caller). */
+    record(payload: {
+        status: string;
+        message: string;
+        watcher?: 'dead';
+    }): void;
+    /**
+     * Resolve with the first snapshot whose phase is settled (not 'compiling')
+     * AND whose generation is greater than `afterGeneration` (default: accept
+     * the current snapshot when it is already settled). Rejects after
+     * `timeoutMs` with the last observed phase in the message.
+     */
+    waitForSettled(opts: {
+        afterGeneration?: number;
+        timeoutMs: number;
+    }): Promise<SessionStatusSnapshot>;
+}
+export declare function createSessionStatusStore(): SessionStatusStore;
+//# sourceMappingURL=session-status-store.d.ts.map

package/dist/main/services/workspace/session-status-store.js

@@ -0,0 +1,73 @@
+/**
+ * Authoritative, queryable record of the active project's compile status in
+ * the main process.
+ *
+ * `notify.projectStatus` is a fire-and-forget push to the renderer; MCP
+ * clients instead need to QUERY the latest state and AWAIT the next settled
+ * state. The notifier tap (see `status-tap.ts`) records every payload here
+ * BEFORE it is broadcast — the store is the authority, the renderer push is
+ * derived from the same single gate.
+ *
+ * "Settled" means the compile pipeline is not mid-flight: every phase except
+ * `'compiling'`. `generation` is a monotonic per-record counter so a waiter
+ * can ignore states recorded before its own trigger (e.g. `project_open`
+ * must not accept the PREVIOUS session's `'ready'` as its own result).
+ */
+function toPhase(status) {
+    if (status === 'compiling')
+        return 'compiling';
+    if (status === 'error')
+        return 'error';
+    // 'ready' plus any future non-error chatter: the pipeline is not mid-flight.
+    return 'ready';
+}
+export function createSessionStatusStore() {
+    let snapshot = {
+        phase: 'idle',
+        message: '',
+        watcherAlive: true,
+        updatedAt: 0,
+        generation: 0,
+    };
+    const waiters = new Set();
+    return {
+        get: () => snapshot,
+        record(payload) {
+            const phase = toPhase(payload.status);
+            snapshot = {
+                phase,
+                message: payload.message,
+                // A dead watcher is a session-lifetime fact; only a NEW compile
+                // (fresh open) resets it. Rebuild 'ready' chatter keeps it dead.
+                watcherAlive: payload.watcher === 'dead'
+                    ? false
+                    : phase === 'compiling' ? true : snapshot.watcherAlive,
+                updatedAt: Date.now(),
+                generation: snapshot.generation + 1,
+            };
+            for (const waiter of [...waiters])
+                waiter(snapshot);
+        },
+        waitForSettled({ afterGeneration = -1, timeoutMs }) {
+            const isSettled = (s) => s.phase !== 'compiling' && s.generation > afterGeneration;
+            if (isSettled(snapshot))
+                return Promise.resolve(snapshot);
+            return new Promise((resolve, reject) => {
+                const timer = setTimeout(() => {
+                    waiters.delete(onRecord);
+                    reject(new Error(`timed out after ${timeoutMs}ms waiting for the compile to settle `
+                        + `(last phase: ${snapshot.phase})`));
+                }, timeoutMs);
+                const onRecord = (s) => {
+                    if (!isSettled(s))
+                        return;
+                    clearTimeout(timer);
+                    waiters.delete(onRecord);
+                    resolve(s);
+                };
+                waiters.add(onRecord);
+            });
+        },
+    };
+}
+//# sourceMappingURL=session-status-store.js.map

package/dist/main/services/workspace/status-tap.d.ts

@@ -0,0 +1,20 @@
+import type { RendererNotifier } from '../notifications/renderer-notifier.js';
+import type { CompileLogBuffer } from './compile-log-buffer.js';
+import type { SessionStatusStore } from './session-status-store.js';
+/**
+ * Wraps the renderer notifier so the two compile-state pushes ALSO land in
+ * the main-process authorities (session-status store + compile-log buffer)
+ * before the renderer broadcast.
+ *
+ * `ctx.notify` is the single outlet every status transition and log line
+ * already flows through (`workspace-service`'s `sendStatus` / `onLog`
+ * closures), so tapping at this gate keeps ONE bookkeeping site instead of a
+ * second call next to every producer — and the stale-session generation
+ * guard upstream of the notify call protects the store/buffer for free.
+ *
+ * A fresh open (`'compiling'` without `hotReload`) starts a new compile
+ * timeline, so it clears the buffer; watcher rebuilds never pass through
+ * `'compiling'` and keep appending to the same timeline.
+ */
+export declare function tapNotifierIntoStores(notify: RendererNotifier, status: SessionStatusStore, compileLogs: CompileLogBuffer): RendererNotifier;
+//# sourceMappingURL=status-tap.d.ts.map

package/dist/main/services/workspace/status-tap.js

@@ -0,0 +1,32 @@
+/**
+ * Wraps the renderer notifier so the two compile-state pushes ALSO land in
+ * the main-process authorities (session-status store + compile-log buffer)
+ * before the renderer broadcast.
+ *
+ * `ctx.notify` is the single outlet every status transition and log line
+ * already flows through (`workspace-service`'s `sendStatus` / `onLog`
+ * closures), so tapping at this gate keeps ONE bookkeeping site instead of a
+ * second call next to every producer — and the stale-session generation
+ * guard upstream of the notify call protects the store/buffer for free.
+ *
+ * A fresh open (`'compiling'` without `hotReload`) starts a new compile
+ * timeline, so it clears the buffer; watcher rebuilds never pass through
+ * `'compiling'` and keep appending to the same timeline.
+ */
+export function tapNotifierIntoStores(notify, status, compileLogs) {
+    return {
+        ...notify,
+        projectStatus(payload) {
+            if (payload.status === 'compiling' && payload.hotReload !== true) {
+                compileLogs.clear();
+            }
+            status.record(payload);
+            notify.projectStatus(payload);
+        },
+        compileLog(payload) {
+            compileLogs.append(payload);
+            notify.compileLog(payload);
+        },
+    };
+}
+//# sourceMappingURL=status-tap.js.map