@minionry/minion 0.7.36

package/dist/server/services/websocket/session-registry.js

@@ -0,0 +1,340 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { writeFileAtomic } from '../../utils/file-store.js';
+import { spacePath, spaceRoot } from '../space-layout.js';
+import { normalizeEngineId } from './types.js';
+function carryOverGitBinding(existing) {
+    return {
+        ...(existing?.worktreePath ? { worktreePath: existing.worktreePath, worktreeBranch: existing.worktreeBranch } : {}),
+        ...(existing?.repoPath ? { repoPath: existing.repoPath } : {}),
+        ...(existing?.repoWorktrees?.length ? { repoWorktrees: existing.repoWorktrees } : {}),
+    };
+}
+export class SessionRegistry {
+    registryPath;
+    historyDir;
+    data;
+    constructor(workingDir) {
+        const minionryDir = spaceRoot(workingDir);
+        if (!existsSync(minionryDir)) {
+            mkdirSync(minionryDir, { recursive: true });
+        }
+        this.registryPath = spacePath(workingDir, 'sessionRegistry');
+        this.historyDir = spacePath(workingDir, 'history');
+        this.data = this.load();
+        this.sweepGhostTabs();
+    }
+    load() {
+        try {
+            if (existsSync(this.registryPath)) {
+                const raw = JSON.parse(readFileSync(this.registryPath, 'utf-8'));
+                const needsOrder = Object.values(raw.tabs).some((t) => t.order === undefined);
+                if (needsOrder) {
+                    const sorted = Object.entries(raw.tabs).sort(([, a], [, b]) => (a.createdAt || '').localeCompare(b.createdAt || ''));
+                    sorted.forEach(([, tab], i) => {
+                        if (tab.order === undefined)
+                            tab.order = i;
+                    });
+                }
+                for (const tab of Object.values(raw.tabs)) {
+                    if (tab.hasUnviewedCompletion === undefined)
+                        tab.hasUnviewedCompletion = false;
+                    if (tab.engineOverride) {
+                        tab.engineOverride.engine = normalizeEngineId(tab.engineOverride.engine);
+                    }
+                }
+                return raw;
+            }
+        }
+        catch (error) {
+            console.error('[SessionRegistry] Error loading registry:', error);
+        }
+        return { tabs: {} };
+    }
+    sweepGhostTabs() {
+        const removed = [];
+        for (const [tabId, tab] of Object.entries(this.data.tabs)) {
+            if (tab.hasPersistedHistory !== true)
+                continue;
+            const timestamp = tab.sessionId.replace('improv-', '');
+            const historyPath = join(this.historyDir, `${timestamp}.json`);
+            if (!existsSync(historyPath)) {
+                removed.push(tabId);
+                delete this.data.tabs[tabId];
+            }
+        }
+        if (removed.length > 0) {
+            console.log(`[SessionRegistry] Swept ${removed.length} ghost tab(s) whose history file was missing`);
+            this.save();
+        }
+    }
+    save() {
+        try {
+            writeFileAtomic(this.registryPath, JSON.stringify(this.data, null, 2), { mode: 0o600 });
+        }
+        catch (error) {
+            console.error('[SessionRegistry] Error saving registry:', error);
+        }
+    }
+    getNextOrder() {
+        let max = -1;
+        for (const tab of Object.values(this.data.tabs)) {
+            if (tab.order > max)
+                max = tab.order;
+        }
+        return max + 1;
+    }
+    registerTab(tabId, sessionId, tabName, webManaged, appLink) {
+        const now = new Date().toISOString();
+        const existing = this.data.tabs[tabId];
+        const sessionChanged = existing?.sessionId !== sessionId;
+        const effectiveAppLink = appLink ?? existing?.appLink;
+        this.data.tabs[tabId] = {
+            sessionId,
+            tabName: tabName || `Agent ${this.getNextChatNumber()}`,
+            createdAt: existing?.createdAt || now,
+            lastActivityAt: now,
+            order: existing?.order ?? this.getNextOrder(),
+            hasUnviewedCompletion: existing?.hasUnviewedCompletion ?? false,
+            hasPersistedHistory: sessionChanged ? false : existing?.hasPersistedHistory,
+            ...(!sessionChanged && existing?.historyMissing ? { historyMissing: true } : {}),
+            ...(existing?.promptQueue ? { promptQueue: existing.promptQueue } : {}),
+            ...((webManaged ?? existing?.webManaged) ? { webManaged: true } : {}),
+            ...(effectiveAppLink ? { appLink: { ...effectiveAppLink } } : {}),
+            ...(existing?.engineOverride ? { engineOverride: existing.engineOverride } : {}),
+            ...carryOverGitBinding(existing),
+        };
+        this.save();
+    }
+    getNextChatNumber() {
+        const usedNumbers = new Set();
+        for (const tab of Object.values(this.data.tabs)) {
+            const match = tab.tabName.match(/^Agent (\d+)$/);
+            if (match) {
+                usedNumbers.add(parseInt(match[1], 10));
+            }
+        }
+        let n = 1;
+        while (usedNumbers.has(n))
+            n++;
+        return n;
+    }
+    unregisterTab(tabId) {
+        delete this.data.tabs[tabId];
+        this.save();
+    }
+    getTabSession(tabId) {
+        return this.data.tabs[tabId]?.sessionId;
+    }
+    getTab(tabId) {
+        return this.data.tabs[tabId];
+    }
+    getAllTabs() {
+        return { ...this.data.tabs };
+    }
+    updateTabName(tabId, name) {
+        if (this.data.tabs[tabId]) {
+            this.data.tabs[tabId].tabName = name;
+            this.save();
+        }
+    }
+    touchTab(tabId) {
+        if (this.data.tabs[tabId]) {
+            this.data.tabs[tabId].lastActivityAt = new Date().toISOString();
+            this.save();
+        }
+    }
+    updateTabSession(tabId, sessionId) {
+        if (this.data.tabs[tabId]) {
+            this.data.tabs[tabId].sessionId = sessionId;
+            this.data.tabs[tabId].lastActivityAt = new Date().toISOString();
+            this.data.tabs[tabId].hasPersistedHistory = false;
+            this.save();
+        }
+    }
+    markTabPersisted(tabId) {
+        const tab = this.data.tabs[tabId];
+        if (tab && (!tab.hasPersistedHistory || tab.historyMissing)) {
+            tab.hasPersistedHistory = true;
+            delete tab.historyMissing;
+            this.save();
+        }
+    }
+    markTabHistoryMissing(tabId) {
+        const tab = this.data.tabs[tabId];
+        if (tab && !tab.historyMissing) {
+            tab.historyMissing = true;
+            this.save();
+        }
+    }
+    isTabHistoryMissing(tabId) {
+        const tab = this.data.tabs[tabId];
+        if (!tab?.historyMissing)
+            return false;
+        if (this.hasWrittenHistoryFile(tab.sessionId)) {
+            delete tab.historyMissing;
+            tab.hasPersistedHistory = true;
+            this.save();
+            return false;
+        }
+        return true;
+    }
+    hasWrittenHistoryFile(sessionId) {
+        const timestamp = sessionId.replace('improv-', '');
+        return existsSync(join(this.historyDir, `${timestamp}.json`));
+    }
+    markTabViewed(tabId) {
+        if (this.data.tabs[tabId]) {
+            this.data.tabs[tabId].hasUnviewedCompletion = false;
+            this.save();
+        }
+    }
+    markTabUnviewed(tabId) {
+        if (this.data.tabs[tabId]) {
+            this.data.tabs[tabId].hasUnviewedCompletion = true;
+            this.save();
+        }
+    }
+    updateTabWorktree(tabId, worktreePath, worktreeBranch) {
+        if (this.data.tabs[tabId]) {
+            if (worktreePath) {
+                this.data.tabs[tabId].worktreePath = worktreePath;
+                this.data.tabs[tabId].worktreeBranch = worktreeBranch || undefined;
+            }
+            else {
+                delete this.data.tabs[tabId].worktreePath;
+                delete this.data.tabs[tabId].worktreeBranch;
+            }
+            this.save();
+        }
+    }
+    updateTabRepoPath(tabId, repoPath) {
+        const tab = this.data.tabs[tabId];
+        if (!tab)
+            return;
+        if (repoPath)
+            tab.repoPath = repoPath;
+        else
+            delete tab.repoPath;
+        this.save();
+    }
+    updateTabRepoWorktrees(tabId, repoWorktrees) {
+        const tab = this.data.tabs[tabId];
+        if (!tab)
+            return;
+        if (repoWorktrees.length > 0)
+            tab.repoWorktrees = repoWorktrees;
+        else
+            delete tab.repoWorktrees;
+        this.save();
+    }
+    updateTabEngineOverride(tabId, override) {
+        const tab = this.data.tabs[tabId];
+        if (!tab)
+            return;
+        if (override === null) {
+            delete tab.engineOverride;
+        }
+        else {
+            tab.engineOverride = { ...override };
+        }
+        tab.lastActivityAt = new Date().toISOString();
+        this.save();
+    }
+    reorderTabs(tabOrder) {
+        for (let i = 0; i < tabOrder.length; i++) {
+            const tab = this.data.tabs[tabOrder[i]];
+            if (tab)
+                tab.order = i;
+        }
+        this.save();
+    }
+    getPromptQueue(tabId) {
+        return this.data.tabs[tabId]?.promptQueue ?? [];
+    }
+    enqueuePrompt(tabId, item) {
+        const tab = this.data.tabs[tabId];
+        if (!tab)
+            return;
+        if (!tab.promptQueue)
+            tab.promptQueue = [];
+        tab.promptQueue.push({ ...item });
+        this.save();
+    }
+    removeQueuedPrompt(tabId, index) {
+        const tab = this.data.tabs[tabId];
+        if (!tab?.promptQueue)
+            return;
+        if (index < 0 || index >= tab.promptQueue.length)
+            return;
+        tab.promptQueue.splice(index, 1);
+        if (tab.promptQueue.length === 0)
+            delete tab.promptQueue;
+        this.save();
+    }
+    clearPromptQueue(tabId) {
+        const tab = this.data.tabs[tabId];
+        if (!tab?.promptQueue)
+            return;
+        delete tab.promptQueue;
+        this.save();
+    }
+    shiftPromptQueue(tabId) {
+        const tab = this.data.tabs[tabId];
+        if (!tab?.promptQueue || tab.promptQueue.length === 0)
+            return null;
+        const next = tab.promptQueue.shift() ?? null;
+        if (tab.promptQueue.length === 0)
+            delete tab.promptQueue;
+        this.save();
+        return next;
+    }
+    getBoardQueue(boardId) {
+        return this.data.boardQueues?.[boardId] ?? [];
+    }
+    enqueueBoardPrompt(boardId, item) {
+        if (!this.data.boardQueues)
+            this.data.boardQueues = {};
+        if (!this.data.boardQueues[boardId])
+            this.data.boardQueues[boardId] = [];
+        this.data.boardQueues[boardId].push({ ...item });
+        this.save();
+    }
+    removeBoardQueuedPrompt(boardId, index) {
+        const queue = this.data.boardQueues?.[boardId];
+        if (!queue)
+            return;
+        if (index < 0 || index >= queue.length)
+            return;
+        queue.splice(index, 1);
+        if (queue.length === 0)
+            delete this.data.boardQueues?.[boardId];
+        this.save();
+    }
+    clearBoardQueue(boardId) {
+        if (!this.data.boardQueues?.[boardId])
+            return;
+        delete this.data.boardQueues[boardId];
+        this.save();
+    }
+    shiftBoardQueue(boardId) {
+        const queue = this.data.boardQueues?.[boardId];
+        if (!queue || queue.length === 0)
+            return null;
+        const next = queue.shift();
+        if (queue.length === 0)
+            delete this.data.boardQueues?.[boardId];
+        this.save();
+        return next ?? null;
+    }
+    getAllBoardQueues() {
+        const out = {};
+        for (const [boardId, queue] of Object.entries(this.data.boardQueues ?? {})) {
+            if (queue.length > 0)
+                out[boardId] = queue;
+        }
+        return out;
+    }
+}

