@minionry/minion 0.7.36

package/dist/server/services/websocket/browser-payloads.js

@@ -0,0 +1,222 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { parseEngineId } from '../../engines/EngineEvent.js';
+export function asObject(data) {
+    if (!data || typeof data !== 'object')
+        return null;
+    return data;
+}
+export function extractString(data, key) {
+    const obj = asObject(data);
+    if (!obj)
+        return null;
+    const value = obj[key];
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+const COORD_MAX = 16_384;
+const COORD_MIN = -16_384;
+const BOUNDS_MAX = 16_384;
+function clampCoord(n) {
+    if (!Number.isFinite(n))
+        return 0;
+    return Math.max(COORD_MIN, Math.min(COORD_MAX, n));
+}
+function clampDimension(n) {
+    if (!Number.isFinite(n) || n < 0)
+        return 0;
+    return Math.min(BOUNDS_MAX, n);
+}
+export function extractBounds(data) {
+    const obj = asObject(data);
+    if (!obj)
+        return null;
+    const width = typeof obj.width === 'number' ? obj.width : null;
+    const height = typeof obj.height === 'number' ? obj.height : null;
+    if (width === null || height === null)
+        return null;
+    const x = typeof obj.x === 'number' ? clampCoord(obj.x) : 0;
+    const y = typeof obj.y === 'number' ? clampCoord(obj.y) : 0;
+    const mobile = obj.mobile === true;
+    const deviceScaleFactor = typeof obj.deviceScaleFactor === 'number' && Number.isFinite(obj.deviceScaleFactor)
+        ? obj.deviceScaleFactor
+        : 1;
+    return {
+        x,
+        y,
+        width: clampDimension(width),
+        height: clampDimension(height),
+        mobile,
+        deviceScaleFactor,
+    };
+}
+export function extractFormFactor(data) {
+    const v = extractString(data, 'formFactor');
+    return v === 'mobile' || v === 'desktop' ? v : null;
+}
+export function passThroughInputEnvelope(data) {
+    const obj = asObject(data);
+    if (!obj)
+        return null;
+    if (typeof obj.kind !== 'string' || obj.kind.length === 0)
+        return null;
+    return obj;
+}
+export function extractTabId(data) {
+    const obj = asObject(data);
+    if (!obj)
+        return null;
+    if (typeof obj.id === 'string' && obj.id.length > 0)
+        return obj.id;
+    if (typeof obj.tabId === 'string' && obj.tabId.length > 0)
+        return obj.tabId;
+    return null;
+}
+export function extractIceServers(data) {
+    const raw = pickRawIceServers(data);
+    if (!raw)
+        return null;
+    if (raw.length === 0)
+        return [];
+    const capped = raw.slice(0, MAX_ICE_SERVERS);
+    const out = [];
+    for (const entry of capped) {
+        const server = normalizeIceServer(entry);
+        if (server)
+            out.push(server);
+    }
+    return out.length > 0 ? out : null;
+}
+const MAX_ICE_SERVERS = 16;
+const ICE_URL_SCHEME_RE = /^(stun|stuns|turn|turns):/i;
+function pickRawIceServers(data) {
+    if (Array.isArray(data))
+        return data;
+    const obj = asObject(data);
+    if (!obj)
+        return null;
+    const field = obj.iceServers;
+    return Array.isArray(field) ? field : null;
+}
+function normalizeIceServer(entry) {
+    const obj = asObject(entry);
+    if (!obj)
+        return null;
+    const urls = obj.urls;
+    if (typeof urls === 'string') {
+        if (!ICE_URL_SCHEME_RE.test(urls))
+            return null;
+    }
+    else if (Array.isArray(urls)) {
+        if (urls.length === 0)
+            return null;
+        if (!urls.every((u) => typeof u === 'string' && ICE_URL_SCHEME_RE.test(u))) {
+            return null;
+        }
+    }
+    else {
+        return null;
+    }
+    const server = { urls: urls };
+    if (typeof obj.username === 'string')
+        server.username = obj.username;
+    if (typeof obj.credential === 'string')
+        server.credential = obj.credential;
+    return server;
+}
+export function extractAnswerEnvelope(data) {
+    const obj = asObject(data);
+    if (!obj)
+        return null;
+    if (typeof obj.sessionId !== 'string' || typeof obj.sdp !== 'string')
+        return null;
+    return { kind: 'answer', sessionId: obj.sessionId, sdp: obj.sdp };
+}
+export function extractIceEnvelope(data) {
+    const obj = asObject(data);
+    if (!obj)
+        return null;
+    if (typeof obj.sessionId !== 'string')
+        return null;
+    const candidate = obj.candidate === null ? null : extractCandidate(obj.candidate);
+    if (candidate === undefined)
+        return null;
+    return { kind: 'ice', sessionId: obj.sessionId, candidate };
+}
+function extractCandidate(raw) {
+    if (raw === null)
+        return undefined;
+    const obj = asObject(raw);
+    if (!obj)
+        return undefined;
+    const out = {};
+    if (typeof obj.candidate === 'string')
+        out.candidate = obj.candidate;
+    if (obj.sdpMLineIndex === null || typeof obj.sdpMLineIndex === 'number') {
+        out.sdpMLineIndex = obj.sdpMLineIndex;
+    }
+    if (obj.sdpMid === null || typeof obj.sdpMid === 'string') {
+        out.sdpMid = obj.sdpMid;
+    }
+    if (obj.usernameFragment === null || typeof obj.usernameFragment === 'string') {
+        out.usernameFragment = obj.usernameFragment;
+    }
+    return out;
+}
+export function extractLeaseReleaseRequest(data) {
+    const obj = asObject(data);
+    if (!obj)
+        return null;
+    const tabId = typeof obj.tabId === 'string' && obj.tabId.length > 0 ? obj.tabId : null;
+    const agentId = typeof obj.agentId === 'string' && obj.agentId.length > 0 ? obj.agentId : null;
+    if (!tabId || !agentId)
+        return null;
+    return { tabId, agentId };
+}
+export function extractAgentTask(data) {
+    const task = extractString(data, 'task');
+    if (!task)
+        return null;
+    const boardId = extractString(data, 'boardId') ?? undefined;
+    const taskId = extractString(data, 'taskId') ?? undefined;
+    const tabId = extractString(data, 'tabId') ?? undefined;
+    const model = extractString(data, 'model') ?? undefined;
+    const engine = parseEngineId(extractString(data, 'engine'));
+    const effortLevel = extractString(data, 'effortLevel') ?? undefined;
+    return {
+        task,
+        ...(boardId ? { boardId } : {}),
+        ...(taskId ? { taskId } : {}),
+        ...(tabId ? { tabId } : {}),
+        ...(model ? { model } : {}),
+        ...(engine ? { engine } : {}),
+        ...(effortLevel ? { effortLevel } : {}),
+    };
+}
+export function extractAgentApprove(data) {
+    const obj = asObject(data);
+    if (!obj)
+        return null;
+    const proposalId = typeof obj.proposalId === 'string' && obj.proposalId.length > 0 ? obj.proposalId : null;
+    const verdict = obj.verdict;
+    if (!proposalId || (verdict !== 'approve' && verdict !== 'edit' && verdict !== 'deny')) {
+        return null;
+    }
+    const editedText = typeof obj.editedText === 'string' ? obj.editedText : undefined;
+    return { proposalId, verdict, ...(editedText !== undefined ? { editedText } : {}) };
+}
+export function extractStateEnvelope(data) {
+    const obj = asObject(data);
+    if (!obj)
+        return null;
+    if (typeof obj.sessionId !== 'string')
+        return null;
+    const state = obj.state;
+    if (state !== 'negotiating' &&
+        state !== 'connected' &&
+        state !== 'failed' &&
+        state !== 'closed') {
+        return null;
+    }
+    const reason = typeof obj.reason === 'string' ? obj.reason : undefined;
+    return { kind: 'state', sessionId: obj.sessionId, state, reason };
+}

package/dist/server/services/websocket/browser-viewer-lifecycle.js

@@ -0,0 +1,84 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { browserLog } from '../browser/debug-log.js';
+import { getBrowserDriverState } from '../browser/driver-state.js';
+import { captureException } from '../sentry.js';
+import { resetDriverFormFactor } from './browser-device-profile.js';
+import { resetIceConfigForHostRestart } from './browser-ice-config.js';
+import { MAX_HUMAN_SURFACES, viewers } from './browser-viewer-registry.js';
+const log = browserLog('handlers');
+const deviceInputTabs = new Map();
+const unscopedInputViewers = new Set();
+const UNSCOPED_INPUT_VIEWERS_MAX = MAX_HUMAN_SURFACES * 8;
+export function _resetViewerLifecycleForTests() {
+    deviceInputTabs.clear();
+    unscopedInputViewers.clear();
+}
+export function recordDeviceInput(viewerId, ws, tabId) {
+    releaseDeviceInput(viewerId, tabId);
+    deviceInputTabs.set(viewerId, { ws, tabId });
+}
+export function releaseDeviceInput(viewerId, keepTabId) {
+    const input = deviceInputTabs.get(viewerId);
+    if (!input || input.tabId === keepTabId)
+        return;
+    deviceInputTabs.delete(viewerId);
+    getBrowserDriverState().releaseHeldInput(input.tabId);
+}
+export function releaseViewerInput(viewer) {
+    getBrowserDriverState().releaseHeldInput(viewer.tabId);
+    releaseDeviceInput(viewer.viewerId);
+}
+export function viewerSessionFor(viewerId, kind) {
+    const sessionId = viewers.getByViewer(viewerId)?.sessionId;
+    if (sessionId) {
+        unscopedInputViewers.delete(viewerId);
+        return sessionId;
+    }
+    if (kind === 'input' && !unscopedInputViewers.has(viewerId)) {
+        if (unscopedInputViewers.size >= UNSCOPED_INPUT_VIEWERS_MAX)
+            unscopedInputViewers.clear();
+        unscopedInputViewers.add(viewerId);
+        log.warn('input.unscoped', `viewer=${viewerId.slice(0, 8)} — no attached session; input goes to the agent surface until browser_webrtc_attach lands`);
+    }
+    return undefined;
+}
+function releaseViewer(host, viewer, context) {
+    releaseViewerInput(viewer);
+    void host.closeCaptureFor(viewer.sessionId).catch((err) => {
+        captureException(err, { context });
+    });
+}
+export function onWsContextClosed(host, ws) {
+    for (const viewer of viewers.detachByWs(ws)) {
+        log.info('viewer.detachByWs', `session=${viewer.sessionId.slice(0, 8)} viewers=${viewers.size()}`);
+        releaseViewer(host, viewer, 'websocket.browser.onWsContextClosed');
+    }
+    for (const [viewerId, input] of deviceInputTabs) {
+        if (input.ws === ws)
+            releaseDeviceInput(viewerId);
+    }
+}
+export function onViewerDisconnected(host, viewerId) {
+    for (const sdkViewer of viewers.detachSdkByOwnerViewer(viewerId)) {
+        log.info('viewer.detachSdkByOwner', `session=${sdkViewer.sessionId.slice(0, 8)} viewers=${viewers.size()}`);
+        sdkViewer.sdkSink?.({ kind: 'sessionReset', reason: 'viewer_disconnected' });
+        releaseViewer(host, sdkViewer, 'websocket.browser.onViewerDisconnected.sdk');
+    }
+    releaseDeviceInput(viewerId);
+    const viewer = viewers.detachByViewer(viewerId);
+    if (!viewer)
+        return;
+    log.info('viewer.detachByViewer', `session=${viewer.sessionId.slice(0, 8)} viewer=${viewerId.slice(0, 8)} viewers=${viewers.size()}`);
+    releaseViewer(host, viewer, 'websocket.browser.onViewerDisconnected');
+}
+export function resetSessionState(reason) {
+    viewers.forEach((viewer) => {
+        viewer.sdkSink?.({ kind: 'sessionReset', reason });
+    });
+    viewers.clear();
+    deviceInputTabs.clear();
+    unscopedInputViewers.clear();
+    resetIceConfigForHostRestart();
+    resetDriverFormFactor();
+}

package/dist/server/services/websocket/browser-viewer-registry.js

@@ -0,0 +1,118 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { randomUUID } from 'node:crypto';
+import { debugLog } from './debug-log.js';
+const log = debugLog('viewers');
+export function canAddressViewer(ws, viewerId) {
+    return viewerId !== undefined && (!ws._isPlatformRelay || viewerId !== ws._viewerId);
+}
+export function addressToViewer(response, ws, viewerId) {
+    if (canAddressViewer(ws, viewerId)) {
+        response._target = viewerId;
+    }
+    return response;
+}
+export class BrowserViewerRegistry {
+    bySession = new Map();
+    byViewer = new Map();
+    attach(viewerId, ws, tabId, attachId, opts = {}) {
+        const existing = this.byViewer.get(viewerId);
+        if (existing) {
+            log('attach.replace', `viewer=${viewerId.slice(0, 8)} prior=${existing.sessionId.slice(0, 8)}`);
+            this.bySession.delete(existing.sessionId);
+            this.byViewer.delete(viewerId);
+        }
+        const viewer = {
+            sessionId: randomUUID(),
+            viewerId,
+            ws,
+            tabId,
+            lastState: null,
+            routable: opts.routable ?? true,
+            ...(attachId ? { attachId } : {}),
+        };
+        this.bySession.set(viewer.sessionId, viewer);
+        this.byViewer.set(viewerId, viewer);
+        return viewer;
+    }
+    attachSdk(args) {
+        const existing = this.byViewer.get(args.key);
+        if (existing) {
+            this.bySession.delete(existing.sessionId);
+            this.byViewer.delete(args.key);
+        }
+        const viewer = {
+            sessionId: randomUUID(),
+            viewerId: args.key,
+            tabId: args.tabId,
+            lastState: null,
+            routable: true,
+            sdkSink: args.sink,
+            ...(args.ownerViewerId ? { ownerViewerId: args.ownerViewerId } : {}),
+        };
+        this.bySession.set(viewer.sessionId, viewer);
+        this.byViewer.set(args.key, viewer);
+        log.info('attachSdk', `session=${viewer.sessionId.slice(0, 8)} key=${args.key} tab=${args.tabId.slice(0, 8)} owner=${args.ownerViewerId?.slice(0, 8) ?? '-'} replaced=${existing?.sessionId.slice(0, 8) ?? '-'} viewers=${this.bySession.size}`);
+        return viewer;
+    }
+    detachSdkByOwnerViewer(viewerId) {
+        const removed = [];
+        for (const v of [...this.bySession.values()]) {
+            if (!v.sdkSink || v.ownerViewerId !== viewerId)
+                continue;
+            this.bySession.delete(v.sessionId);
+            this.byViewer.delete(v.viewerId);
+            removed.push(v);
+        }
+        return removed;
+    }
+    getBySession(sessionId) {
+        return this.bySession.get(sessionId);
+    }
+    getByViewer(viewerId) {
+        return this.byViewer.get(viewerId);
+    }
+    detach(sessionId) {
+        const viewer = this.bySession.get(sessionId);
+        if (!viewer) {
+            log('detach.unknown', `session=${sessionId.slice(0, 8)}`);
+            return undefined;
+        }
+        this.bySession.delete(sessionId);
+        this.byViewer.delete(viewer.viewerId);
+        log.info('detach', `session=${sessionId.slice(0, 8)} viewer=${viewer.viewerId.slice(0, 8)} lastState=${viewer.lastState ?? 'pending'} viewers=${this.bySession.size}`);
+        return viewer;
+    }
+    detachByViewer(viewerId) {
+        const viewer = this.byViewer.get(viewerId);
+        if (!viewer)
+            return undefined;
+        this.bySession.delete(viewer.sessionId);
+        this.byViewer.delete(viewerId);
+        return viewer;
+    }
+    detachByWs(ws) {
+        const removed = [];
+        for (const v of [...this.bySession.values()]) {
+            if (v.ws !== ws)
+                continue;
+            this.bySession.delete(v.sessionId);
+            this.byViewer.delete(v.viewerId);
+            removed.push(v);
+        }
+        return removed;
+    }
+    forEach(fn) {
+        for (const v of this.bySession.values())
+            fn(v);
+    }
+    size() {
+        return this.bySession.size;
+    }
+    clear() {
+        this.bySession.clear();
+        this.byViewer.clear();
+    }
+}
+export const MAX_HUMAN_SURFACES = 8;
+export const viewers = new BrowserViewerRegistry();

package/dist/server/services/websocket/collab-broadcast.js

@@ -0,0 +1,11 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export function collabKey(absolutePath) {
+    return absolutePath;
+}
+export function broadcastCollabEvent(ctx, key, type, data) {
+    const buffer = ctx.collabEventBuffers.getOrCreate(key);
+    const seq = buffer.record(type, data);
+    ctx.broadcastToAll({ type, data, seq, collabKey: key });
+    return seq;
+}

package/dist/server/services/websocket/collab-handlers.js

@@ -0,0 +1,116 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { can } from '@minionry/roles';
+import { safeRealpath } from '../collab/registry.js';
+import { validatePathWithinRoots } from '../file-explorer-ops.js';
+import { systemPromptsDir } from '../system-prompts.js';
+const COLLAB_WRITE_OPS = new Set(['collabPush', 'collabFlush']);
+export function handleCollabMessage(ctx, ws, msg, effectiveDir, role, viewerId) {
+    if (!viewerId) {
+        console.warn(`[collab] dropping ${msg.type}: no viewer identity on the frame`);
+        return;
+    }
+    const requestPath = typeof msg.data?.path === 'string' ? msg.data.path : '';
+    if (!requestPath) {
+        sendCollabError(ctx, ws, viewerId, '', msg.type, 'unsupported', 'File path is required');
+        return;
+    }
+    if (COLLAB_WRITE_OPS.has(msg.type) && !can(role, 'editFiles')) {
+        sendCollabError(ctx, ws, viewerId, requestPath, msg.type, 'read_only', 'Your role does not permit editing files');
+        return;
+    }
+    const extraRoots = role === 'owner' ? [systemPromptsDir()] : [];
+    const validation = validatePathWithinRoots(requestPath, effectiveDir, extraRoots);
+    if (!validation.valid) {
+        sendCollabError(ctx, ws, viewerId, requestPath, msg.type, 'sandbox', validation.error ?? 'Sandboxed: path outside project directory');
+        return;
+    }
+    const req = {
+        ws,
+        viewerId,
+        requestPath,
+        key: safeRealpath(validation.resolvedPath),
+        workingDir: effectiveDir,
+        extraRoots,
+    };
+    ctx.collabSessions.noteDevice(viewerId, ws);
+    switch (msg.type) {
+        case 'collabJoin':
+            handleJoin(ctx, req, msg, role);
+            return;
+        case 'collabLeave':
+            withClientId(msg, (clientID) => ctx.collabSessions.leave(req, clientID));
+            return;
+        case 'collabPush':
+            withClientId(msg, (clientID) => ctx.collabSessions.push(req, clientID, readVersion(msg), readUpdates(msg)));
+            return;
+        case 'collabCursor':
+            withClientId(msg, (clientID) => ctx.collabSessions.cursor(req, clientID, readVersion(msg), readSelection(msg), readActive(msg)));
+            return;
+        case 'collabFlush':
+            ctx.collabSessions.flush(req);
+            return;
+        default:
+            console.warn(`[collab] unknown message type: ${msg.type}`);
+    }
+}
+function handleJoin(ctx, req, msg, role) {
+    const clientID = typeof msg.data?.clientID === 'string' ? msg.data.clientID : '';
+    if (!clientID)
+        return;
+    const participant = msg.data?.participant;
+    const join = {
+        clientID,
+        viewerId: req.viewerId,
+        userId: typeof participant?.userId === 'string' ? participant.userId : '',
+        name: typeof participant?.name === 'string' ? participant.name : 'Anonymous',
+        role,
+        canEdit: can(role, 'editFiles'),
+        resume: readResume(msg),
+        active: readActive(msg) ?? true,
+    };
+    ctx.collabSessions.join(req, join);
+}
+function withClientId(msg, run) {
+    const clientID = typeof msg.data?.clientID === 'string' ? msg.data.clientID : '';
+    if (!clientID)
+        return;
+    run(clientID);
+}
+function readVersion(msg) {
+    const version = msg.data?.version;
+    return typeof version === 'number' && Number.isInteger(version) && version >= 0 ? version : -1;
+}
+function readUpdates(msg) {
+    const updates = msg.data?.updates;
+    return Array.isArray(updates) ? updates : [];
+}
+function readSelection(msg) {
+    const selection = msg.data?.selection;
+    if (!selection || typeof selection !== 'object')
+        return null;
+    const { anchor, head } = selection;
+    if (typeof anchor !== 'number' || typeof head !== 'number')
+        return null;
+    return { anchor, head };
+}
+function readActive(msg) {
+    const active = msg.data?.active;
+    return typeof active === 'boolean' ? active : undefined;
+}
+function readResume(msg) {
+    const resume = msg.data?.resume;
+    if (!resume || typeof resume !== 'object')
+        return undefined;
+    const { version, lastSeq } = resume;
+    if (typeof version !== 'number' || !Number.isInteger(version) || version < 0)
+        return undefined;
+    return { version, lastSeq: typeof lastSeq === 'number' ? lastSeq : undefined };
+}
+function sendCollabError(ctx, ws, viewerId, path, operation, code, error) {
+    ctx.send(ws, {
+        type: 'collabError',
+        data: { path, operation, code, error },
+        _target: viewerId,
+    });
+}

package/dist/server/services/websocket/commit-suggestion-service.js

@@ -0,0 +1,132 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { computeStatusKey, GIT_VIEW_TAB_ID, generateSuggestionMessage, resolveSuggestionRepoRoots, snapshotWorktree, } from '../git/index.js';
+export { computeStatusKey, GIT_VIEW_TAB_ID };
+const DEFAULT_SETTLE_MS = 5_000;
+const ACTIVE_EXECUTOR_STATUSES = new Set(['starting', 'executing', 'stopping']);
+export function normalizeDir(dir) {
+    const trimmed = dir.replace(/\/+$/, '');
+    return trimmed === '' ? '/' : trimmed;
+}
+export function isAnyExecutionActive(sessions, executors) {
+    for (const session of sessions) {
+        if (session.isExecuting)
+            return true;
+    }
+    for (const executor of executors) {
+        if (ACTIVE_EXECUTOR_STATUSES.has(executor.getStatus()))
+            return true;
+    }
+    return false;
+}
+export class CommitSuggestionService {
+    deps;
+    dirtyDirs = new Set();
+    inflight = new Set();
+    suggestions = new Map();
+    settleTimer = null;
+    settleMs;
+    constructor(deps) {
+        this.deps = deps;
+        this.settleMs = deps.settleMs ?? DEFAULT_SETTLE_MS;
+    }
+    notifyExecutionSettled(candidateDir) {
+        if (candidateDir)
+            this.dirtyDirs.add(normalizeDir(candidateDir));
+        if (this.dirtyDirs.size === 0)
+            return;
+        this.armSettleTimer();
+    }
+    getSuggestionForStatus(dir, headSha, porcelainStatus) {
+        const cached = this.suggestions.get(normalizeDir(dir));
+        if (!cached)
+            return null;
+        if (cached.statusKey !== computeStatusKey(headSha, porcelainStatus))
+            return null;
+        const { statusKey: _statusKey, ...suggestion } = cached;
+        return suggestion;
+    }
+    invalidate(dir) {
+        this.suggestions.delete(normalizeDir(dir));
+    }
+    dispose() {
+        if (this.settleTimer) {
+            clearTimeout(this.settleTimer);
+            this.settleTimer = null;
+        }
+    }
+    armSettleTimer() {
+        if (this.settleTimer)
+            clearTimeout(this.settleTimer);
+        this.settleTimer = setTimeout(() => {
+            this.settleTimer = null;
+            void this.evaluate();
+        }, this.settleMs);
+        this.settleTimer.unref?.();
+    }
+    async evaluate() {
+        if (this.deps.isSystemActive()) {
+            if (this.dirtyDirs.size > 0)
+                this.armSettleTimer();
+            return;
+        }
+        const batch = [...this.dirtyDirs];
+        for (const dir of batch)
+            this.dirtyDirs.delete(dir);
+        const roots = new Set();
+        const resolutions = await Promise.allSettled(batch.map((dir) => this.deps.resolveRepoDirs(dir)));
+        for (const resolution of resolutions) {
+            if (resolution.status !== 'fulfilled')
+                continue;
+            for (const root of resolution.value)
+                roots.add(normalizeDir(root));
+        }
+        const work = [...roots].filter((root) => {
+            if (this.inflight.has(root)) {
+                this.dirtyDirs.add(root);
+                return false;
+            }
+            return true;
+        });
+        await Promise.allSettled(work.map((dir) => this.generateForDir(dir)));
+        if (this.dirtyDirs.size > 0)
+            this.armSettleTimer();
+    }
+    async generateForDir(dir) {
+        this.inflight.add(dir);
+        try {
+            const snapshot = await this.deps.snapshotWorktree(dir);
+            if (!snapshot)
+                return;
+            if (!snapshot.isDirty) {
+                this.suggestions.delete(dir);
+                return;
+            }
+            if (this.suggestions.get(dir)?.statusKey === snapshot.statusKey)
+                return;
+            const message = await this.deps.generate(dir, snapshot);
+            if (!message)
+                return;
+            if (this.deps.isSystemActive()) {
+                this.dirtyDirs.add(dir);
+                return;
+            }
+            const generatedAt = (this.deps.now ?? Date.now)();
+            this.suggestions.set(dir, { workingDir: dir, branch: snapshot.branch, message, generatedAt, statusKey: snapshot.statusKey });
+            this.deps.broadcast({ workingDir: dir, branch: snapshot.branch, message, generatedAt });
+        }
+        finally {
+            this.inflight.delete(dir);
+        }
+    }
+}
+export function createCommitSuggestionService(opts) {
+    return new CommitSuggestionService({
+        isSystemActive: opts.isSystemActive,
+        broadcast: opts.broadcast,
+        settleMs: opts.settleMs,
+        resolveRepoDirs: resolveSuggestionRepoRoots,
+        snapshotWorktree,
+        generate: generateSuggestionMessage,
+    });
+}