@minionry/minion 0.7.36

package/dist/server/services/websocket/autocomplete.js

@@ -0,0 +1,407 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { readdirSync, realpathSync, statSync } from 'node:fs';
+import { isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { compareNatural, createDefaultIndexCache, normalizeDisplayDir, } from './autocomplete-index.js';
+import { fuzzyMatch, isSmartCaseSensitive, positionsToRanges } from './autocomplete-match.js';
+import { getFileType } from './file-utils.js';
+export const RESULT_LIMIT = 20;
+const RECENT_LIMIT = 6;
+const FRECENCY_MAX_ENTRIES = 1000;
+const FRECENCY_LIFT = 0.5;
+const RELATIVE_SCORE_CUTOFF = 0.35;
+const MIN_RESULTS_BEFORE_CUTOFF = 3;
+const TIER_EXACT_NAME = 40;
+const TIER_NAME_PREFIX = 24;
+const TIER_NAME_SUBSTRING = 12;
+export function normalizeCompletionQuery(partialPath) {
+    let query = partialPath.startsWith('@') ? partialPath.slice(1) : partialPath;
+    query = query.replace(/\\/g, '/').replace(/\/{2,}/g, '/');
+    while (query.startsWith('./'))
+        query = query.slice(2);
+    return query;
+}
+export function parseCompletionQuery(query, isDirectory) {
+    if (query === '')
+        return { mode: 'root' };
+    if (query.endsWith('/')) {
+        const dir = query.slice(0, -1);
+        return { mode: 'browse', dir: dir === '' ? '/' : dir };
+    }
+    if (query === '..' || query.endsWith('/..'))
+        return { mode: 'browse', dir: query };
+    const slash = query.lastIndexOf('/');
+    if (slash === -1)
+        return { mode: 'search', term: query };
+    const dir = slash === 0 ? '/' : query.slice(0, slash);
+    const term = query.slice(slash + 1);
+    if (isDirectory(dir))
+        return { mode: 'scoped', dir, term };
+    return { mode: 'search', term: query };
+}
+function isDirectoryOnDisk(abs) {
+    try {
+        return statSync(abs).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function realpathOrNull(abs) {
+    try {
+        return realpathSync(abs);
+    }
+    catch {
+        return null;
+    }
+}
+function isContainedCanonically(abs, root) {
+    const realRoot = realpathOrNull(root);
+    const realAbs = realpathOrNull(abs);
+    if (realRoot === null || realAbs === null)
+        return false;
+    return realAbs === realRoot || realAbs.startsWith(realRoot + sep);
+}
+function tailOf(term) {
+    const slash = term.lastIndexOf('/');
+    return slash === -1 ? term : term.slice(slash + 1);
+}
+function stemOf(name) {
+    const dot = name.lastIndexOf('.');
+    return dot > 0 ? name.slice(0, dot) : name;
+}
+function compareListing(a, b) {
+    if (a.candidate.isDirectory !== b.candidate.isDirectory)
+        return a.candidate.isDirectory ? -1 : 1;
+    const aRecent = a.frecency > 0;
+    const bRecent = b.frecency > 0;
+    if (aRecent !== bRecent)
+        return aRecent ? -1 : 1;
+    if (aRecent && a.frecency !== b.frecency)
+        return b.frecency - a.frecency;
+    if (a.candidate.hidden !== b.candidate.hidden)
+        return a.candidate.hidden ? 1 : -1;
+    return compareNatural(a.candidate.name, b.candidate.name);
+}
+function compareRanked(a, b) {
+    if (a.rank !== b.rank)
+        return b.rank - a.rank;
+    if (a.candidate.isDirectory !== b.candidate.isDirectory)
+        return a.candidate.isDirectory ? 1 : -1;
+    if (a.candidate.depth !== b.candidate.depth)
+        return a.candidate.depth - b.candidate.depth;
+    if (a.candidate.path.length !== b.candidate.path.length)
+        return a.candidate.path.length - b.candidate.path.length;
+    return a.candidate.path < b.candidate.path ? -1 : a.candidate.path > b.candidate.path ? 1 : 0;
+}
+function insertTopK(top, item, k) {
+    if (top.length === k && compareRanked(item, top[k - 1]) >= 0)
+        return;
+    let lo = 0;
+    let hi = top.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >>> 1;
+        if (compareRanked(top[mid], item) <= 0)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    top.splice(lo, 0, item);
+    if (top.length > k)
+        top.pop();
+}
+export class AutocompleteService {
+    frecencyData;
+    indexCache;
+    constructor(initialFrecencyData = {}, deps = {}) {
+        this.frecencyData = initialFrecencyData;
+        this.indexCache = deps.indexCache ?? createDefaultIndexCache();
+    }
+    setFrecencyData(data) {
+        this.frecencyData = data;
+    }
+    getFrecencyData() {
+        return this.frecencyData;
+    }
+    recordFileSelection(key) {
+        const existing = this.frecencyData[key];
+        if (existing) {
+            existing.count++;
+            existing.lastUsed = Date.now();
+        }
+        else {
+            this.frecencyData[key] = { count: 1, lastUsed: Date.now() };
+        }
+        this.pruneFrecency();
+    }
+    calculateFrecencyScore(key) {
+        const entry = this.frecencyData[key];
+        if (!entry)
+            return 0;
+        const hoursSinceLastUse = (Date.now() - entry.lastUsed) / (1000 * 60 * 60);
+        const recencyWeight = Math.max(0, 1 - hoursSinceLastUse / (24 * 7));
+        const frequencyWeight = Math.log2(entry.count + 1);
+        return frequencyWeight * (0.3 + 0.7 * recencyWeight) * 100;
+    }
+    invalidateIndex(workingDir) {
+        this.indexCache.invalidate(workingDir === undefined ? undefined : resolve(workingDir));
+    }
+    pruneFrecency() {
+        const keys = Object.keys(this.frecencyData);
+        if (keys.length <= FRECENCY_MAX_ENTRIES)
+            return;
+        const scored = keys.map((key) => ({ key, score: this.calculateFrecencyScore(key) }));
+        scored.sort((a, b) => a.score - b.score);
+        const dropCount = keys.length - Math.floor(FRECENCY_MAX_ENTRIES * 0.9);
+        for (const { key } of scored.slice(0, dropCount))
+            delete this.frecencyData[key];
+    }
+    frecencyByRelativePath(root) {
+        const byRel = new Map();
+        const prefix = root + sep;
+        for (const key of Object.keys(this.frecencyData)) {
+            let rel;
+            if (key.startsWith(prefix))
+                rel = relative(root, key).split(sep).join('/');
+            else if (isAbsolute(key))
+                continue;
+            else
+                rel = key.replace(/\\/g, '/');
+            rel = rel.replace(/\/+$/, '');
+            if (rel === '')
+                continue;
+            const score = this.calculateFrecencyScore(key);
+            if (score <= 0)
+                continue;
+            const current = byRel.get(rel);
+            if (current === undefined || current < score)
+                byRel.set(rel, score);
+        }
+        return byRel;
+    }
+    frecencyOf(lookup, candidate) {
+        if (candidate.abs !== undefined)
+            return this.calculateFrecencyScore(candidate.abs);
+        return lookup.get(candidate.path) ?? 0;
+    }
+    async complete(partialPath, workingDir, options = {}) {
+        const query = normalizeCompletionQuery(partialPath);
+        const limit = options.limit ?? RESULT_LIMIT;
+        const sandboxed = options.sandboxed === true;
+        try {
+            const root = resolve(workingDir);
+            const index = await this.indexCache.get(root);
+            const frecency = this.frecencyByRelativePath(root);
+            const parsed = parseCompletionQuery(query, (dir) => this.resolveDirTarget(dir, root, index, sandboxed) !== null);
+            const base = { query, indexTruncated: index.meta.truncated };
+            switch (parsed.mode) {
+                case 'root':
+                    return { ...base, mode: 'root', ...this.completeRoot(index, frecency, limit) };
+                case 'browse': {
+                    const target = this.resolveDirTarget(parsed.dir, root, index, sandboxed);
+                    const dir = this.displayDir(parsed.dir, target);
+                    if (!target)
+                        return { ...base, mode: 'browse', dir, completions: [], totalMatches: 0, truncated: false };
+                    return { ...base, mode: 'browse', dir, ...this.completeBrowse(index, frecency, target, limit) };
+                }
+                case 'scoped': {
+                    const target = this.resolveDirTarget(parsed.dir, root, index, sandboxed);
+                    const dir = this.displayDir(parsed.dir, target);
+                    if (!target)
+                        return { ...base, mode: 'scoped', dir, completions: [], totalMatches: 0, truncated: false };
+                    return { ...base, mode: 'scoped', dir, ...this.completeScoped(index, frecency, target, parsed.term, limit) };
+                }
+                default:
+                    return { ...base, mode: 'search', ...this.completeSearch(index, frecency, parsed.term, limit) };
+            }
+        }
+        catch (error) {
+            console.error('[AutocompleteService] Error getting file completions:', error);
+            return { completions: [], query, mode: 'search', totalMatches: 0, truncated: false, indexTruncated: false };
+        }
+    }
+    displayDir(dir, target) {
+        if (target?.kind === 'index')
+            return target.rel === '' ? '' : `${target.rel}/`;
+        if (target?.kind === 'disk')
+            return target.display === '/' ? '/' : `${target.display}/`;
+        const normalized = normalizeDisplayDir(dir);
+        return normalized === '' || normalized === '/' ? normalized : `${normalized}/`;
+    }
+    resolveDirTarget(dir, root, index, sandboxed) {
+        const abs = resolve(root, dir);
+        const inRoot = abs === root || abs.startsWith(root + sep);
+        if (!inRoot) {
+            if (sandboxed)
+                return null;
+            return isDirectoryOnDisk(abs) ? { kind: 'disk', abs, display: normalizeDisplayDir(dir) || '/' } : null;
+        }
+        const rel = abs === root ? '' : relative(root, abs).split(sep).join('/');
+        if (rel === '')
+            return { kind: 'index', rel: '' };
+        const entry = index.get(rel);
+        if (entry?.isDirectory)
+            return { kind: 'index', rel };
+        if (!isDirectoryOnDisk(abs))
+            return null;
+        if (sandboxed && !isContainedCanonically(abs, root))
+            return null;
+        return { kind: 'disk', abs, display: rel };
+    }
+    completeRoot(index, frecency, limit) {
+        const recents = this.recentCandidates(index, frecency, RECENT_LIMIT);
+        const recentPaths = new Set(recents.map((r) => r.candidate.path));
+        const children = index
+            .childrenOf('')
+            .filter((entry) => !recentPaths.has(entry.path))
+            .map((entry) => ({ candidate: entry, frecency: this.frecencyOf(frecency, entry) }))
+            .sort(compareListing);
+        const completions = [
+            ...recents.map((r) => this.toResult(r.candidate, [], true)),
+            ...children.map((c) => this.toResult(c.candidate, [], false)),
+        ];
+        const total = recents.length + children.length;
+        return { completions: completions.slice(0, limit), totalMatches: total, truncated: total > limit };
+    }
+    completeBrowse(index, frecency, target, limit) {
+        const children = this.candidatesIn(index, target, 'children')
+            .map((candidate) => ({ candidate, frecency: this.frecencyOf(frecency, candidate) }))
+            .sort(compareListing);
+        return {
+            completions: children.slice(0, limit).map((r) => this.toResult(r.candidate, [], r.frecency > 0)),
+            totalMatches: children.length,
+            truncated: children.length > limit,
+        };
+    }
+    completeScoped(index, frecency, target, term, limit) {
+        const candidates = this.candidatesIn(index, target, 'descendants');
+        const prefixLength = this.displayDir(target.kind === 'index' ? target.rel : target.display, target).length;
+        const matches = this.matchCandidates(candidates, term, prefixLength);
+        return this.rankToResponse(frecency, matches, limit);
+    }
+    completeSearch(index, frecency, term, limit) {
+        const matches = this.matchCandidates(index.entries, term, 0);
+        return this.rankToResponse(frecency, matches, limit);
+    }
+    candidatesIn(index, target, scope) {
+        if (target.kind === 'index') {
+            return scope === 'children' ? index.childrenOf(target.rel) : index.descendantsOf(target.rel);
+        }
+        let dirents;
+        try {
+            dirents = readdirSync(target.abs, { withFileTypes: true });
+        }
+        catch {
+            return [];
+        }
+        const prefix = target.display === '/' ? '/' : `${target.display}/`;
+        const baseDepth = target.display.split('/').filter((s) => s !== '' && s !== '.').length;
+        const out = [];
+        for (const dirent of dirents) {
+            if (dirent.name === '.git')
+                continue;
+            const path = prefix + dirent.name;
+            out.push({
+                path,
+                lower: path.toLowerCase(),
+                name: dirent.name,
+                nameLower: dirent.name.toLowerCase(),
+                isDirectory: dirent.isDirectory(),
+                depth: baseDepth + 1,
+                hidden: dirent.name.startsWith('.'),
+                abs: join(target.abs, dirent.name),
+            });
+        }
+        return out;
+    }
+    recentCandidates(index, frecency, limit) {
+        const recents = [];
+        for (const [rel, score] of frecency) {
+            const entry = index.get(rel);
+            if (entry)
+                recents.push({ candidate: entry, frecency: score });
+        }
+        return recents.sort((a, b) => b.frecency - a.frecency).slice(0, limit);
+    }
+    matchCandidates(candidates, term, offset) {
+        const caseSensitive = isSmartCaseSensitive(term);
+        const pattern = caseSensitive ? term : term.toLowerCase();
+        const tail = tailOf(term).toLowerCase();
+        const matches = [];
+        for (const candidate of candidates) {
+            const text = offset > 0 ? candidate.path.slice(offset) : candidate.path;
+            const cmp = caseSensitive ? text : offset > 0 ? candidate.lower.slice(offset) : candidate.lower;
+            const match = fuzzyMatch(text, cmp, pattern);
+            if (!match)
+                continue;
+            let score = match.score;
+            if (tail) {
+                const name = candidate.nameLower;
+                if (name === tail || stemOf(name) === tail)
+                    score += TIER_EXACT_NAME;
+                else if (name.startsWith(tail))
+                    score += TIER_NAME_PREFIX;
+                else if (name.includes(tail))
+                    score += TIER_NAME_SUBSTRING;
+            }
+            matches.push({ candidate, score, positions: match.positions, offset });
+        }
+        return matches;
+    }
+    rankToResponse(frecency, matches, limit) {
+        const { top, total } = this.rank(frecency, matches, limit);
+        return {
+            completions: top.map((r) => this.toResult(r.candidate, positionsToRanges(r.positions.map((p) => p + r.offset)), r.frecency > 0)),
+            totalMatches: total,
+            truncated: total > top.length,
+        };
+    }
+    rank(frecency, matches, limit) {
+        if (matches.length === 0)
+            return { top: [], total: 0 };
+        let best = 0;
+        for (const m of matches)
+            if (m.score > best)
+                best = m.score;
+        if (best <= 0)
+            best = 1;
+        let maxFrecency = 0;
+        const frecencies = new Float64Array(matches.length);
+        for (let i = 0; i < matches.length; i++) {
+            const f = this.frecencyOf(frecency, matches[i].candidate);
+            frecencies[i] = f;
+            if (f > maxFrecency)
+                maxFrecency = f;
+        }
+        const logMax = Math.log1p(maxFrecency);
+        const k = limit + MIN_RESULTS_BEFORE_CUTOFF;
+        const top = [];
+        let aboveCutoff = 0;
+        for (let i = 0; i < matches.length; i++) {
+            const m = matches[i];
+            const f = frecencies[i];
+            const relativeScore = m.score / best;
+            if (relativeScore >= RELATIVE_SCORE_CUTOFF)
+                aboveCutoff++;
+            const frecencyNorm = f > 0 && logMax > 0 ? Math.log1p(f) / logMax : 0;
+            insertTopK(top, { ...m, frecency: f, relative: relativeScore, rank: relativeScore * (1 + FRECENCY_LIFT * frecencyNorm) }, k);
+        }
+        const kept = top.filter((r, i) => r.relative >= RELATIVE_SCORE_CUTOFF || i < MIN_RESULTS_BEFORE_CUTOFF);
+        let belowCutoffKept = 0;
+        for (const r of kept)
+            if (r.relative < RELATIVE_SCORE_CUTOFF)
+                belowCutoffKept++;
+        return { top: kept.slice(0, limit), total: aboveCutoff + belowCutoffKept };
+    }
+    toResult(candidate, matchedIndices, isRecent) {
+        const display = candidate.isDirectory ? `${candidate.path}/` : candidate.path;
+        return {
+            value: display,
+            label: display,
+            isDirectory: candidate.isDirectory,
+            isRecent,
+            fileType: candidate.isDirectory ? 'directory' : getFileType(candidate.path),
+            matchedIndices,
+        };
+    }
+}

package/dist/server/services/websocket/browser-agent-runtime.js

@@ -0,0 +1,208 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { randomUUID } from 'node:crypto';
+import { createClaudePlanner, createClaudeReasoner } from '../browser/claude-reasoner.js';
+import { browserLog } from '../browser/debug-log.js';
+import { defaultAgentActionReviewer, defaultAgentReasoner, ReasoningAgent, withNavigationFastPath, } from '../browser/reasoning-agent.js';
+import { captureException } from '../sentry.js';
+import { addressToViewer } from './browser-viewer-registry.js';
+const log = browserLog('handlers');
+const activeAgents = new Set();
+const activeRunTargets = new Map();
+export function activeBrowserAgentTarget(agentId) {
+    return activeRunTargets.get(agentId);
+}
+function buildExecutorReasoner(target) {
+    return withNavigationFastPath(createClaudeReasoner({
+        ...(target.model ? { model: target.model } : {}),
+        ...(target.engine ? { engine: target.engine } : {}),
+        ...(target.effortLevel ? { effortLevel: target.effortLevel } : {}),
+        fallback: defaultAgentReasoner,
+        debug: process.env.MINIONRY_BROWSER_DEBUG === '1',
+    }));
+}
+function reasoningTargetOf(task) {
+    return {
+        ...(task.model && task.model !== 'default' ? { model: task.model } : {}),
+        ...(task.engine ? { engine: task.engine } : {}),
+        ...(task.effortLevel ? { effortLevel: task.effortLevel } : {}),
+    };
+}
+function reasoningTargetKey(target) {
+    return `${target.engine ?? 'claude-code'}:${target.model ?? '__default__'}:${target.effortLevel ?? 'auto'}`;
+}
+const executorByModel = new Map();
+let agentReasonerOverride = null;
+function reasonerForTask(target) {
+    if (agentReasonerOverride)
+        return agentReasonerOverride;
+    const key = reasoningTargetKey(target);
+    let reasoner = executorByModel.get(key);
+    if (!reasoner) {
+        reasoner = buildExecutorReasoner(target);
+        executorByModel.set(key, reasoner);
+    }
+    return reasoner;
+}
+function buildPlanner(target) {
+    return createClaudePlanner({
+        ...(target.model ? { model: target.model } : {}),
+        ...(target.engine ? { engine: target.engine } : {}),
+        ...(target.effortLevel ? { effortLevel: target.effortLevel } : {}),
+        fallback: (input) => [input.task],
+    });
+}
+const plannerByModel = new Map();
+let agentPlannerOverride = null;
+function plannerForTask(target) {
+    if (agentPlannerOverride)
+        return agentPlannerOverride;
+    const key = reasoningTargetKey(target);
+    let planner = plannerByModel.get(key);
+    if (!planner) {
+        planner = buildPlanner(target);
+        plannerByModel.set(key, planner);
+    }
+    return planner;
+}
+let agentReviewer = defaultAgentActionReviewer;
+let agentSettleDelayMsOverride = null;
+export { defaultAgentReasoner, REASONING_UNAVAILABLE_RESULT } from '../browser/reasoning-agent.js';
+export function _setBrowserAgentReasonerForTests(reasoner) {
+    agentReasonerOverride = reasoner;
+}
+export function _setBrowserAgentPlannerForTests(planner) {
+    agentPlannerOverride = planner;
+}
+export function _setBrowserAgentReviewerForTests(reviewer) {
+    agentReviewer = reviewer;
+}
+export function _setBrowserAgentSettleDelayForTests(ms) {
+    agentSettleDelayMsOverride = ms;
+}
+export function _resetBrowserAgentsForTests() {
+    for (const agent of activeAgents)
+        agent.cancel();
+    activeAgents.clear();
+    activeRunTargets.clear();
+    agentReasonerOverride = defaultAgentReasoner;
+    agentReviewer = defaultAgentActionReviewer;
+    agentSettleDelayMsOverride = 0;
+    executorByModel.clear();
+    agentPlannerOverride = (input) => [input.task];
+    plannerByModel.clear();
+}
+export function startBrowserAgentRun(host, task, sink) {
+    const agentId = `browser-agent-${randomUUID()}`;
+    const agentLabel = 'Browser Agent';
+    log.info('agent.start', `agent=${agentId.slice(14, 22)} taskId=${task.taskId?.slice(0, 8) ?? '-'} tab=${task.tabId?.slice(0, 8) ?? 'new'} engine=${task.engine ?? 'default'} model=${task.model ?? 'default'} effort=${task.effortLevel ?? 'auto'} active=${activeAgents.size}`);
+    log('agent.task', `agent=${agentId.slice(14, 22)} task="${task.task}"`);
+    const target = reasoningTargetOf(task);
+    const agent = new ReasoningAgent({
+        host,
+        reasoner: reasonerForTask(target),
+        planner: plannerForTask(target),
+        reviewer: agentReviewer,
+        task,
+        agentId,
+        agentLabel,
+        ...(task.tabId ? { tabId: task.tabId } : {}),
+        ...(agentSettleDelayMsOverride !== null
+            ? { settleDelayMs: agentSettleDelayMsOverride }
+            : {}),
+        sink: {
+            emit: (response) => sink.emit(response),
+            badgeTab: () => 
+            broadcastAgentTabState(host, sink, agentId, agentLabel, {
+                ...(task.engine ? { engine: task.engine } : {}),
+                ...(task.model ? { model: task.model } : {}),
+            }),
+        },
+    });
+    activeAgents.add(agent);
+    activeRunTargets.set(agentId, {
+        label: agentLabel,
+        ...(task.engine ? { engine: task.engine } : {}),
+        ...(task.model ? { model: task.model } : {}),
+    });
+    const startedAt = Date.now();
+    const finished = agent
+        .run()
+        .catch((err) => {
+        log.error('agent.run.threw', `agent=${agentId.slice(14, 22)} ${err instanceof Error ? err.message : String(err)}`);
+        captureException(err, { context: 'websocket.browser.agent.run' });
+    })
+        .finally(() => {
+        activeAgents.delete(agent);
+        activeRunTargets.delete(agentId);
+        log.info('agent.finished', `agent=${agentId.slice(14, 22)} elapsedMs=${Date.now() - startedAt} active=${activeAgents.size}`);
+    });
+    return { agentId, cancel: () => agent.cancel(), finished };
+}
+export function startReasoningAgent(host, sink, ws, task, viewerId) {
+    startBrowserAgentRun(host, task, {
+        emit: (response) => {
+            log('agent.emit', `type=${response.type} taskId=${task.taskId?.slice(0, 8) ?? '-'}`);
+            sink.send(ws, addressToViewer(response, ws, viewerId));
+        },
+        broadcastToAll: (response) => sink.broadcastToAll(response),
+    });
+}
+export function resolveProposal(payload) {
+    for (const agent of activeAgents) {
+        if (agent.approve(payload)) {
+            log.info('agent.approve', `proposal=${payload.proposalId.slice(0, 8)} verdict=${payload.verdict}`);
+            return true;
+        }
+    }
+    log.info('agent.approve.unmatched', `proposal=${payload.proposalId.slice(0, 8)} verdict=${payload.verdict} activeAgents=${activeAgents.size}`);
+    return false;
+}
+const LEASE_PARKED_WINDOW_MS = 5_000;
+export function computeLeaseState(now, leasedUntil) {
+    const remaining = leasedUntil - now;
+    if (remaining <= 0)
+        return 'released';
+    if (remaining <= LEASE_PARKED_WINDOW_MS)
+        return 'parked';
+    return 'active';
+}
+export async function broadcastAgentTabState(host, sink, agentId, agentLabel, target = {}) {
+    let leases;
+    try {
+        leases = await host.listLeases({ agentId });
+    }
+    catch (err) {
+        log.error('agentTabState.listLeasesFailed', `agent=${agentId.slice(0, 22)} ${err instanceof Error ? err.message : String(err)}`);
+        captureException(err, { context: 'websocket.browser.broadcastAgentTabState' });
+        return;
+    }
+    const tabs = leases.map((lease) => {
+        const info = host.getTabInfo(lease.tabId);
+        const entry = {
+            tabId: lease.tabId,
+            url: info?.url ?? '',
+            title: info?.title ?? '',
+            leasedUntil: lease.leasedUntil,
+            state: computeLeaseState(Date.now(), lease.leasedUntil),
+        };
+        if (info?.faviconUrl !== undefined)
+            entry.faviconUrl = info.faviconUrl;
+        if (lease.planId !== undefined)
+            entry.planId = lease.planId;
+        return entry;
+    });
+    const payload = {
+        agentId,
+        agentLabel,
+        tabs,
+        ...(target.engine ? { engine: target.engine } : {}),
+        ...(target.model ? { model: target.model } : {}),
+        ...(target.sessionId ? { sessionId: target.sessionId } : {}),
+    };
+    log('agentTabState.broadcast', `agent=${agentId.slice(0, 22)} tabs=${tabs.map((t) => `${t.tabId.slice(0, 8)}:${t.state}`).join(',') || '-'}`);
+    sink.broadcastToAll({
+        type: 'agent_tab_state',
+        data: payload,
+    });
+}

package/dist/server/services/websocket/browser-device-profile.js

@@ -0,0 +1,46 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { deviceProfileFor } from '@minionry/browser-types';
+import { viewers } from './browser-viewer-registry.js';
+let lastDriverFormFactor = 'desktop';
+export function resetDriverFormFactor() {
+    lastDriverFormFactor = 'desktop';
+}
+export function defaultFormFactor() {
+    return lastDriverFormFactor;
+}
+export function recordDriverFormFactor(viewerId, formFactor) {
+    lastDriverFormFactor = formFactor;
+    const viewer = viewers.getByViewer(viewerId);
+    if (viewer)
+        viewer.formFactor = formFactor;
+}
+export function navigatingFormFactor(viewerId) {
+    return viewers.getByViewer(viewerId)?.formFactor ?? lastDriverFormFactor;
+}
+export async function ensureTabProfileCaptured(host, tabId, formFactor) {
+    if (!tabId)
+        return formFactor;
+    const existing = host.getTabInfo(tabId)?.deviceProfile;
+    if (existing)
+        return existing.formFactor;
+    if (formFactor === 'mobile') {
+        await host.setTabDeviceProfile(tabId, deviceProfileFor('mobile'));
+    }
+    return formFactor;
+}
+export function reconcileDeviceParam(url, formFactor) {
+    try {
+        const parsed = new URL(url);
+        if (!parsed.searchParams.has('device'))
+            return url;
+        parsed.searchParams.set('device', formFactor);
+        return parsed.toString();
+    }
+    catch {
+        return url;
+    }
+}
+export function isCapturableUrl(url) {
+    return url.length > 0 && url !== 'about:blank';
+}