package/dist/server/services/websocket/session-role-directory.js

@@ -0,0 +1,39 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { can } from '@minionry/roles';
+export function isViewerStampTrustworthy(messageType) {
+    return messageType.startsWith('browser_') || messageType.startsWith('sdk') || messageType.startsWith('collab');
+}
+export class SessionRoleDirectory {
+    entries = new Map();
+    seq = 0;
+    noteMessage(viewerId, role, ws, opts) {
+        if (!viewerId)
+            return;
+        if (opts.explicitViewerStamp && !isViewerStampTrustworthy(opts.messageType))
+            return;
+        this.seq += 1;
+        this.entries.set(viewerId, { viewerId, role, ws, lastSeenSeq: this.seq });
+    }
+    get(viewerId) {
+        return this.entries.get(viewerId);
+    }
+    dropViewer(viewerId) {
+        this.entries.delete(viewerId);
+    }
+    dropWs(ws) {
+        for (const [viewerId, entry] of this.entries) {
+            if (entry.ws === ws)
+                this.entries.delete(viewerId);
+        }
+    }
+    clear() {
+        this.entries.clear();
+    }
+    listOwnerTierViewerIds() {
+        return [...this.entries.values()]
+            .filter((entry) => can(entry.role, 'editSettings'))
+            .sort((a, b) => b.lastSeenSeq - a.lastSeenSeq)
+            .map((entry) => entry.viewerId);
+    }
+}

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

@@ -0,0 +1,276 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { resolveClaudeCommand } from '../../engines/claude/claude-command.js';
+import { computeClassifierHealth } from '../../mcp/classifier/health.js';
+import { getModelCatalog } from '../model-catalog.js';
+import { clearBouncerClassifierOverride, getCurrentSpaceIdentity, getSettings, setBouncerClassifier, setBouncerClassifierOverride, setEffortLevel, setEngine, setFastMode, setMaxConcurrentSessions, setMaxUploadSizeMb, setModel, setQualityEffortLevel, setQualityEngine, setQualityFastMode, setQualityModel, setSubagentModel, setSubagentModelForce, } from '../settings.js';
+import { spacePath } from '../space-layout.js';
+import { createSystemPrompt, deleteSystemPromptProfile, listSystemPromptProfiles, readSystemPromptFile, saveSystemPromptFile, systemPromptsDir, } from '../system-prompts.js';
+import { isEngineId } from './types.js';
+function buildSystemPromptProfilesMessage() {
+    const promptDir = systemPromptsDir();
+    try {
+        return {
+            type: 'systemPromptProfiles',
+            data: { profiles: listSystemPromptProfiles(), promptDir },
+        };
+    }
+    catch (err) {
+        return {
+            type: 'systemPromptProfiles',
+            data: {
+                profiles: [],
+                promptDir,
+                error: err instanceof Error ? err.message : String(err),
+            },
+        };
+    }
+}
+export function handleGetSystemPromptProfiles(ctx, ws) {
+    ctx.send(ws, buildSystemPromptProfilesMessage());
+}
+export function handleCreateSystemPrompt(ctx, ws, msg) {
+    const result = createSystemPrompt(typeof msg.data?.name === 'string' ? msg.data.name : '', undefined, typeof msg.data?.content === 'string' ? msg.data.content : undefined);
+    ctx.send(ws, { type: 'systemPromptCreated', data: result });
+    if (result.success) {
+        ctx.broadcastToAll(buildSystemPromptProfilesMessage());
+    }
+}
+function requestedPromptFile(msg) {
+    return {
+        profile: typeof msg.data?.profile === 'string' ? msg.data.profile : '',
+        lang: typeof msg.data?.lang === 'string' && msg.data.lang ? msg.data.lang : undefined,
+    };
+}
+export function handleReadSystemPrompt(ctx, ws, msg) {
+    const { profile, lang } = requestedPromptFile(msg);
+    ctx.send(ws, {
+        type: 'systemPromptContent',
+        data: { profile, lang, ...readSystemPromptFile(profile, lang) },
+    });
+}
+export function handleSaveSystemPrompt(ctx, ws, msg) {
+    const { profile, lang } = requestedPromptFile(msg);
+    if (typeof msg.data?.content !== 'string') {
+        ctx.send(ws, {
+            type: 'systemPromptSaved',
+            data: { success: false, profile, lang, error: 'Nothing to save.' },
+        });
+        return;
+    }
+    const result = saveSystemPromptFile(profile, msg.data.content, lang);
+    ctx.send(ws, { type: 'systemPromptSaved', data: { profile, lang, ...result } });
+    if (result.success) {
+        ctx.broadcastToAll(buildSystemPromptProfilesMessage());
+    }
+}
+export function handleDeleteSystemPrompt(ctx, ws, msg) {
+    const { profile } = requestedPromptFile(msg);
+    const result = deleteSystemPromptProfile(profile);
+    ctx.send(ws, { type: 'systemPromptDeleted', data: { profile, ...result } });
+    if (result.success) {
+        ctx.broadcastToAll(buildSystemPromptProfilesMessage());
+    }
+}
+export function buildClassifierHealthMessage() {
+    return {
+        type: 'bouncerClassifierHealth',
+        data: computeClassifierHealth(getCurrentSpaceIdentity().workingDirectory, { limit: 200 }),
+    };
+}
+export function handleGetSettings(ctx, ws) {
+    ctx.send(ws, { type: 'settings', data: getSettings() });
+    try {
+        ctx.send(ws, buildClassifierHealthMessage());
+    }
+    catch (err) {
+        console.error('[Settings] Failed to send classifier health:', err);
+    }
+}
+function applyScalarSettings(data) {
+    if (data?.model !== undefined)
+        setModel(data.model);
+    if (data?.effortLevel !== undefined)
+        setEffortLevel(data.effortLevel);
+    if (typeof data?.fastMode === 'boolean')
+        setFastMode(data.fastMode);
+    if (isEngineId(data?.engine))
+        setEngine(data.engine);
+    if (isEngineId(data?.qualityEngine))
+        setQualityEngine(data.qualityEngine);
+    if (data?.qualityModel !== undefined)
+        setQualityModel(data.qualityModel);
+    if (data?.qualityEffortLevel !== undefined)
+        setQualityEffortLevel(data.qualityEffortLevel);
+    if (typeof data?.qualityFastMode === 'boolean')
+        setQualityFastMode(data.qualityFastMode);
+    if (typeof data?.maxUploadSizeMb === 'number')
+        setMaxUploadSizeMb(data.maxUploadSizeMb);
+    if (typeof data?.subagentModel === 'string')
+        setSubagentModel(data.subagentModel);
+    if (typeof data?.subagentModelForce === 'boolean')
+        setSubagentModelForce(data.subagentModelForce);
+    if (typeof data?.maxConcurrentSessions === 'number')
+        setMaxConcurrentSessions(data.maxConcurrentSessions);
+}
+function applyBouncerClassifierOverride(ctx, ws, data) {
+    try {
+        const { clientId, workingDirectory } = getCurrentSpaceIdentity();
+        if (data.bouncerClassifierOverride === null) {
+            clearBouncerClassifierOverride(clientId, workingDirectory);
+        }
+        else {
+            setBouncerClassifierOverride(clientId, workingDirectory, data.bouncerClassifierOverride);
+        }
+        return false;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        ctx.send(ws, { type: 'error', data: { scope: 'bouncerClassifierOverride', message } });
+        ctx.send(ws, { type: 'settings', data: getSettings() });
+        return true;
+    }
+}
+export function handleUpdateSettings(ctx, ws, msg) {
+    applyScalarSettings(msg.data);
+    if (msg.data?.bouncerClassifier !== undefined) {
+        try {
+            setBouncerClassifier(msg.data.bouncerClassifier);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            ctx.send(ws, {
+                type: 'error',
+                data: {
+                    scope: 'bouncerClassifier',
+                    message,
+                },
+            });
+            ctx.send(ws, { type: 'settings', data: getSettings() });
+            return;
+        }
+    }
+    if (msg.data?.bouncerClassifierOverride !== undefined) {
+        if (applyBouncerClassifierOverride(ctx, ws, msg.data))
+            return;
+    }
+    ctx.broadcastToAll({ type: 'settingsUpdated', data: getSettings() });
+}
+export async function handleGetModelCatalog(ctx, ws, msg) {
+    const result = await getModelCatalog({ refresh: msg.data?.refresh === true });
+    ctx.send(ws, { type: 'modelCatalog', data: result.payload });
+    if (result.didFetch) {
+        ctx.broadcastToAll({ type: 'modelCatalog', data: result.payload });
+    }
+    else if (result.backgroundRefresh) {
+        result.backgroundRefresh
+            .then((payload) => ctx.broadcastToAll({ type: 'modelCatalog', data: payload }))
+            .catch((err) => console.error('[ModelCatalog] Background refresh failed:', err));
+    }
+}
+export async function generateNotificationSummary(ctx, ws, tabId, userPrompt, output, workingDir) {
+    try {
+        const tempDir = spacePath(workingDir, 'tmp');
+        if (!existsSync(tempDir)) {
+            mkdirSync(tempDir, { recursive: true });
+        }
+        let truncatedOutput = output;
+        if (output.length > 4000) {
+            const firstPart = output.slice(0, 2000);
+            const lastPart = output.slice(-1500);
+            truncatedOutput = `${firstPart}\n\n... [output truncated] ...\n\n${lastPart}`;
+        }
+        const summaryPrompt = `You are generating a SHORT browser notification summary for a completed task.
+The user ran a task and wants a brief notification to remind them what happened.
+
+USER'S ORIGINAL PROMPT:
+"${userPrompt}"
+
+TASK OUTPUT (may be truncated):
+${truncatedOutput}
+
+Generate a notification summary following these rules:
+1. Maximum 100 characters (this is a browser notification)
+2. Focus on the OUTCOME, not the process
+3. Be specific about what was accomplished
+4. Use past tense (e.g., "Fixed bug in auth.ts", "Added 3 new tests")
+5. If there was an error, mention it briefly
+6. No emojis, no markdown, just plain text
+
+Respond with ONLY the summary text, nothing else.`;
+        const promptFile = join(tempDir, `notif-summary-${Date.now()}.txt`);
+        writeFileSync(promptFile, summaryPrompt);
+        const systemPrompt = 'You are a notification summary assistant. Respond with only the summary text, no preamble or explanation.';
+        const args = [
+            '--print',
+            '--model', 'haiku',
+            '--system-prompt', systemPrompt,
+            promptFile
+        ];
+        const claude = spawn(resolveClaudeCommand(), args, {
+            cwd: workingDir,
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        let stdout = '';
+        let stderr = '';
+        let responseSent = false;
+        const sendSummaryOnce = (summary) => {
+            if (responseSent)
+                return;
+            responseSent = true;
+            ctx.send(ws, {
+                type: 'notificationSummary',
+                tabId,
+                data: { summary }
+            });
+        };
+        claude.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        claude.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        claude.on('close', (code) => {
+            try {
+                unlinkSync(promptFile);
+            }
+            catch {
+            }
+            if (code === 0 && stdout.trim()) {
+                sendSummaryOnce(stdout.trim().slice(0, 150));
+            }
+            else {
+                console.error('[WebSocketImproviseHandler] Claude error:', stderr || 'Unknown error');
+                sendSummaryOnce(createFallbackSummary(userPrompt));
+            }
+        });
+        claude.on('error', (err) => {
+            console.error('[WebSocketImproviseHandler] Failed to spawn Claude:', err);
+            sendSummaryOnce(createFallbackSummary(userPrompt));
+        });
+        const timeout = setTimeout(() => {
+            claude.kill();
+            sendSummaryOnce(createFallbackSummary(userPrompt));
+        }, 10000);
+        claude.on('close', () => { clearTimeout(timeout); });
+    }
+    catch (error) {
+        console.error('[WebSocketImproviseHandler] Error generating summary:', error);
+        const summary = createFallbackSummary(userPrompt);
+        ctx.send(ws, {
+            type: 'notificationSummary',
+            tabId,
+            data: { summary }
+        });
+    }
+}
+function createFallbackSummary(userPrompt) {
+    const truncated = userPrompt.slice(0, 60);
+    if (userPrompt.length > 60) {
+        return `Completed: "${truncated}..."`;
+    }
+    return `Completed: "${truncated}"`;
+}