@minionry/sdk 0.4.23

package/dist/transports/mock.js

@@ -0,0 +1,4286 @@
+import { createProvider } from '../provider.js';
+import { AGENT_RUN_LIMITS, AGENT_RUN_MODEL_SELECTIONS, MinionryError, SCOPES } from '../types.js';
+import { base64ToBytes, bytesToBase64 } from '../base64.js';
+const DEFAULT_SPACE = { id: 'space-mock', name: 'Mock Space' };
+const DEFAULT_USER = { id: 'user-mock', name: 'Mock User', role: 'owner' };
+const DEFAULT_THEME = {
+    mode: 'light',
+    tokens: {
+        background: '#faf9f5',
+        surface: '#f0efe8',
+        foreground: '#141413',
+        foregroundMuted: '#6b6a68',
+        accent: '#ae5630',
+        border: 'rgba(20, 20, 19, 0.1)',
+    },
+};
+const DEFAULT_LOCALE = {
+    locale: 'en',
+    dir: 'ltr',
+};
+const MOCK_FEATURES = [
+    'agents',
+    'apps',
+    'pm',
+    'files',
+    'storage',
+    'notifications',
+    'mock',
+    'role',
+    'streamResume',
+    'theme',
+    'browser',
+    'agentsRichStream',
+    'composer',
+    'browserAutomate',
+    'browserView',
+    'git',
+    'terminal',
+    'appTools',
+    'quality',
+    'locale',
+    'browserOps',
+    'inference',
+    'appEndpoints',
+    'agentsAppEndpoint',
+    'qualityFindingState',
+    'agentsModelSelection',
+    'qualitySchedules',
+];
+const DEFAULT_BROWSER_TABS = [
+    {
+        id: 'tab-mock-1',
+        url: 'https://minionry.com/',
+        title: 'Minionry',
+        isLoading: false,
+        canGoBack: false,
+        canGoForward: false,
+    },
+];
+const MOCK_SCREENSHOT_PNG = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==';
+const MOCK_SKILLS = [
+    { name: 'code-review', displayName: '/code-review', description: 'Comprehensive code review of the current changes.', source: 'platform' },
+    { name: 'board', displayName: '/board', description: 'Convert the current chat conversation into a PM board with issues.', source: 'platform' },
+];
+const MOCK_SNIPPETS = [
+    { name: 'standup', aliases: ['su'], description: 'Daily standup update template', origin: 'personal', preview: 'Yesterday: … Today: … Blockers: …', bodyLength: 42 },
+];
+const MOCK_INPUT_BATCH_MAX = 64;
+const BOARD_STATUSES = ['todo', 'in_progress', 'done'];
+const MOCK_ISSUE_CREATED = '2026-01-01';
+const MOCK_ID_PREFIXES = {
+    issue: 'IS',
+    epic: 'EP',
+    bug: 'BG',
+    task: 'TASK',
+};
+const WORKSPACE_PATH_PREFIX = 'workspace:';
+const resolveFilesReadScope = (path) => path.startsWith(WORKSPACE_PATH_PREFIX) ? 'files:workspace:read' : 'files:app';
+const resolveFilesWriteScope = (path) => path.startsWith(WORKSPACE_PATH_PREFIX) ? 'files:workspace:write' : 'files:app';
+const FILES_READ_PATH_METHODS = new Set([
+    'files.read',
+    'files.readEntry',
+    'files.list',
+    'files.search',
+    'files.definition',
+    'files.subscribeChanges',
+    'files.downloadStart',
+]);
+const FILES_WRITE_PATH_METHODS = new Set([
+    'files.write',
+    'files.delete',
+    'files.mkdir',
+    'files.rename',
+    'files.uploadStart',
+]);
+const METHOD_SCOPES = {
+    features: null,
+    connect: null,
+    disconnect: null,
+    'auth.getToken': 'identity',
+    'agents.run': 'agents:run',
+    'agents.result': 'agents:run',
+    'agents.sessions.list': 'agents:sessions',
+    'agents.sessions.create': 'agents:sessions',
+    'agents.sessions.attach': 'agents:sessions',
+    'agents.sessions.close': 'agents:sessions',
+    'agents.sessions.rename': 'agents:sessions',
+    'agents.sessions.history': 'agents:sessions',
+    'agents.sessions.replay': 'agents:sessions',
+    'agents.sessions.approve': 'agents:sessions',
+    'agents.sessions.answerQuestion': 'agents:sessions',
+    'agents.sessions.prompt': 'agents:sessions',
+    'agents.sessions.stop': 'agents:sessions',
+    'apps.open': null,
+    cancel: null,
+    'pm.createBoard': 'pm:write',
+    'pm.getBoard': 'pm:read',
+    'pm.listBoards': 'pm:read',
+    'pm.createIssue': 'pm:write',
+    'pm.updateIssue': 'pm:write',
+    'pm.deleteIssue': 'pm:write',
+    'pm.updateBoard': 'pm:write',
+    'pm.subscribeBoard': 'pm:read',
+    'stream.resume': null,
+    'pm.execute': 'pm:execute',
+    'pm.pause': null,
+    'pm.resume': null,
+    'pm.stop': null,
+    'pm.schedules.list': 'pm:schedule',
+    'pm.schedules.create': 'pm:schedule',
+    'pm.schedules.update': 'pm:schedule',
+    'pm.schedules.delete': 'pm:schedule',
+    'files.read': 'files:app',
+    'files.readEntry': 'files:app',
+    'files.write': 'files:app',
+    'files.list': 'files:app',
+    'files.delete': 'files:app',
+    'files.mkdir': 'files:app',
+    'files.rename': 'files:app',
+    'files.search': 'files:app',
+    'files.definition': 'files:app',
+    'files.subscribeChanges': 'files:app',
+    'files.uploadStart': 'files:app',
+    'files.uploadChunk': 'files:app',
+    'files.uploadStatus': 'files:app',
+    'files.uploadCancel': 'files:app',
+    'files.downloadStart': 'files:app',
+    'files.downloadChunk': 'files:app',
+    'files.downloadCancel': 'files:app',
+    'storage.get': 'storage',
+    'storage.set': 'storage',
+    'storage.delete': 'storage',
+    'storage.keys': 'storage',
+    'notifications.request': 'notifications',
+    'notifications.status': 'notifications',
+    'notifications.revoke': 'notifications',
+    'theme.get': null,
+    'locale.get': null,
+    'browser.tabs.list': 'browser:read',
+    'browser.tabs.subscribe': 'browser:read',
+    'browser.navigate': 'browser:control',
+    'browser.open': 'browser:control',
+    'browser.close': 'browser:control',
+    'browser.select': 'browser:control',
+    'browser.snapshot': 'browser:control',
+    'browser.screenshot': 'browser:control',
+    'browser.evaluate': 'browser:control',
+    'browser.automate': 'browser:control',
+    'browser.automate.approve': 'browser:control',
+    'browser.back': 'browser:control',
+    'browser.forward': 'browser:control',
+    'browser.reload': 'browser:control',
+    'browser.stop': 'browser:control',
+    'browser.view.attach': 'browser:control',
+    'browser.view.answer': 'browser:control',
+    'browser.view.ice': 'browser:control',
+    'browser.view.state': 'browser:control',
+    'browser.view.input': 'browser:control',
+    'browser.view.bounds': 'browser:control',
+    'browser.preflight': 'browser:read',
+    'browser.resumeDriver': 'browser:control',
+    'browser.setDeviceProfile': 'browser:control',
+    'composer.autocomplete': 'files:workspace:read',
+    'composer.skills': 'settings:read',
+    'composer.snippets': 'settings:read',
+    'composer.settings': 'settings:read',
+    'terminal.sessions.list': 'terminal:read',
+    'terminal.sessions.subscribe': 'terminal:read',
+    'terminal.attach': 'terminal:read',
+    'terminal.open': 'terminal:exec',
+    'terminal.write': 'terminal:exec',
+    'terminal.resize': 'terminal:exec',
+    'terminal.close': 'terminal:exec',
+    'git.status': 'git:read',
+    'git.log': 'git:read',
+    'git.diff': 'git:read',
+    'git.show': 'git:read',
+    'git.commitDiff': 'git:read',
+    'git.branches.list': 'git:read',
+    'git.tags.list': 'git:read',
+    'git.remote.info': 'git:read',
+    'git.repos.discover': 'git:read',
+    'git.worktrees.list': 'git:read',
+    'git.merge.preview': 'git:read',
+    'git.pr.generateDescription': 'git:read',
+    'git.branches.create': 'git:write',
+    'git.branches.delete': 'git:write',
+    'git.tags.create': 'git:write',
+    'git.worktrees.create': 'git:write',
+    'git.worktrees.remove': 'git:write',
+    'git.worktrees.switchActive': 'git:write',
+    'git.worktrees.subscribe': 'git:read',
+    'git.merge.run': 'git:write',
+    'git.merge.abort': 'git:write',
+    'git.merge.complete': 'git:write',
+    'git.merge.stashPop': 'git:write',
+    'git.merge.discardBlockers': 'git:write',
+    'git.stage': 'git:write',
+    'git.unstage': 'git:write',
+    'git.commit': 'git:write',
+    'git.generateCommitMessage': 'git:write',
+    'git.checkout': 'git:write',
+    'git.tags.push': 'git:remote',
+    'git.pr.create': 'git:remote',
+    'git.push': 'git:remote',
+    'git.pull': 'git:remote',
+    'git.subscribeBranchChanged': 'git:read',
+    'git.subscribeCommitSuggestion': 'git:read',
+    'tools.register': 'tools:serve',
+    'tools.result': 'tools:serve',
+    'quality.state': 'quality:read',
+    'quality.detectTools': 'quality:read',
+    'quality.result': 'quality:read',
+    'quality.settings': 'quality:read',
+    'quality.subscribeChanges': 'quality:read',
+    'quality.run': 'quality:run',
+    'quality.cancel': 'quality:run',
+    'quality.installTools': 'quality:run',
+    'quality.saveDirectories': 'quality:run',
+    'quality.setSettings': 'quality:run',
+    'inference.chat': 'inference:run',
+    'inference.result': 'inference:run',
+    'endpoints.register': 'endpoints:register',
+    'endpoints.unregister': 'endpoints:register',
+    'endpoints.list': 'endpoints:register',
+    'quality.setFindingState': 'quality:run',
+    'quality.schedules.list': 'quality:read',
+    'quality.schedules.create': 'quality:run',
+    'quality.schedules.update': 'quality:run',
+    'quality.schedules.delete': 'quality:run',
+};
+const MOCK_ENDPOINT_APP_ID = 'mock-app';
+const MOCK_ENDPOINT_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,31}$/;
+const MOCK_ENDPOINT_LABEL_CHARS = 80;
+const MOCK_ENDPOINT_MODEL_CHARS = 200;
+const MOCK_ENDPOINT_API_KEY_BYTES = 4096;
+const MOCK_ENDPOINT_URL_BYTES = 2048;
+const MOCK_ENDPOINT_DEFAULT_TTL_MS = 3_600_000;
+const MOCK_ENDPOINT_ENGINES = ['hermes'];
+const MOCK_ENDPOINT_REGISTER_SHAPE = '{ id, label, engine, baseUrl, apiKey, model, contextLength?, ttlMs? }';
+const MOCK_ENDPOINT_REGISTER_KEYS = new Set([
+    'id',
+    'label',
+    'engine',
+    'baseUrl',
+    'apiKey',
+    'model',
+    'contextLength',
+    'ttlMs',
+]);
+const MOCK_CONTROL_CHARS = /[\u0000-\u001f\u007f]/;
+const MOCK_WHITESPACE_OR_CONTROL = /[\s\u0000-\u001f\u007f]/;
+const MOCK_LOCAL_ONLY_SUFFIXES = ['localhost', 'local', 'internal', 'home.arpa'];
+const MOCK_RUN_PARAMS_SHAPE = '{ prompt, title?, model?, modelSelection?, systemPrompt?, budget?: { maxTurns?, maxSeconds? }, sessionId? }';
+const MOCK_RUN_PARAM_KEYS = new Set([
+    'prompt',
+    'title',
+    'model',
+    'modelSelection',
+    'systemPrompt',
+    'budget',
+    'sessionId',
+]);
+const MOCK_RUN_BUDGET_KEYS = new Set(['maxTurns', 'maxSeconds']);
+const utf8ByteLength = (value) => new TextEncoder().encode(value).length;
+function mockValidateEndpointUrl(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        return { ok: false, reason: 'is not a valid absolute URL' };
+    }
+    if (url.protocol !== 'https:')
+        return { ok: false, reason: 'must use https' };
+    if (url.username !== '' || url.password !== '')
+        return { ok: false, reason: 'must not carry credentials' };
+    if (url.search !== '' || url.href.includes('?'))
+        return { ok: false, reason: 'must not carry a query' };
+    if (url.hash !== '' || url.href.includes('#'))
+        return { ok: false, reason: 'must not carry a fragment' };
+    const name = url.hostname.replace(/\.+$/, '').toLowerCase();
+    if (name === '')
+        return { ok: false, reason: 'must name a host' };
+    if (name.startsWith('[') || /^\d{1,3}(\.\d{1,3}){3}$/.test(name)) {
+        return { ok: false, reason: 'must name a hostname, not an IP address' };
+    }
+    if (MOCK_LOCAL_ONLY_SUFFIXES.some((suffix) => name === suffix || name.endsWith(`.${suffix}`))) {
+        return { ok: false, reason: 'must not name a local-network host' };
+    }
+    const canonical = `${url.origin}${url.pathname === '/' ? '' : url.pathname}`;
+    if (utf8ByteLength(canonical) > MOCK_ENDPOINT_URL_BYTES) {
+        return { ok: false, reason: `must be at most ${MOCK_ENDPOINT_URL_BYTES} bytes` };
+    }
+    return { ok: true };
+}
+const MOCK_TOOL_CALL_TIMEOUT_MS = 30_000;
+const MOCK_TOOL_CALL_TIMEOUT_MAX_MS = 120_000;
+const MOCK_GIT_MAIN_WORKTREE_PATH = '/workspace';
+const MOCK_GIT_DEFAULT_BRANCH = 'main';
+const MOCK_GIT_REMOTE_URL = 'https://github.com/mock-org/mock-repo.git';
+const MOCK_TERMINAL_SCROLLBACK_MAX = 256 * 1024;
+const MOCK_PTY_BURST_CHUNKS = 200;
+const MOCK_QUALITY_ROOT_PATH = '.';
+const MOCK_QUALITY_SEEDED_AT = '2026-04-13T18:29:50.235Z';
+const MOCK_QUALITY_BASELINE_AT = '2026-04-12T11:02:17.410Z';
+const MOCK_QUALITY_NA_PATH = 'docs';
+const MOCK_QUALITY_PARTIAL_PATH = 'packages/legacy';
+const MOCK_QUALITY_AGENT_TURN_PROMPT = 'quality: agent turn';
+const MOCK_QUALITY_WORKTREE_TURN_PROMPT = 'quality: worktree turn';
+const MOCK_QUALITY_TURN_FILE = 'src/services/report-builder.ts';
+const MOCK_QUALITY_TOOLS = [
+    { name: 'eslint', installed: true, installCommand: 'npm install -D eslint', category: 'linter' },
+    { name: 'prettier', installed: true, installCommand: 'npm install -D prettier', category: 'formatter' },
+    { name: 'typescript', installed: true, installCommand: 'npm install -D typescript', category: 'general' },
+    { name: 'biome', installed: false, installCommand: 'npm install -D @biomejs/biome', category: 'linter' },
+    { name: 'jscpd', installed: false, installCommand: 'npm install -D jscpd', category: 'general' },
+    { name: 'pip-audit', installed: false, installCommand: 'pip install pip-audit', category: 'security' },
+];
+const MOCK_QUALITY_ECOSYSTEM = ['node', 'python'];
+const MOCK_QUALITY_FINDINGS = [
+    {
+        severity: 'high',
+        category: 'secrets',
+        file: 'src/config/analytics.ts',
+        line: 7,
+        title: 'generic-api-key',
+        description: 'Detected a Generic API Key, potentially exposing access to various services and sensitive operations.',
+        suggestion: 'Move the value to the environment and rotate it — it is already in git history.',
+        fingerprint: 'eaaf9634c34ff05fcb3378ffb5e68fa1947ef88ac35cdc75d011850cba70375b',
+        introduced: true,
+    },
+    {
+        severity: 'high',
+        category: 'dependencies',
+        file: 'package-lock.json',
+        line: null,
+        title: 'serialize-anything <2.1.4 — prototype pollution (GHSA-8q2v-w5xj-3rpc)',
+        description: 'npm audit reports advisory GHSA-8q2v-w5xj-3rpc (high) against serialize-anything 2.0.3; fixed in 2.1.4.',
+        suggestion: 'npm update serialize-anything',
+        fingerprint: '48acfa3b78b839a91211c2b529dee95a9347e064043e93a3cbbf6c9dd14c3d64',
+        introduced: true,
+    },
+    {
+        severity: 'high',
+        category: 'complexity',
+        file: 'src/services/report-builder.ts',
+        line: 214,
+        title: 'buildReport() has cyclomatic complexity 21',
+        description: 'Complexity 21 exceeds the threshold of 10. Rank: D.',
+        status: 'confirmed',
+        confidence: 0.92,
+        triageRationale: '21 real branches, no dead paths.',
+        fingerprint: 'f3b867d61d68176490529d8d31ddd5c1cea0edd896272d5195e228758a0aabab',
+        introduced: false,
+    },
+    {
+        severity: 'medium',
+        category: 'file-length',
+        file: 'src/services/report-builder.ts',
+        line: null,
+        title: 'report-builder.ts is 812 lines',
+        description: 'Exceeds the 600-line module threshold.',
+        status: 'confirmed',
+        fingerprint: '692f9acde06f364ab152df3ef1a534129b96ae01e5f6abdf9e536fd5a7692b8b',
+        introduced: false,
+    },
+    {
+        severity: 'medium',
+        category: 'security',
+        file: 'src/routes/export.ts',
+        line: 58,
+        title: 'User-supplied filename reaches the filesystem unvalidated',
+        description: 'The `name` query param is joined onto a directory without normalization.',
+        suggestion: 'Reject any name containing a path separator before joining.',
+        status: 'uncertain',
+        confidence: 0.41,
+        triageRationale: 'The caller may normalize upstream — not verified.',
+        fingerprint: '5b3892962cb1f2731d3dfcb4ada8c39d3424182dde4d173ccfdee4f99609745c',
+        introduced: false,
+    },
+    {
+        severity: 'medium',
+        category: 'duplication',
+        file: 'src/services/summary-builder.ts',
+        line: 118,
+        title: 'Duplicated block (18 lines, 96 tokens)',
+        description: 'src/services/summary-builder.ts:118–135 duplicates src/services/report-builder.ts:340–357.',
+        suggestion: 'Extract the shared row-mapping into one helper both builders call.',
+        status: 'confirmed',
+        confidence: 0.88,
+        triageRationale: 'A verbatim clone, not a coincidental resemblance.',
+        fingerprint: '7648ed24afef95de19a59a26fb47bbb5feaa9b8a929bd96dbb8acbcd392f59eb',
+        introduced: false,
+    },
+    {
+        severity: 'low',
+        category: 'tech-debt',
+        file: 'src/hooks/useTrend.ts',
+        line: 12,
+        title: 'TODO: replace the placeholder trend window',
+        description: 'Marker left since the initial implementation.',
+        status: 'likely-fp',
+        confidence: 0.78,
+        triageRationale: 'An honest note about a deliberate default, not debt.',
+        fingerprint: '43905119f9df837bb902c93a225f8d645f309fb0731ea29be2aa89c171764517',
+        introduced: false,
+    },
+];
+const MOCK_QUALITY_CODE_REVIEW = [
+    {
+        severity: 'high',
+        category: 'architecture',
+        file: 'src/services/report-builder.ts',
+        line: null,
+        title: 'Report assembly and persistence are the same unit',
+        description: 'Assembly and persistence cannot be exercised separately.',
+        suggestion: 'Extract a ReportWriter so assembly can be tested without I/O.',
+        evidence: 'buildReport() calls writeFile() directly at three points.',
+        verified: true,
+        verificationNote: 'Confirmed against the current file.',
+        fingerprint: '6aaa6a35b6b751d2cb4a036fef9c851025790c33e7f0d871620ac7c39bafcb3e',
+        introduced: false,
+    },
+];
+const MOCK_QUALITY_TURN_FINDING = {
+    severity: 'low',
+    category: 'lint',
+    file: MOCK_QUALITY_TURN_FILE,
+    line: 231,
+    title: 'no-unused-vars',
+    description: "'legacyTotals' is assigned a value but never used.",
+    fingerprint: '82e9506cdeed63aac266450c76fa3e6d13b762386383140584cce360f5108fe2',
+    introduced: true,
+};
+const mockQualityFindings = (source, withBaseline) => source.map(({ introduced, ...finding }) => (withBaseline ? { ...finding, introduced } : finding));
+const MOCK_QUALITY_AGENT_COST = (sampledAt) => ({
+    available: true,
+    sampledAt,
+    sampledTurns: 61,
+    truncated: false,
+    attributedTurns: 19,
+    unattributed: { missingOutputTokens: 2, outsideSpaceRoot: 4, unknownWriteTools: 1 },
+    unreadableFiles: 0,
+    files: [
+        { file: 'src/services/report-builder.ts', turns: 9, medianOutputTokens: 6_420, medianDurationMs: 212_000 },
+        { file: 'src/services/summary-builder.ts', turns: 3, reason: '3 turns; 5 needed' },
+    ],
+    comparison: {
+        withStructuralFindings: { turns: 12, medianOutputTokens: 5_880 },
+        withoutStructuralFindings: { turns: 7, reason: '7 turns; 10 needed' },
+    },
+});
+const MOCK_QUALITY_COMMIT = {
+    sha: '3f9c2a7e1b5d4c6f8a0e9b2d7c1f4a6e8b3d5c7f',
+    branch: 'main',
+    dirty: true,
+};
+const MOCK_QUALITY_STRUCTURAL_SCOPE = () => ({ files: 96, extensions: ['.py', '.ts', '.tsx'] });
+const MOCK_QUALITY_CHANGE_ACTIVITY = (root) => ({
+    available: true,
+    windowDays: 90,
+    commitsScanned: root ? 143 : 37,
+    truncated: false,
+    files: {
+        'src/services/report-builder.ts': { commits: 17, linesChanged: 1_204, lastChangedAt: '2026-04-12T16:41:03.000Z' },
+        'src/index.ts': { commits: 11, linesChanged: 402, lastChangedAt: '2026-04-13T09:20:31.000Z' },
+        ...(root ? { 'package-lock.json': { commits: 9, linesChanged: 2_876, lastChangedAt: '2026-04-10T14:55:00.000Z' } } : {}),
+        'src/routes/index.ts': { commits: 8, linesChanged: 265, lastChangedAt: '2026-04-08T17:30:12.000Z' },
+        'src/services/summary-builder.ts': { commits: 6, linesChanged: 318, lastChangedAt: '2026-04-09T10:12:47.000Z' },
+        'src/config/analytics.ts': { commits: 2, linesChanged: 41, lastChangedAt: '2026-04-11T08:03:19.000Z' },
+    },
+});
+const mockQualityBand = (score) => score >= 90 ? 'A' : score >= 80 ? 'B' : score >= 70 ? 'C' : 'F';
+const mockQualityReport = (path, timestamp, withReview, baselineAt) => {
+    const root = path === MOCK_QUALITY_ROOT_PATH;
+    const findings = mockQualityFindings(root ? MOCK_QUALITY_FINDINGS : MOCK_QUALITY_FINDINGS.filter((finding) => finding.category !== 'dependencies'), baselineAt !== undefined);
+    return {
+        path,
+        overall: 87,
+        grade: 'B+',
+        dimensions: [
+            {
+                name: 'security',
+                score: 94,
+                grade: 'A',
+                rationale: root
+                    ? 'One leaked key, one vulnerable dependency, one unverified input-handling finding.'
+                    : 'One leaked key, one unverified input-handling finding.',
+                available: true,
+                findingCount: root ? 3 : 2,
+                worstSeverity: 'high',
+            },
+            {
+                name: 'reliability',
+                score: 88,
+                grade: 'B+',
+                rationale: 'Lint and build clean; one complexity hot spot.',
+                available: true,
+                findingCount: 1,
+                worstSeverity: 'high',
+            },
+            {
+                name: 'maintainability',
+                score: 81,
+                grade: 'B-',
+                rationale: 'One oversized module carries the debt, and a block of it is duplicated.',
+                available: true,
+                findingCount: 3,
+                worstSeverity: 'medium',
+            },
+        ],
+        categories: [
+            { name: 'Linting', score: 100, available: true, issueCount: 0 },
+            { name: 'Build', score: 100, available: true, issueCount: 0 },
+            { name: 'complexity', score: 88, available: true, issueCount: 1 },
+            { name: 'file-length', score: 82, available: true, issueCount: 1 },
+            { name: 'security', score: 94, available: true, issueCount: 1 },
+            { name: 'Duplication', score: 90, available: true, issueCount: 1 },
+            { name: 'Secrets', score: 80, available: true, issueCount: 1 },
+            root
+                ? { name: 'Dependencies', score: 85, available: true, issueCount: 1 }
+                : {
+                    name: 'Dependencies',
+                    score: 0,
+                    available: false,
+                    issueCount: 0,
+                    reason: `npm audit needs a lockfile and ${path} has no package-lock.json — the audit did not run.`,
+                },
+        ],
+        findings,
+        codeReview: withReview ? mockQualityFindings(MOCK_QUALITY_CODE_REVIEW, baselineAt !== undefined) : [],
+        analyzedFiles: 128,
+        totalLines: 24_680,
+        timestamp,
+        ecosystem: [...MOCK_QUALITY_ECOSYSTEM],
+        scoreBreakdown: {
+            penaltyDensity: 1.3,
+            totalPenalty: root ? 52.7 : 47.3,
+            issueDensity: root ? 0.24 : 0.2,
+            kloc: 24.7,
+            categoryPenalties: [
+                { category: 'complexity', score: 88, grade: 'B+', penalty: 14.4, findingCount: 1 },
+                { category: 'file-length', score: 82, grade: 'B-', penalty: 11.2, findingCount: 1 },
+                { category: 'security', score: 94, grade: 'A', penalty: 6.5, findingCount: 1 },
+                { category: 'duplication', score: 90, grade: 'A', penalty: 4.1, findingCount: 1 },
+                { category: 'secrets', score: 80, grade: 'B', penalty: 11.1, findingCount: 1 },
+                ...(root ? [{ category: 'dependencies', score: 85, grade: 'B', penalty: 5.4, findingCount: 1 }] : []),
+            ],
+        },
+        gate: { passed: true, failingConditions: [] },
+        gradeRationale: 'No critical findings; the high-severity hot spot and the leaked key hold the grade at B+.',
+        readiness: {
+            level: 'develop',
+            headline: 'Ready for development',
+            rationale: 'Nothing blocking, but the leaked key and the hot spot should land before a release cut.',
+            blockers: [
+                'src/config/analytics.ts:7 — generic-api-key',
+                'src/services/report-builder.ts:214 — buildReport() has cyclomatic complexity 21',
+            ],
+        },
+        triage: { total: 5, confirmed: 3, likelyFalsePositive: 1, uncertain: 1 },
+        scanDurationMs: 42_000,
+        ...(withReview ? { reviewDurationMs: 96_000 } : {}),
+        ...(baselineAt === undefined ? {} : { baselineAt }),
+        agentCost: root
+            ? MOCK_QUALITY_AGENT_COST(timestamp)
+            : { available: false, reason: 'mock: .minionry/history/ could not be read — the Space history is missing or unreadable.' },
+        structuralScope: MOCK_QUALITY_STRUCTURAL_SCOPE(),
+        changeActivity: MOCK_QUALITY_CHANGE_ACTIVITY(root),
+        commit: { ...MOCK_QUALITY_COMMIT },
+    };
+};
+const mockQualityNaReport = (path, timestamp) => {
+    const noEcosystem = `No ecosystem was detected in ${path}, so no analyzer ran.`;
+    const unavailable = (name, reason) => ({
+        name,
+        score: 0,
+        available: false,
+        issueCount: 0,
+        reason,
+    });
+    return {
+        path,
+        overall: null,
+        grade: 'N/A',
+        dimensions: ['security', 'reliability', 'maintainability'].map((name) => ({
+            name,
+            score: null,
+            grade: 'N/A',
+            rationale: 'No tooling was available to evaluate this directory.',
+            available: false,
+            findingCount: 0,
+            worstSeverity: null,
+        })),
+        categories: [
+            unavailable('Linting', noEcosystem),
+            unavailable('Build', noEcosystem),
+            unavailable('complexity', noEcosystem),
+            unavailable('file-length', noEcosystem),
+            unavailable('Duplication', 'jscpd is not installed (npm install -D jscpd).'),
+            unavailable('Secrets', 'gitleaks is not on PATH — https://github.com/gitleaks/gitleaks#installing'),
+            unavailable('Dependencies', 'No lockfile was found — npm audit, pip-audit and cargo audit each need one.'),
+        ],
+        findings: [],
+        codeReview: [],
+        analyzedFiles: 0,
+        totalLines: 0,
+        timestamp,
+        ecosystem: [],
+        gradeRationale: 'No tooling was available, so no grade could be computed.',
+        readiness: {
+            level: 'insufficient-data',
+            headline: 'Not enough data',
+            rationale: 'No dimension was available and no files were analyzed — nothing was evaluated.',
+            blockers: [],
+        },
+        scanDurationMs: 1_200,
+        agentCost: {
+            available: true,
+            sampledAt: timestamp,
+            sampledTurns: 61,
+            truncated: false,
+            attributedTurns: 0,
+            unattributed: { missingOutputTokens: 0, outsideSpaceRoot: 0, unknownWriteTools: 0 },
+            unreadableFiles: 0,
+            files: [],
+            comparison: {
+                withStructuralFindings: { turns: 0, reason: '0 turns; 10 needed' },
+                withoutStructuralFindings: { turns: 0, reason: '0 turns; 10 needed' },
+            },
+        },
+        changeActivity: {
+            available: false,
+            reason: `mock: ${path} is not inside a git work tree — the change-activity sample did not run.`,
+            windowDays: 90,
+            commitsScanned: 0,
+            truncated: false,
+            files: {},
+        },
+    };
+};
+const mockQualityAgentTurnReport = (path, timestamp, baselineAt) => ({
+    path,
+    overall: 79,
+    grade: 'C+',
+    dimensions: [
+        {
+            name: 'security',
+            score: 100,
+            grade: 'A+',
+            rationale: 'No security findings in the files this turn wrote.',
+            available: true,
+            findingCount: 0,
+            worstSeverity: null,
+        },
+        {
+            name: 'reliability',
+            score: 84,
+            grade: 'B',
+            rationale: 'One new lint hit; the complexity hot spot is unchanged.',
+            available: true,
+            findingCount: 2,
+            worstSeverity: 'high',
+        },
+        {
+            name: 'maintainability',
+            score: 78,
+            grade: 'C+',
+            rationale: 'The oversized module is still oversized.',
+            available: true,
+            findingCount: 1,
+            worstSeverity: 'medium',
+        },
+    ],
+    categories: [
+        { name: 'Linting', score: 92, available: true, issueCount: 1 },
+        { name: 'Build', score: 100, available: true, issueCount: 0 },
+        { name: 'complexity', score: 88, available: true, issueCount: 1 },
+        { name: 'file-length', score: 82, available: true, issueCount: 1 },
+    ],
+    findings: mockQualityFindings([MOCK_QUALITY_TURN_FINDING, ...MOCK_QUALITY_FINDINGS.filter((finding) => finding.file === MOCK_QUALITY_TURN_FILE)], baselineAt !== undefined),
+    codeReview: [],
+    analyzedFiles: 1,
+    totalLines: 812,
+    timestamp,
+    ecosystem: [...MOCK_QUALITY_ECOSYSTEM],
+    gradeRationale: 'Scoped to the files this turn wrote — not a grade for the directory.',
+    scanDurationMs: 3_400,
+    ...(baselineAt === undefined ? {} : { baselineAt }),
+    structuralScope: { files: 1, extensions: ['.ts'] },
+});
+const mockQualityHistoryEntry = (report) => ({
+    timestamp: report.timestamp,
+    overall: report.overall,
+    grade: report.grade,
+    issueDensity: report.scoreBreakdown?.issueDensity,
+    categoryScores: report.categories
+        .filter((category) => category.available)
+        .map((category) => ({
+        category: category.name,
+        score: category.score,
+        grade: mockQualityBand(category.score),
+    })),
+    dimensionScores: Object.fromEntries(report.dimensions.map((dimension) => [dimension.name, { score: dimension.score, grade: dimension.grade }])),
+    directories: [{ path: report.path, score: report.overall, grade: report.grade }],
+    scanDurationMs: report.scanDurationMs,
+    reviewDurationMs: report.reviewDurationMs,
+    ...(report.commit === undefined ? {} : { commit: { ...report.commit } }),
+});
+const MOCK_QUALITY_FINGERPRINTS_PER_CALL = 1_000;
+const MOCK_QUALITY_REASON_MAX = 500;
+export function createMockTransport(config = {}) {
+    const space = { ...DEFAULT_SPACE, ...config.space };
+    const user = config.user === null ? null : { ...DEFAULT_USER, ...config.user };
+    const denied = new Set(config.deniedScopes ?? []);
+    const forcedErrors = config.errors ?? {};
+    const theme = {
+        ...DEFAULT_THEME,
+        ...config.theme,
+        tokens: { ...DEFAULT_THEME.tokens, ...config.theme?.tokens },
+    };
+    const locale = { ...DEFAULT_LOCALE, ...config.locale };
+    const granted = new Set();
+    let notificationGranted = false;
+    const files = new Map(Object.entries(config.files ?? {}));
+    const dirs = new Set();
+    const timestamps = new Map();
+    const uploads = new Map();
+    const downloads = new Map();
+    const storage = new Map();
+    for (const [key, value] of Object.entries(config.storage ?? {}))
+        storage.set(key, structuredClone(value));
+    const runsByRequestId = new Map();
+    const runsByRunId = new Map();
+    const inferenceRunsByRequestId = new Map();
+    const inferenceRunsByRunId = new Map();
+    const endpoints = new Map();
+    const runSessions = new Map();
+    const boards = new Map();
+    const subscriptions = new Map();
+    const execRunsByBoardId = new Map();
+    const execRunsByRunId = new Map();
+    const execRunsByRequestId = new Map();
+    const schedules = new Map();
+    const fileChangeSubscriptions = new Map();
+    const browserTabs = DEFAULT_BROWSER_TABS.map((tab) => ({ ...tab }));
+    let currentTabId = browserTabs[0]?.id ?? null;
+    const browserTabSubscriptions = new Set();
+    let browserEpoch = 1;
+    const automations = new Map();
+    const views = new Map();
+    const sessions = new Map();
+    const gitCommits = [];
+    const gitBranches = new Map();
+    const gitTags = new Map();
+    const gitWorktrees = new Map();
+    let gitActiveWorktreePath = null;
+    const gitWorktreeSubscriptions = new Set();
+    const gitBranchChangeSubscriptions = new Set();
+    const gitCommitSuggestionSubscriptions = new Set();
+    const ptySessions = new Map();
+    const ptyAttachByRequestId = new Map();
+    const terminalSessionSubscriptions = new Set();
+    const toolRegistrations = new Map();
+    const toolCalls = new Map();
+    let toolCallCounter = 0;
+    let qualityDirectories = [
+        { path: MOCK_QUALITY_ROOT_PATH, label: 'Workspace' },
+        { path: MOCK_QUALITY_NA_PATH, label: 'Docs' },
+        { path: MOCK_QUALITY_PARTIAL_PATH, label: 'Legacy' },
+    ];
+    const qualityReports = new Map();
+    const qualityHistory = [];
+    let qualityPendingResults = [];
+    const qualityRunsByPath = new Map();
+    const qualityRunsByRequestId = new Map();
+    const qualityResults = new Map();
+    const qualityChangeSubscriptions = new Set();
+    const qualitySchedules = [];
+    let qualityScheduleCounter = 0;
+    const qualityInstalledTools = new Map();
+    const qualitySettings = {
+        engine: 'claude-code',
+        model: 'default',
+        effortLevel: 'auto',
+        fastMode: false,
+        agentNotes: true,
+    };
+    let qualityPostSessionFired = false;
+    const qualitySuppressions = new Map();
+    {
+        const seeded = mockQualityReport(MOCK_QUALITY_ROOT_PATH, MOCK_QUALITY_SEEDED_AT, true, MOCK_QUALITY_BASELINE_AT);
+        qualityReports.set(MOCK_QUALITY_ROOT_PATH, seeded);
+        qualityHistory.push(mockQualityHistoryEntry(seeded));
+        qualityPendingResults = [
+            {
+                kind: 'codeReview',
+                path: MOCK_QUALITY_ROOT_PATH,
+                completedAt: MOCK_QUALITY_SEEDED_AT,
+                findings: MOCK_QUALITY_CODE_REVIEW.map((finding) => ({ ...finding })),
+            },
+        ];
+    }
+    let handlers;
+    let closed = false;
+    let seq = 0;
+    const streamSeq = new Map();
+    const streamLog = new Map();
+    const timers = new Set();
+    const deliver = (fn) => {
+        queueMicrotask(() => {
+            if (!closed)
+                fn();
+        });
+    };
+    const later = (fn) => {
+        const id = setTimeout(() => {
+            timers.delete(id);
+            if (!closed)
+                fn();
+        }, 0);
+        timers.add(id);
+    };
+    const respond = (requestId, result) => {
+        deliver(() => handlers?.onResponse({ requestId, ok: true, result }));
+    };
+    const fail = (requestId, error) => {
+        deliver(() => handlers?.onResponse({ requestId, ok: false, error }));
+    };
+    const emit = (requestId, event, payload) => {
+        const eventSeq = (streamSeq.get(requestId) ?? 0) + 1;
+        streamSeq.set(requestId, eventSeq);
+        const logged = payload !== undefined ? { seq: eventSeq, event, payload } : { seq: eventSeq, event };
+        const log = streamLog.get(requestId);
+        if (log)
+            log.push(logged);
+        else
+            streamLog.set(requestId, [logged]);
+        deliver(() => handlers?.onEvent({ requestId, event, payload, seq: eventSeq }));
+    };
+    const notify = (event, payload) => {
+        deliver(() => handlers?.onNotification({ event, payload }));
+    };
+    const emitEphemeral = (requestId, event, payload) => {
+        const eventSeq = (streamSeq.get(requestId) ?? 0) + 1;
+        streamSeq.set(requestId, eventSeq);
+        deliver(() => handlers?.onEvent({ requestId, event, payload, seq: eventSeq }));
+    };
+    const asRecord = (params, method) => {
+        if (typeof params !== 'object' || params === null) {
+            throw new MinionryError('BAD_REQUEST', `${method}: params must be an object`);
+        }
+        return params;
+    };
+    const asString = (value, name, method) => {
+        if (typeof value !== 'string') {
+            throw new MinionryError('BAD_REQUEST', `${method}: '${name}' must be a string`);
+        }
+        return value;
+    };
+    const mockScheduleTiming = (raw, method) => {
+        if (typeof raw !== 'object' || raw === null) {
+            throw new MinionryError('BAD_REQUEST', `${method}: timing must be an object`);
+        }
+        const t = raw;
+        if (t.kind === 'once' && typeof t.at === 'string' && !Number.isNaN(Date.parse(t.at))) {
+            return { kind: 'once', at: t.at };
+        }
+        if (t.kind === 'interval' && typeof t.everyMs === 'number' && Number.isFinite(t.everyMs)) {
+            return { kind: 'interval', everyMs: t.everyMs };
+        }
+        if (t.kind === 'continuous')
+            return { kind: 'continuous' };
+        throw new MinionryError('BAD_REQUEST', `${method}: invalid timing`);
+    };
+    const mockNextFireAt = (timing, from) => {
+        if (timing.kind === 'once') {
+            const at = new Date(timing.at);
+            return at.getTime() >= from.getTime() ? at.toISOString() : null;
+        }
+        if (timing.kind === 'interval')
+            return new Date(from.getTime() + timing.everyMs).toISOString();
+        return null;
+    };
+    const settleWaiters = (run) => {
+        if (run.status === 'running')
+            return;
+        const result = { status: run.status, text: run.text };
+        for (const waiter of run.waiters)
+            respond(waiter, result);
+        run.waiters = [];
+    };
+    const settleRunSession = (run) => {
+        const session = sessions.get(run.sessionId);
+        if (!session)
+            return;
+        session.isExecuting = false;
+        session.lastActivityAt = new Date().toISOString();
+    };
+    const advanceRun = (run) => {
+        if (run.status !== 'running')
+            return;
+        const step = run.steps.shift();
+        if (!step) {
+            run.status = 'done';
+            emit(run.requestId, 'status', { status: 'done' });
+            settleWaiters(run);
+            settleRunSession(run);
+            if (run.agentTurn !== undefined) {
+                publishQualityAgentTurn(run.agentTurn);
+                return;
+            }
+            if (!qualityPostSessionFired && qualityChangeSubscriptions.size > 0) {
+                qualityPostSessionFired = true;
+                const report = qualityReports.get(MOCK_QUALITY_ROOT_PATH) ??
+                    mockQualityReport(MOCK_QUALITY_ROOT_PATH, new Date().toISOString(), true, undefined);
+                publishQualityChange({ kind: 'postSession', path: MOCK_QUALITY_ROOT_PATH, report });
+            }
+            return;
+        }
+        if (step.event === 'output')
+            run.text += step.payload.text;
+        emit(run.requestId, step.event, step.payload);
+        later(() => advanceRun(run));
+    };
+    const cancelRun = (run) => {
+        if (run.status !== 'running')
+            return;
+        run.status = 'cancelled';
+        run.steps = [];
+        emit(run.requestId, 'status', { status: 'cancelled' });
+        settleWaiters(run);
+        settleRunSession(run);
+    };
+    const isLiveEndpoint = (endpoint, now) => Date.parse(endpoint.expiresAt) > now;
+    const refuseUnknownKeys = (record, allowed, what, shape) => {
+        const unknown = Object.keys(record).filter((key) => !allowed.has(key));
+        if (unknown.length > 0) {
+            throw new MinionryError('BAD_REQUEST', `${what}: unknown param${unknown.length > 1 ? 's' : ''} ${unknown.map((key) => `'${key}'`).join(', ')} — expected ${shape}`);
+        }
+    };
+    const strictRecord = (params, method, shape, keys) => {
+        if (typeof params !== 'object' || params === null || Array.isArray(params)) {
+            throw new MinionryError('BAD_REQUEST', `${method} requires params ${shape}`);
+        }
+        const record = params;
+        refuseUnknownKeys(record, keys, method, shape);
+        return record;
+    };
+    const endpointId = (raw, method) => {
+        if (typeof raw !== 'string' || !MOCK_ENDPOINT_ID_PATTERN.test(raw)) {
+            throw new MinionryError('BAD_REQUEST', `${method}: id must match ${MOCK_ENDPOINT_ID_PATTERN.source}`);
+        }
+        return raw;
+    };
+    const endpointText = (raw, field, max) => {
+        if (typeof raw !== 'string' || raw.trim() === '' || raw.length > max || MOCK_CONTROL_CHARS.test(raw)) {
+            throw new MinionryError('BAD_REQUEST', `endpoints.register: ${field} must be a non-empty string of at most ${max} characters, without control characters`);
+        }
+        return raw.trim();
+    };
+    const optionalPositiveInteger = (raw, field) => {
+        if (raw === undefined || raw === null)
+            return undefined;
+        if (typeof raw !== 'number' || !Number.isSafeInteger(raw) || raw <= 0) {
+            throw new MinionryError('BAD_REQUEST', `endpoints.register: ${field} must be a positive integer when present`);
+        }
+        return raw;
+    };
+    const admitEndpointModel = (model) => {
+        const now = Date.now();
+        const endpoint = [...endpoints.values()].find((candidate) => candidate.modelValue === model && isLiveEndpoint(candidate, now));
+        if (!endpoint) {
+            throw new MinionryError('MODEL_NOT_ALLOWED', `agents.run: model '${model}' is not a live endpoint this app registered in this Space — register one with endpoints.register and pass its modelValue`);
+        }
+        return endpoint;
+    };
+    const admitModelSelection = (raw) => {
+        if (raw === undefined)
+            return undefined;
+        const name = AGENT_RUN_MODEL_SELECTIONS.find((known) => known === raw);
+        if (!name) {
+            const known = AGENT_RUN_MODEL_SELECTIONS.map((value) => `'${value}'`).join(', ');
+            throw new MinionryError('BAD_REQUEST', `agents.run modelSelection must be one of ${known} when present`);
+        }
+        if (!granted.has('quality:read')) {
+            throw new MinionryError('SCOPE_DENIED', `agents.run: modelSelection '${name}' needs the quality:read scope`);
+        }
+        if (qualitySettings.engine !== 'claude-code') {
+            throw new MinionryError('ENGINE_UNAVAILABLE', `agents.run: the Quality model runs on ${qualitySettings.engine}, and only Claude Code can run an app session with tools — choose a Claude Code model for Quality`);
+        }
+        if (qualitySettings.model.startsWith('custom:claude-code:')) {
+            throw new MinionryError('MODEL_NOT_ALLOWED', `agents.run: the Quality model '${qualitySettings.model}' is not a Claude Code model added on this machine — choose another model for Quality`);
+        }
+        return name;
+    };
+    const runParams = (params) => {
+        const record = strictRecord(params, 'agents.run', MOCK_RUN_PARAMS_SHAPE, MOCK_RUN_PARAM_KEYS);
+        const prompt = asString(record.prompt, 'prompt', 'agents.run');
+        const title = typeof record.title === 'string' ? record.title : undefined;
+        const optional = (field) => {
+            const value = record[field];
+            if (value === undefined)
+                return undefined;
+            if (typeof value !== 'string' || value === '') {
+                throw new MinionryError('BAD_REQUEST', `agents.run ${field} must be a non-empty string when present`);
+            }
+            return value;
+        };
+        const model = optional('model');
+        const sessionId = optional('sessionId');
+        const { systemPrompt, budget, modelSelection } = record;
+        if (systemPrompt !== undefined && (typeof systemPrompt !== 'string' || systemPrompt.length > AGENT_RUN_LIMITS.maxSystemPromptChars)) {
+            throw new MinionryError('BAD_REQUEST', `agents.run systemPrompt must be a string of at most ${AGENT_RUN_LIMITS.maxSystemPromptChars} characters`);
+        }
+        if (budget !== undefined) {
+            if (typeof budget !== 'object' || budget === null || Array.isArray(budget)) {
+                throw new MinionryError('BAD_REQUEST', 'agents.run budget must be an object { maxTurns?, maxSeconds? }');
+            }
+            const ceilings = budget;
+            refuseUnknownKeys(ceilings, MOCK_RUN_BUDGET_KEYS, 'agents.run budget', '{ maxTurns?, maxSeconds? }');
+            for (const field of ['maxTurns', 'maxSeconds']) {
+                const value = ceilings[field];
+                if (value !== undefined && (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0)) {
+                    throw new MinionryError('BAD_REQUEST', `agents.run budget.${field} must be a positive integer when present`);
+                }
+            }
+        }
+        const choosesModel = model !== undefined || modelSelection !== undefined;
+        if (sessionId !== undefined && (choosesModel || systemPrompt !== undefined || budget !== undefined)) {
+            throw new MinionryError('BAD_REQUEST', 'agents.run with sessionId continues that session on its own model, systemPrompt and budget — omit model, modelSelection, systemPrompt and budget');
+        }
+        if (model !== undefined && modelSelection !== undefined) {
+            throw new MinionryError('BAD_REQUEST', 'agents.run takes model or modelSelection, not both');
+        }
+        if (model === undefined && (systemPrompt !== undefined || budget !== undefined)) {
+            throw new MinionryError('BAD_REQUEST', 'agents.run systemPrompt and budget apply only to a run on an app-registered model — pass model');
+        }
+        admitModelSelection(modelSelection);
+        return { prompt, title, model, sessionId };
+    };
+    const endpointRunSteps = (endpoint, prompt, turn) => {
+        const at = Date.now();
+        const echoed = prompt.length > 120 ? `${prompt.slice(0, 119)}…` : prompt;
+        const chunks = [`(mock ${endpoint.engine} · ${endpoint.model}) `, `Turn ${turn}: ${echoed}\n`, 'Done (mock).'];
+        return [
+            { event: 'status', payload: { status: 'running' } },
+            { event: 'timelineEvent', payload: { kind: 'status', at, executing: true, turn } },
+            ...chunks.flatMap((text) => [
+                { event: 'output', payload: { text } },
+                { event: 'timelineEvent', payload: { kind: 'text', at, entryId: `mock-text-${turn}`, delta: text } },
+            ]),
+            { event: 'timelineEvent', payload: { kind: 'status', at, executing: false, turn } },
+        ];
+    };
+    const MOCK_INFERENCE_USAGE = { inputTokens: 64, outputTokens: 16 };
+    const inferenceResultOf = (run) => ({
+        status: run.status === 'running' ? 'done' : run.status,
+        text: run.text,
+        engine: run.engine,
+        ...(run.model ? { model: run.model } : {}),
+        ...(run.status === 'done' ? { usage: { ...MOCK_INFERENCE_USAGE } } : {}),
+    });
+    const settleInference = (run) => {
+        emit(run.requestId, 'status', { status: run.status });
+        for (const waiter of run.waiters)
+            respond(waiter, inferenceResultOf(run));
+        run.waiters = [];
+    };
+    const advanceInferenceRun = (run) => {
+        if (run.status !== 'running')
+            return;
+        const delta = run.deltas.shift();
+        if (delta === undefined) {
+            emit(run.requestId, 'usage', { ...MOCK_INFERENCE_USAGE });
+            run.status = 'done';
+            settleInference(run);
+            return;
+        }
+        run.text += delta;
+        emit(run.requestId, 'delta', { text: delta });
+        later(() => advanceInferenceRun(run));
+    };
+    const cancelInferenceRun = (run) => {
+        if (run.status !== 'running')
+            return;
+        run.status = 'cancelled';
+        run.deltas = [];
+        settleInference(run);
+    };
+    const mockSessionSummary = (session) => ({
+        id: session.id,
+        name: session.name,
+        createdAt: session.createdAt,
+        lastActivityAt: session.lastActivityAt,
+        isExecuting: session.isExecuting,
+    });
+    const boardIssue = (issue) => ({
+        id: issue.id,
+        title: issue.title,
+        status: issue.status,
+        type: issue.type,
+        priority: issue.priority,
+        labels: [...issue.labels],
+    });
+    const boardSnapshot = (board) => ({
+        boardId: board.boardId,
+        title: board.title,
+        statuses: [...board.statuses],
+        issues: board.issues.map(boardIssue),
+    });
+    const boardSummary = (board) => ({
+        id: board.boardId,
+        title: board.title,
+        status: board.completedAt ? 'completed' : board.status,
+        goal: board.goal,
+        created: board.createdAt,
+        completedAt: board.completedAt,
+    });
+    const mockIssue = (id, title, priority) => ({
+        id,
+        title,
+        type: 'issue',
+        status: BOARD_STATUSES[0],
+        priority,
+        estimate: null,
+        labels: [],
+        epicId: null,
+        blockedBy: [],
+        blocks: [],
+        description: '',
+        acceptanceCriteria: [],
+        created: MOCK_ISSUE_CREATED,
+        updated: null,
+    });
+    const requireBoard = (params, method) => {
+        const raw = asRecord(params, method);
+        const boardId = asString(raw.boardId, 'boardId', method);
+        const board = boards.get(boardId);
+        if (!board)
+            throw new MinionryError('BAD_REQUEST', `${method}: unknown boardId '${boardId}'`);
+        return { board, raw };
+    };
+    const requireIssue = (board, issueId, method) => {
+        const issue = board.issues.find((candidate) => candidate.id === issueId);
+        if (!issue) {
+            throw new MinionryError('BAD_REQUEST', `${method}: unknown issueId '${issueId}' on board '${board.boardId}'`);
+        }
+        return issue;
+    };
+    const nextIssueId = (board, prefix) => {
+        let max = 0;
+        for (const issue of board.issues) {
+            const match = issue.id.match(new RegExp(`^${prefix}-(\\d+)$`));
+            if (match)
+                max = Math.max(max, Number.parseInt(match[1], 10));
+        }
+        return `${prefix}-${max + 1}`;
+    };
+    const asStringList = (value, name, method) => {
+        if (!Array.isArray(value) || value.some((entry) => typeof entry !== 'string')) {
+            throw new MinionryError('BAD_REQUEST', `${method}: '${name}' must be an array of strings`);
+        }
+        return [...value];
+    };
+    const applyIssuePatch = (board, issue, raw, method) => {
+        const fields = asRecord(raw, method);
+        const issueRefs = (value, name) => {
+            const ids = asStringList(value, name, method);
+            for (const id of ids)
+                requireIssue(board, id, method);
+            return ids;
+        };
+        if (fields.title !== undefined)
+            issue.title = asString(fields.title, 'title', method);
+        if (fields.status !== undefined)
+            issue.status = asString(fields.status, 'status', method);
+        if (fields.priority !== undefined)
+            issue.priority = asString(fields.priority, 'priority', method);
+        if (fields.estimate !== undefined) {
+            const estimate = fields.estimate;
+            if (estimate !== null && typeof estimate !== 'number' && typeof estimate !== 'string') {
+                throw new MinionryError('BAD_REQUEST', `${method}: 'estimate' must be a number, string, or null`);
+            }
+            issue.estimate = estimate;
+        }
+        if (fields.labels !== undefined)
+            issue.labels = asStringList(fields.labels, 'labels', method);
+        if (fields.epicId !== undefined) {
+            const epicId = fields.epicId;
+            if (epicId !== null && typeof epicId !== 'string') {
+                throw new MinionryError('BAD_REQUEST', `${method}: 'epicId' must be an issue id or null`);
+            }
+            if (epicId !== null)
+                requireIssue(board, epicId, method);
+            issue.epicId = epicId;
+        }
+        if (fields.blockedBy !== undefined)
+            issue.blockedBy = issueRefs(fields.blockedBy, 'blockedBy');
+        if (fields.blocks !== undefined)
+            issue.blocks = issueRefs(fields.blocks, 'blocks');
+    };
+    const publishBoard = (board) => {
+        for (const requestId of board.subscribers)
+            emit(requestId, 'boardUpdate', boardSnapshot(board));
+    };
+    const progressBoard = (board) => {
+        const issue = board.issues.find((candidate) => candidate.status !== 'done');
+        if (!issue)
+            return;
+        const column = board.statuses.indexOf(issue.status);
+        issue.status = board.statuses[Math.min(column + 1, board.statuses.length - 1)];
+        if (board.issues.every((candidate) => candidate.status === 'done')) {
+            board.completedAt ??= new Date().toISOString();
+        }
+        publishBoard(board);
+        later(() => progressBoard(board));
+    };
+    const emitToRun = (run, event, payload) => {
+        for (const requestId of run.requestIds)
+            emit(requestId, event, payload);
+    };
+    const advanceExec = (run) => {
+        if (run.status !== 'running')
+            return;
+        const board = boards.get(run.boardId);
+        if (!board || run.issueIndex >= board.issues.length) {
+            run.status = 'done';
+            emitToRun(run, 'complete', { reason: 'All issues complete (mock)' });
+            return;
+        }
+        const issue = board.issues[run.issueIndex];
+        emitToRun(run, 'issueStarted', { issueId: issue.id, title: issue.title });
+        emitToRun(run, 'output', { issueId: issue.id, text: `Working on ${issue.title} (mock)...\n` });
+        emitToRun(run, 'toolUse', { issueId: issue.id, tool: 'write_file', input: { path: `${issue.id}.md` } });
+        emitToRun(run, 'tokens', {
+            issueId: issue.id,
+            inputTokens: 100,
+            outputTokens: 40,
+            cacheCreationTokens: 0,
+            cacheReadTokens: 0,
+            currentTurnInputTokens: 100,
+            isFinal: true,
+        });
+        issue.status = 'done';
+        emitToRun(run, 'issueComplete', { issueId: issue.id });
+        publishBoard(board);
+        run.issueIndex += 1;
+        later(() => advanceExec(run));
+    };
+    const notifyMockFileChanged = (path, kind) => {
+        for (const [requestId, root] of fileChangeSubscriptions) {
+            const prefix = root === '' || root === '.' ? '' : `${root.replace(/\/+$/, '')}/`;
+            if (prefix && !path.startsWith(prefix))
+                continue;
+            emit(requestId, 'changed', { path: prefix ? path.slice(prefix.length) : path, kind });
+        }
+    };
+    const browserTabsPayload = () => ({
+        tabs: browserTabs.map((tab) => ({ ...tab })),
+        currentTabId,
+    });
+    const publishBrowserTabs = () => {
+        for (const requestId of browserTabSubscriptions)
+            emit(requestId, 'tabsChanged', browserTabsPayload());
+        for (const view of views.values())
+            publishViewNavigation(view);
+    };
+    const publishViewNavigation = (view) => {
+        if (view.detached)
+            return;
+        const tab = browserTabs.find((candidate) => candidate.id === view.tabId);
+        if (!tab)
+            return;
+        emit(view.requestId, 'navigationState', {
+            tabId: tab.id,
+            url: tab.url,
+            title: tab.title,
+            isLoading: tab.isLoading,
+            canGoBack: tab.canGoBack,
+            canGoForward: tab.canGoForward,
+        });
+    };
+    const requireView = (params, method) => {
+        const sessionId = asString(asRecord(params, method).sessionId, 'sessionId', method);
+        for (const view of views.values()) {
+            if (view.sessionId === sessionId && !view.detached)
+                return view;
+        }
+        throw new MinionryError('BAD_REQUEST', `${method}: no live view session '${sessionId}'`);
+    };
+    const retireView = (view) => {
+        view.detached = true;
+        views.delete(view.requestId);
+        streamSeq.delete(view.requestId);
+        streamLog.delete(view.requestId);
+    };
+    const historyTarget = (params, method) => {
+        const record = params === undefined || params === null ? {} : asRecord(params, method);
+        const tabId = record.tabId === undefined || record.tabId === null
+            ? currentTabId
+            : asString(record.tabId, 'tabId', method);
+        if (tabId === null)
+            throw new MinionryError('BAD_REQUEST', `${method}: no tab is open`);
+        return requireBrowserTab(tabId, method);
+    };
+    const moveHistory = (params, method) => {
+        const tab = historyTarget(params, method);
+        if (method === 'browser.back') {
+            if (!tab.canGoBack)
+                return null;
+            tab.canGoBack = false;
+            tab.canGoForward = true;
+        }
+        else {
+            if (!tab.canGoForward)
+                return null;
+            tab.canGoForward = false;
+            tab.canGoBack = true;
+        }
+        browserEpoch += 1;
+        publishBrowserTabs();
+        return null;
+    };
+    const requireBrowserTab = (tabId, method) => {
+        const tab = browserTabs.find((candidate) => candidate.id === tabId);
+        if (!tab)
+            throw new MinionryError('BAD_REQUEST', `${method}: unknown tabId '${tabId}'`);
+        return tab;
+    };
+    const originOf = (url) => {
+        try {
+            return new URL(url).origin;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const MOCK_ENGINES = ['claude-code', 'codex', 'hermes'];
+    const MOCK_CODEX_MODEL_IDS = ['gpt-5.1-codex-max', 'gpt-5-codex'];
+    const mockEngineForModel = (model) => {
+        if (MOCK_CODEX_MODEL_IDS.includes(model))
+            return 'codex';
+        if (model.includes('/'))
+            return 'hermes';
+        return 'claude-code';
+    };
+    const MOCK_DEFAULT_ENGINE = 'claude-code';
+    const MOCK_DEFAULT_MODEL = 'opus';
+    const MOCK_EFFORT_LEVELS = {
+        'claude-code': ['auto', 'low', 'medium', 'high', 'xhigh', 'max'],
+        codex: ['auto', 'minimal', 'low', 'medium', 'high', 'xhigh'],
+        hermes: [],
+    };
+    const MOCK_INFERENCE_ENGINES = ['claude-code'];
+    const mockInferenceMessages = (raw) => {
+        const valid = Array.isArray(raw) &&
+            raw.length > 0 &&
+            raw.length <= 64 &&
+            raw.every((m) => typeof m === 'object' &&
+                m !== null &&
+                (m.role === 'user' || m.role === 'assistant') &&
+                typeof m.content === 'string') &&
+            raw[raw.length - 1].role === 'user';
+        if (!valid) {
+            throw new MinionryError('BAD_REQUEST', "inference.chat: messages must be 1–64 { role: 'user' | 'assistant', content } turns ending on a 'user' turn");
+        }
+        return raw;
+    };
+    const MOCK_MODEL_CATALOG = [
+        { value: 'default', engine: 'claude-code', label: 'Default', description: "The engine's own default model", isDefault: true },
+        { value: 'fable', engine: 'claude-code', label: 'Fable', description: 'Most capable, for the hardest work' },
+        { value: 'opus', engine: 'claude-code', label: 'Opus', description: 'Frontier reasoning for complex tasks' },
+        { value: 'sonnet', engine: 'claude-code', label: 'Sonnet', description: 'Balanced speed and capability' },
+        { value: 'haiku', engine: 'claude-code', label: 'Haiku', description: 'Fastest, for simple tasks' },
+        { value: 'gpt-5.1-codex-max', engine: 'codex', label: 'GPT-5.1 Codex Max', description: "Codex's most capable model", isDefault: true },
+        { value: 'gpt-5-codex', engine: 'codex', label: 'GPT-5 Codex', description: 'Faster Codex model' },
+        { value: 'z-ai/glm-5.2', engine: 'hermes', label: 'GLM 5.2', isDefault: true },
+        { value: 'moonshotai/kimi-k3', engine: 'hermes', label: 'Kimi K3' },
+    ];
+    const stampTarget = (run, step) => step.event === 'step' ? { ...step.payload, ...run.target } : step.payload;
+    const advanceAutomation = (run) => {
+        if (run.status !== 'running')
+            return;
+        const step = run.steps.shift();
+        if (!step) {
+            run.status = 'done';
+            automations.delete(run.requestId);
+            return;
+        }
+        emit(run.requestId, step.event, stampTarget(run, step));
+        if (step.event === 'done') {
+            run.status = 'done';
+            automations.delete(run.requestId);
+            return;
+        }
+        later(() => advanceAutomation(run));
+    };
+    const proposeAutomationAction = (run) => {
+        if (run.status !== 'running')
+            return;
+        const proposalId = `proposal-mock-${++seq}`;
+        run.pendingProposalId = proposalId;
+        run.status = 'awaiting-approval';
+        emit(run.requestId, 'proposed', { proposalId, summary: 'Click "Continue" on the page (mock)' });
+    };
+    const mockSnapshotRoot = (tab) => ({
+        ref: `${tab.id}-e1`,
+        role: 'RootWebArea',
+        name: tab.title,
+        children: [
+            { ref: `${tab.id}-e2`, role: 'heading', name: tab.title, level: 1, children: [] },
+            { ref: `${tab.id}-e3`, role: 'link', name: 'Mock link', value: tab.url, children: [] },
+        ],
+    });
+    const mintGitHash = () => `mock${(++seq).toString(16).padStart(36, '0')}`;
+    const gitShortHash = (hash) => hash.slice(0, 7);
+    const findGitCommit = (hash) => gitCommits.find((commit) => commit.hash === hash || commit.shortHash === hash);
+    const resolveGitWorktree = (path, method) => {
+        const target = path ?? gitActiveWorktreePath ?? MOCK_GIT_MAIN_WORKTREE_PATH;
+        const worktree = gitWorktrees.get(target);
+        if (!worktree)
+            throw new MinionryError('BAD_REQUEST', `${method}: unknown worktree '${target}'`);
+        return worktree;
+    };
+    const optionalWorktreeField = (value, method) => value === undefined || value === null ? undefined : asString(value, 'worktree', method);
+    const requireWorktree = (params, method) => {
+        const record = asRecord(params, method);
+        return { worktree: resolveGitWorktree(optionalWorktreeField(record.worktree, method), method), record };
+    };
+    const gitWorktreeStatus = (worktree) => ({
+        staged: worktree.staged.length,
+        unstaged: worktree.unstaged.length,
+        untracked: worktree.untracked.length,
+        ahead: 0,
+        behind: 0,
+        hasUpstream: gitBranches.get(worktree.branch)?.upstream !== undefined,
+    });
+    const gitWorktreeInfo = (worktree) => ({
+        path: worktree.path,
+        branch: worktree.branch,
+        head: gitBranches.get(worktree.branch)?.head ?? '',
+        isMain: worktree.isMain,
+        isBare: false,
+        status: gitWorktreeStatus(worktree),
+    });
+    const gitWorktreesSnapshot = () => ({
+        worktrees: [...gitWorktrees.values()].map(gitWorktreeInfo),
+        activeWorktreePath: gitActiveWorktreePath,
+    });
+    const publishGitWorktrees = () => {
+        for (const requestId of gitWorktreeSubscriptions)
+            emit(requestId, 'worktreesChanged', gitWorktreesSnapshot());
+    };
+    const publishGitBranchChanged = (worktree) => {
+        for (const requestId of gitBranchChangeSubscriptions) {
+            emit(requestId, 'branchChanged', { worktreePath: worktree.path, branch: worktree.branch });
+        }
+    };
+    const gitStageFile = (worktree, path, method) => {
+        const fromUntracked = worktree.untracked.findIndex((file) => file.path === path);
+        if (fromUntracked !== -1) {
+            const [file] = worktree.untracked.splice(fromUntracked, 1);
+            worktree.staged.push({ ...file, status: 'A', staged: true });
+            return;
+        }
+        const fromUnstaged = worktree.unstaged.findIndex((file) => file.path === path);
+        if (fromUnstaged !== -1) {
+            const [file] = worktree.unstaged.splice(fromUnstaged, 1);
+            worktree.staged.push({ ...file, staged: true });
+            return;
+        }
+        throw new MinionryError('BAD_REQUEST', `${method}: '${path}' has no pending changes in this worktree`);
+    };
+    const gitUnstageFile = (worktree, path, method) => {
+        const index = worktree.staged.findIndex((file) => file.path === path);
+        if (index === -1)
+            throw new MinionryError('BAD_REQUEST', `${method}: '${path}' is not staged`);
+        const [file] = worktree.staged.splice(index, 1);
+        if (file.status === 'A')
+            worktree.untracked.push({ ...file, status: '?', staged: false });
+        else
+            worktree.unstaged.push({ ...file, staged: false });
+    };
+    const gitInitialCommitHash = mintGitHash();
+    gitCommits.push({
+        hash: gitInitialCommitHash,
+        shortHash: gitShortHash(gitInitialCommitHash),
+        subject: 'Initial commit (mock)',
+        body: '',
+        author: user?.name ?? 'Mock User',
+        date: new Date().toISOString(),
+        files: [],
+    });
+    gitBranches.set(MOCK_GIT_DEFAULT_BRANCH, {
+        name: MOCK_GIT_DEFAULT_BRANCH,
+        head: gitInitialCommitHash,
+        isRemote: false,
+        upstream: `origin/${MOCK_GIT_DEFAULT_BRANCH}`,
+    });
+    gitWorktrees.set(MOCK_GIT_MAIN_WORKTREE_PATH, {
+        path: MOCK_GIT_MAIN_WORKTREE_PATH,
+        branch: MOCK_GIT_DEFAULT_BRANCH,
+        isMain: true,
+        staged: [],
+        unstaged: [],
+        untracked: [{ path: 'NOTES.md', status: '?', staged: false }],
+    });
+    const mockPtySessionSummary = (session) => ({
+        id: session.id,
+        shell: session.shell,
+        cwd: session.cwd,
+        cols: session.cols,
+        rows: session.rows,
+        createdAt: session.createdAt,
+        lastActivityAt: session.lastActivityAt,
+    });
+    const emitToPty = (session, event, payload) => {
+        for (const requestId of session.attachedRequestIds)
+            emitEphemeral(requestId, event, payload);
+    };
+    const notifyTerminalSessionChanged = (change) => {
+        for (const requestId of terminalSessionSubscriptions)
+            emit(requestId, 'sessionChanged', change);
+    };
+    const appendPtyScrollback = (session, data) => {
+        const combined = session.scrollback + data;
+        session.scrollback =
+            combined.length > MOCK_TERMINAL_SCROLLBACK_MAX ? combined.slice(combined.length - MOCK_TERMINAL_SCROLLBACK_MAX) : combined;
+    };
+    const closePtySession = (session, exitCode) => {
+        if (session.closed)
+            return;
+        session.closed = true;
+        emitToPty(session, 'exit', { exitCode });
+        session.attachedRequestIds.clear();
+        ptySessions.delete(session.id);
+        notifyTerminalSessionChanged({ kind: 'closed', id: session.id });
+    };
+    const triggerPtyBurst = (session) => {
+        for (let i = 0; i < MOCK_PTY_BURST_CHUNKS; i++) {
+            const chunk = `burst line ${i} (mock)\n`;
+            appendPtyScrollback(session, chunk);
+            emitToPty(session, 'output', { data: chunk });
+        }
+    };
+    const takeToolCall = (callId) => {
+        const call = toolCalls.get(callId);
+        if (!call)
+            return undefined;
+        toolCalls.delete(callId);
+        clearTimeout(call.timer);
+        timers.delete(call.timer);
+        return call;
+    };
+    const retireToolRegistration = (requestId) => {
+        if (!toolRegistrations.delete(requestId))
+            return;
+        for (const pending of [...toolCalls.values()]) {
+            if (pending.registrationId !== requestId)
+                continue;
+            const call = takeToolCall(pending.callId);
+            call?.fail(new MinionryError('APP_UNAVAILABLE', `mock: the app stopped serving '${pending.tool}' before it answered`));
+        }
+    };
+    const sendToolCancel = (callId, registrationId) => {
+        deliver(() => handlers?.onToolCall?.({ op: 'cancel', callId, requestId: registrationId }));
+    };
+    const toolsController = {
+        list: () => [...toolRegistrations.values()].flatMap((registration) => [...registration.tools.values()].map((spec) => ({
+            ...spec,
+            registrationId: registration.requestId,
+            profile: registration.profile,
+        }))),
+        call: (tool, input, opts) => new Promise((resolve, reject) => {
+            const registration = [...toolRegistrations.values()].find((candidate) => candidate.tools.has(tool));
+            const spec = registration?.tools.get(tool);
+            if (!registration || !spec || !handlers?.onToolCall) {
+                reject(new MinionryError('APP_UNAVAILABLE', `mock: no app is serving a tool named '${tool}'`));
+                return;
+            }
+            const callId = `tc-${++toolCallCounter}`;
+            const timeoutMs = Math.min(opts?.timeoutMs ?? spec.timeoutMs ?? MOCK_TOOL_CALL_TIMEOUT_MS, MOCK_TOOL_CALL_TIMEOUT_MAX_MS);
+            const timer = setTimeout(() => {
+                const call = takeToolCall(callId);
+                if (!call)
+                    return;
+                sendToolCancel(callId, registration.requestId);
+                call.fail(new MinionryError('APP_TIMEOUT', `mock: '${tool}' did not answer within ${timeoutMs}ms`));
+            }, timeoutMs);
+            timers.add(timer);
+            toolCalls.set(callId, {
+                callId,
+                registrationId: registration.requestId,
+                tool,
+                settle: resolve,
+                fail: reject,
+                timer,
+            });
+            deliver(() => handlers?.onToolCall?.({ op: 'call', callId, requestId: registration.requestId, tool, input }));
+        }),
+        cancel: (callId) => {
+            const call = takeToolCall(callId);
+            if (!call)
+                return;
+            sendToolCancel(callId, call.registrationId);
+            call.fail(new MinionryError('CANCELLED', `mock: call '${callId}' to '${call.tool}' was cancelled by the host`));
+        },
+    };
+    const qualitySuppressionKey = (path, fingerprint) => `${path}|${fingerprint}`;
+    const stampQualityFindings = (path, findings) => findings.map((finding) => {
+        const entry = finding.fingerprint === undefined ? undefined : qualitySuppressions.get(qualitySuppressionKey(path, finding.fingerprint));
+        return entry ? { ...finding, dismissal: { reason: entry.reason, dismissedAt: entry.dismissedAt } } : { ...finding };
+    });
+    const stampQualityReport = (report) => ({
+        ...report,
+        findings: stampQualityFindings(report.path, report.findings),
+        codeReview: stampQualityFindings(report.path, report.codeReview),
+    });
+    const stampQualityResult = (result) => result.report === null ? result : { ...result, report: stampQualityReport(result.report) };
+    const publishQualityChange = (change) => {
+        const stamped = change.kind === 'results' || change.kind === 'postSession' || change.kind === 'agentTurn'
+            ? { ...change, report: stampQualityReport(change.report) }
+            : change;
+        for (const requestId of qualityChangeSubscriptions)
+            emit(requestId, 'changed', stamped);
+    };
+    const publishQualityAgentTurn = (form) => {
+        const timestamp = new Date().toISOString();
+        const changedFiles = [MOCK_QUALITY_TURN_FILE];
+        if (form === 'worktree') {
+            const report = mockQualityAgentTurnReport(MOCK_QUALITY_ROOT_PATH, timestamp, undefined);
+            publishQualityChange({ kind: 'agentTurn', path: MOCK_QUALITY_ROOT_PATH, worktree: true, changedFiles, report });
+            return;
+        }
+        const baselineAt = qualityReports.get(MOCK_QUALITY_ROOT_PATH)?.timestamp;
+        const report = mockQualityAgentTurnReport(MOCK_QUALITY_ROOT_PATH, timestamp, baselineAt);
+        publishQualityChange({ kind: 'agentTurn', path: MOCK_QUALITY_ROOT_PATH, changedFiles, report });
+    };
+    const qualityPathOf = (value, method) => {
+        if (value === undefined || value === null)
+            return MOCK_QUALITY_ROOT_PATH;
+        const raw = asString(value, 'path', method).trim();
+        if (raw === '')
+            return MOCK_QUALITY_ROOT_PATH;
+        if (raw.startsWith('/') || raw.split('/').includes('..')) {
+            throw new MinionryError('BAD_REQUEST', `${method}: '${raw}' resolves outside the working directory`);
+        }
+        return raw;
+    };
+    const cloneQualitySchedule = (schedule) => ({
+        ...schedule,
+        timing: schedule.timing.kind === 'daily' && schedule.timing.days ? { ...schedule.timing, days: [...schedule.timing.days] } : { ...schedule.timing },
+        ...(schedule.lastFire ? { lastFire: { ...schedule.lastFire } } : {}),
+        history: schedule.history.map((entry) => ({ ...entry })),
+    });
+    const isValidTimeZone = (value) => {
+        if (typeof value !== 'string' || value === '')
+            return false;
+        try {
+            new Intl.DateTimeFormat('en-US', { timeZone: value });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    const qualityTimingOf = (value, method) => {
+        const raw = asRecord(value, method);
+        if (raw.kind === 'interval') {
+            if (typeof raw.everyMs !== 'number' || !Number.isFinite(raw.everyMs) || raw.everyMs <= 0) {
+                throw new MinionryError('BAD_REQUEST', `${method}: timing.everyMs must be a positive number`);
+            }
+            return { kind: 'interval', everyMs: Math.max(raw.everyMs, 60_000) };
+        }
+        if (raw.kind !== 'daily')
+            throw new MinionryError('BAD_REQUEST', `${method}: timing.kind must be 'daily' or 'interval'`);
+        if (typeof raw.time !== 'string' || !/^([01]\d|2[0-3]):[0-5]\d$/.test(raw.time)) {
+            throw new MinionryError('BAD_REQUEST', `${method}: timing.time must be 24-hour HH:MM`);
+        }
+        if (!isValidTimeZone(raw.timeZone))
+            throw new MinionryError('BAD_REQUEST', `${method}: timing.timeZone must be an IANA zone name`);
+        const timing = { kind: 'daily', time: raw.time, timeZone: raw.timeZone };
+        if (raw.days !== undefined) {
+            if (!Array.isArray(raw.days) || raw.days.length === 0 || raw.days.some((day) => !Number.isInteger(day) || day < 0 || day > 6)) {
+                throw new MinionryError('BAD_REQUEST', `${method}: timing.days must be a non-empty array of weekdays 0 (Sunday) … 6 (Saturday)`);
+            }
+            timing.days = [...new Set(raw.days)].sort((a, b) => a - b);
+        }
+        return timing;
+    };
+    const zonedParts = (instant, timeZone) => {
+        const parts = new Intl.DateTimeFormat('en-US', {
+            timeZone,
+            hourCycle: 'h23',
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            weekday: 'short',
+        }).formatToParts(new Date(instant));
+        const read = (type) => parts.find((part) => part.type === type)?.value ?? '0';
+        const weekdays = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+        return {
+            y: Number(read('year')),
+            m: Number(read('month')),
+            d: Number(read('day')),
+            hh: Number(read('hour')) % 24,
+            mm: Number(read('minute')),
+            ss: Number(read('second')),
+            weekday: Math.max(0, weekdays.indexOf(read('weekday'))),
+        };
+    };
+    const zoneOffsetMs = (instant, timeZone) => {
+        const p = zonedParts(instant, timeZone);
+        return Date.UTC(p.y, p.m - 1, p.d, p.hh, p.mm, p.ss) - instant;
+    };
+    const zonedWallTimeToInstant = (y, m, d, hh, mm, timeZone) => {
+        const guess = Date.UTC(y, m - 1, d, hh, mm);
+        const first = guess - zoneOffsetMs(guess, timeZone);
+        const offset = zoneOffsetMs(first, timeZone);
+        return guess - offset;
+    };
+    const nextQualityFireAt = (timing, from) => {
+        if (timing.kind === 'interval')
+            return new Date(from + timing.everyMs).toISOString();
+        const [hh, mm] = timing.time.split(':').map(Number);
+        const today = zonedParts(from, timing.timeZone);
+        for (let offset = 0; offset <= 8; offset++) {
+            const day = new Date(Date.UTC(today.y, today.m - 1, today.d + offset, 12));
+            const candidate = zonedWallTimeToInstant(day.getUTCFullYear(), day.getUTCMonth() + 1, day.getUTCDate(), hh, mm, timing.timeZone);
+            if (candidate <= from)
+                continue;
+            if (timing.days && !timing.days.includes(zonedParts(candidate, timing.timeZone).weekday))
+                continue;
+            return new Date(candidate).toISOString();
+        }
+        return new Date(from + 7 * 24 * 60 * 60 * 1000).toISOString();
+    };
+    const publishQualitySchedules = () => {
+        publishQualityChange({ kind: 'schedules', schedules: qualitySchedules.map(cloneQualitySchedule) });
+    };
+    const qualityScheduleById = (value, method) => {
+        const id = asString(value, 'scheduleId', method);
+        const schedule = qualitySchedules.find((entry) => entry.id === id);
+        if (!schedule)
+            throw new MinionryError('BAD_REQUEST', `${method}: schedule '${id}' not found in this Space`);
+        return schedule;
+    };
+    const qualityToolState = (path) => {
+        let installed = qualityInstalledTools.get(path);
+        if (!installed) {
+            installed = new Set(MOCK_QUALITY_TOOLS.filter((tool) => tool.installed).map((tool) => tool.name));
+            qualityInstalledTools.set(path, installed);
+        }
+        return installed;
+    };
+    const qualityToolsFor = (path) => {
+        if (path === MOCK_QUALITY_NA_PATH)
+            return { path, tools: [], ecosystem: [] };
+        const installed = qualityToolState(path);
+        return {
+            path,
+            tools: MOCK_QUALITY_TOOLS.map((tool) => ({ ...tool, installed: installed.has(tool.name) })),
+            ecosystem: [...MOCK_QUALITY_ECOSYSTEM],
+        };
+    };
+    const emitToQualityRun = (run, event, payload) => {
+        for (const requestId of run.requestIds)
+            emit(requestId, event, payload);
+    };
+    const settleQualityWaiters = (run, result) => {
+        const stamped = stampQualityResult(result);
+        for (const waiter of run.waiters)
+            respond(waiter, stamped);
+        run.waiters = [];
+    };
+    const qualityRunSteps = (startedAt, sessionId) => {
+        const script = [
+            ['detecting', 'Detecting tools', undefined],
+            ['scanning', 'Running quality checks', 'tsc --noEmit, 18s elapsed'],
+            ['reviewing', 'AI deep review', 'reviewing 3 of 5 files'],
+            ['complete', 'Complete', undefined],
+        ];
+        return script.flatMap(([phase, step, detail], index) => {
+            const withSession = phase === 'reviewing' && sessionId !== undefined ? { sessionId } : {};
+            return [
+                { event: 'phase', phase, payload: { phase, ...withSession } },
+                ...(phase === 'reviewing' && sessionId !== undefined
+                    ? [{ event: 'session', phase, payload: { sessionId } }]
+                    : []),
+                {
+                    event: 'progress',
+                    phase,
+                    payload: {
+                        phase,
+                        step,
+                        current: index + 1,
+                        total: script.length,
+                        ...(detail === undefined ? {} : { detail }),
+                        etaMs: 138_000,
+                        startedAt,
+                        ...withSession,
+                    },
+                },
+            ];
+        });
+    };
+    const finishQualityRun = (run) => {
+        const partial = run.path === MOCK_QUALITY_PARTIAL_PATH;
+        const timestamp = new Date().toISOString();
+        const previous = qualityReports.get(run.path);
+        const baselineAt = previous?.findings.some((finding) => finding.fingerprint !== undefined)
+            ? previous.timestamp
+            : undefined;
+        const baseReport = run.path === MOCK_QUALITY_NA_PATH
+            ? mockQualityNaReport(run.path, timestamp)
+            : mockQualityReport(run.path, timestamp, !partial, baselineAt);
+        const report = !partial && run.sessionId !== undefined ? { ...baseReport, reviewSessionId: run.sessionId } : baseReport;
+        qualityReports.set(run.path, report);
+        qualityHistory.push(mockQualityHistoryEntry(report));
+        run.status = partial ? 'partial' : 'ok';
+        const result = {
+            path: run.path,
+            status: run.status,
+            report,
+            ...(run.sessionId !== undefined ? { sessionId: run.sessionId } : {}),
+            legs: partial
+                ? {
+                    scan: { status: 'ok' },
+                    review: {
+                        status: 'failed',
+                        code: 'CLAUDE_NOT_INSTALLED',
+                        message: `mock: no coding-agent binary for '${run.path}' — the scan leg still produced a report`,
+                        sessionId: run.sessionId,
+                    },
+                }
+                : { scan: { status: 'ok' }, review: { status: 'ok', sessionId: run.sessionId } },
+        };
+        qualityResults.set(run.path, result);
+        qualityRunsByPath.delete(run.path);
+        settleQualityWaiters(run, result);
+        publishQualityChange({ kind: 'results', path: run.path, report });
+    };
+    const advanceQualityRun = (run) => {
+        if (run.status !== 'running')
+            return;
+        const step = run.steps.shift();
+        if (!step) {
+            finishQualityRun(run);
+            return;
+        }
+        if (step.event === 'phase')
+            run.kind = step.phase === 'reviewing' ? 'reviewing' : 'scanning';
+        emitToQualityRun(run, step.event, step.payload);
+        later(() => advanceQualityRun(run));
+    };
+    const cancelQualityRun = (run) => {
+        if (run.status !== 'running')
+            return;
+        run.status = 'cancelled';
+        run.steps = [];
+        const result = {
+            path: run.path,
+            status: 'cancelled',
+            report: qualityReports.get(run.path) ?? null,
+            legs: { scan: { status: 'skipped' }, review: { status: 'skipped' } },
+        };
+        qualityResults.set(run.path, result);
+        qualityRunsByPath.delete(run.path);
+        settleQualityWaiters(run, result);
+    };
+    const DEFER = Symbol('mock-defer');
+    const methodHandlers = {
+        features: () => [...MOCK_FEATURES],
+        connect: (params) => {
+            const scopes = asRecord(params, 'connect').scopes;
+            if (!Array.isArray(scopes) || scopes.some((scope) => typeof scope !== 'string')) {
+                throw new MinionryError('BAD_REQUEST', 'connect: scopes must be an array of scope strings');
+            }
+            const requested = [...new Set(scopes)];
+            for (const scope of requested) {
+                if (SCOPES.includes(scope) && !denied.has(scope)) {
+                    granted.add(scope);
+                }
+            }
+            return {
+                space: { ...space },
+                user: user === null ? null : { ...user },
+                grants: requested.filter((scope) => granted.has(scope)),
+                viewOnly: user === null,
+            };
+        },
+        disconnect: () => {
+            granted.clear();
+            for (const board of boards.values())
+                board.subscribers.clear();
+            for (const requestId of subscriptions.keys()) {
+                streamSeq.delete(requestId);
+                streamLog.delete(requestId);
+            }
+            subscriptions.clear();
+            for (const requestId of fileChangeSubscriptions.keys()) {
+                streamSeq.delete(requestId);
+                streamLog.delete(requestId);
+            }
+            fileChangeSubscriptions.clear();
+            for (const requestId of browserTabSubscriptions) {
+                streamSeq.delete(requestId);
+                streamLog.delete(requestId);
+            }
+            browserTabSubscriptions.clear();
+            for (const run of automations.values()) {
+                run.status = 'cancelled';
+                run.pendingProposalId = null;
+                run.steps = [];
+                streamSeq.delete(run.requestId);
+                streamLog.delete(run.requestId);
+            }
+            automations.clear();
+            for (const view of [...views.values()])
+                retireView(view);
+            for (const requestId of gitWorktreeSubscriptions) {
+                streamSeq.delete(requestId);
+                streamLog.delete(requestId);
+            }
+            gitWorktreeSubscriptions.clear();
+            for (const requestId of gitBranchChangeSubscriptions) {
+                streamSeq.delete(requestId);
+                streamLog.delete(requestId);
+            }
+            gitBranchChangeSubscriptions.clear();
+            for (const requestId of terminalSessionSubscriptions) {
+                streamSeq.delete(requestId);
+                streamLog.delete(requestId);
+            }
+            terminalSessionSubscriptions.clear();
+            for (const [requestId, session] of ptyAttachByRequestId) {
+                session.attachedRequestIds.delete(requestId);
+                streamSeq.delete(requestId);
+            }
+            ptyAttachByRequestId.clear();
+            for (const requestId of qualityChangeSubscriptions) {
+                streamSeq.delete(requestId);
+                streamLog.delete(requestId);
+            }
+            qualityChangeSubscriptions.clear();
+            for (const [requestId, run] of qualityRunsByRequestId) {
+                run.requestIds.delete(requestId);
+                streamSeq.delete(requestId);
+                streamLog.delete(requestId);
+            }
+            qualityRunsByRequestId.clear();
+            for (const requestId of [...toolRegistrations.keys()])
+                retireToolRegistration(requestId);
+            notify('disconnect');
+            return null;
+        },
+        'auth.getToken': () => `mock-token-${space.id}`,
+        'agents.run': (params, requestId) => {
+            const { prompt, title, model, sessionId: continuedId } = runParams(params);
+            let session;
+            let endpoint;
+            if (continuedId !== undefined) {
+                session = runSessions.get(continuedId);
+                if (!session) {
+                    throw new MinionryError('BAD_REQUEST', `unknown sessionId '${continuedId}' — agents.run continues only an open session this app started with agents.run in this Space`);
+                }
+                if (session.run.status === 'running') {
+                    throw new MinionryError('BAD_REQUEST', `session_busy: session '${session.id}' is still running a turn — wait for its result() before continuing it`);
+                }
+                if (session.modelValue !== undefined)
+                    endpoint = admitEndpointModel(session.modelValue);
+            }
+            else if (model !== undefined) {
+                endpoint = admitEndpointModel(model);
+            }
+            const turn = (session?.turns ?? 0) + 1;
+            const runNumber = ++seq;
+            const runId = `run-mock-${runNumber}`;
+            const sessionId = session?.id ?? `session-mock-${++seq}`;
+            const startedAtIso = new Date().toISOString();
+            const tab = sessions.get(sessionId);
+            if (tab) {
+                tab.isExecuting = true;
+                tab.lastActivityAt = startedAtIso;
+            }
+            else {
+                sessions.set(sessionId, {
+                    id: sessionId,
+                    name: title?.trim() || `Run ${runNumber}`,
+                    createdAt: startedAtIso,
+                    lastActivityAt: startedAtIso,
+                    isExecuting: true,
+                    entries: [],
+                    seq: 0,
+                });
+            }
+            const startedAt = Date.now();
+            const run = {
+                runId,
+                requestId,
+                sessionId,
+                status: 'running',
+                text: '',
+                steps: endpoint ? endpointRunSteps(endpoint, prompt, turn) : [
+                    { event: 'status', payload: { status: 'running' } },
+                    {
+                        event: 'timelineEvent',
+                        payload: { kind: 'status', at: startedAt, executing: true, turn },
+                    },
+                    {
+                        event: 'timelineEvent',
+                        payload: {
+                            kind: 'thinking',
+                            at: startedAt,
+                            entryId: 'mock-thinking-1',
+                            delta: 'Reviewing the request (mock)...',
+                        },
+                    },
+                    { event: 'toolUse', payload: { tool: 'plan', input: { prompt } } },
+                    {
+                        event: 'timelineEvent',
+                        payload: {
+                            kind: 'tool_use',
+                            at: startedAt,
+                            entryId: 'mock-tool-1',
+                            toolName: 'plan',
+                            input: { prompt },
+                        },
+                    },
+                    {
+                        event: 'timelineEvent',
+                        payload: {
+                            kind: 'tool_result',
+                            at: startedAt,
+                            entryId: 'mock-tool-1',
+                            ok: true,
+                            result: 'Planned (mock).',
+                        },
+                    },
+                    { event: 'output', payload: { text: `Working on: ${prompt}\n` } },
+                    {
+                        event: 'timelineEvent',
+                        payload: {
+                            kind: 'text',
+                            at: startedAt,
+                            entryId: 'mock-text-1',
+                            delta: `Working on: ${prompt}\n`,
+                        },
+                    },
+                    { event: 'output', payload: { text: 'Done (mock).' } },
+                    {
+                        event: 'timelineEvent',
+                        payload: { kind: 'text', at: startedAt, entryId: 'mock-text-1', delta: 'Done (mock).' },
+                    },
+                    {
+                        event: 'timelineEvent',
+                        payload: {
+                            kind: 'tokens',
+                            at: startedAt,
+                            usage: {
+                                inputTokens: 120,
+                                outputTokens: 48,
+                                cacheCreationTokens: 0,
+                                cacheReadTokens: 0,
+                                currentTurnInputTokens: 120,
+                                isFinal: true,
+                            },
+                        },
+                    },
+                    {
+                        event: 'timelineEvent',
+                        payload: { kind: 'status', at: startedAt, executing: false, turn },
+                    },
+                ],
+                waiters: [],
+                ...(prompt.trim() === MOCK_QUALITY_AGENT_TURN_PROMPT
+                    ? { agentTurn: 'directory' }
+                    : prompt.trim() === MOCK_QUALITY_WORKTREE_TURN_PROMPT
+                        ? { agentTurn: 'worktree' }
+                        : {}),
+            };
+            runsByRequestId.set(requestId, run);
+            runsByRunId.set(runId, run);
+            if (session) {
+                session.turns = turn;
+                session.run = run;
+            }
+            else {
+                session = { id: sessionId, turns: turn, run, ...(endpoint ? { modelValue: endpoint.modelValue } : {}) };
+                runSessions.set(session.id, session);
+            }
+            later(() => advanceRun(run));
+            return { runId, sessionId };
+        },
+        'agents.result': (params, requestId) => {
+            const runId = asString(asRecord(params, 'agents.result').runId, 'runId', 'agents.result');
+            const run = runsByRunId.get(runId);
+            if (!run)
+                throw new MinionryError('BAD_REQUEST', `agents.result: unknown runId '${runId}'`);
+            if (run.status === 'running') {
+                run.waiters.push(requestId);
+                return DEFER;
+            }
+            const result = { status: run.status, text: run.text };
+            return result;
+        },
+        'inference.chat': (params, requestId) => {
+            const record = asRecord(params, 'inference.chat');
+            const messages = mockInferenceMessages(record.messages);
+            if (record.system !== undefined && (typeof record.system !== 'string' || record.system.length > 32_000)) {
+                throw new MinionryError('BAD_REQUEST', 'inference.chat: system must be a string of at most 32000 characters');
+            }
+            const engine = record.engine === undefined || record.engine === null ? undefined : asString(record.engine, 'engine', 'inference.chat');
+            if (engine !== undefined && !MOCK_ENGINES.includes(engine)) {
+                throw new MinionryError('BAD_REQUEST', `inference.chat: unknown engine '${engine}' — expected one of ${MOCK_ENGINES.join(', ')}`);
+            }
+            const model = record.model === undefined || record.model === null ? undefined : asString(record.model, 'model', 'inference.chat');
+            if (model === '')
+                throw new MinionryError('BAD_REQUEST', 'inference.chat: model must be a non-empty string when present');
+            const resolvedEngine = engine ?? (model ? mockEngineForModel(model) : MOCK_DEFAULT_ENGINE);
+            if (model && mockEngineForModel(model) !== resolvedEngine) {
+                throw new MinionryError('BAD_REQUEST', `inference.chat: model '${model}' is not a ${resolvedEngine} model — it belongs to ${mockEngineForModel(model)}`);
+            }
+            if (!MOCK_INFERENCE_ENGINES.includes(resolvedEngine)) {
+                throw new MinionryError('UNSUPPORTED', `inference.chat: ${resolvedEngine} cannot run a tool-less completion on this host`);
+            }
+            const effortLevel = record.effortLevel === undefined || record.effortLevel === null
+                ? undefined
+                : asString(record.effortLevel, 'effortLevel', 'inference.chat');
+            if (effortLevel !== undefined && effortLevel !== 'auto' && !MOCK_EFFORT_LEVELS[resolvedEngine]?.includes(effortLevel)) {
+                throw new MinionryError('BAD_REQUEST', `inference.chat: '${effortLevel}' is not a ${resolvedEngine} effort level`);
+            }
+            const resolvedModel = model ?? (mockEngineForModel(MOCK_DEFAULT_MODEL) === resolvedEngine ? MOCK_DEFAULT_MODEL : undefined);
+            const prompt = messages[messages.length - 1]?.content.trim() ?? '';
+            const runId = `inference-mock-${++seq}`;
+            const run = {
+                runId,
+                requestId,
+                status: 'running',
+                engine: resolvedEngine,
+                ...(resolvedModel ? { model: resolvedModel } : {}),
+                text: '',
+                deltas: [
+                    `(mock ${resolvedEngine}${resolvedModel ? ` · ${resolvedModel}` : ''}) `,
+                    prompt.length > 120 ? `${prompt.slice(0, 119)}…` : prompt,
+                ],
+                waiters: [],
+            };
+            inferenceRunsByRequestId.set(requestId, run);
+            inferenceRunsByRunId.set(runId, run);
+            later(() => {
+                if (run.status !== 'running')
+                    return;
+                emit(requestId, 'status', { status: 'running' });
+                advanceInferenceRun(run);
+            });
+            return { runId };
+        },
+        'inference.result': (params, requestId) => {
+            const runId = asString(asRecord(params, 'inference.result').runId, 'runId', 'inference.result');
+            const run = inferenceRunsByRunId.get(runId);
+            if (!run)
+                throw new MinionryError('BAD_REQUEST', `inference.result: unknown runId '${runId}'`);
+            if (run.status === 'running') {
+                run.waiters.push(requestId);
+                return DEFER;
+            }
+            return inferenceResultOf(run);
+        },
+        'endpoints.register': (params) => {
+            const record = strictRecord(params, 'endpoints.register', MOCK_ENDPOINT_REGISTER_SHAPE, MOCK_ENDPOINT_REGISTER_KEYS);
+            const id = endpointId(record.id, 'endpoints.register');
+            const label = endpointText(record.label, 'label', MOCK_ENDPOINT_LABEL_CHARS);
+            if (typeof record.engine !== 'string' || !MOCK_ENDPOINT_ENGINES.includes(record.engine)) {
+                throw new MinionryError('BAD_REQUEST', `endpoints.register: engine must be one of ${MOCK_ENDPOINT_ENGINES.join(', ')}`);
+            }
+            const { baseUrl, apiKey } = record;
+            if (typeof baseUrl !== 'string' || utf8ByteLength(baseUrl) > MOCK_ENDPOINT_URL_BYTES) {
+                throw new MinionryError('BAD_REQUEST', `endpoints.register: baseUrl must be a string of at most ${MOCK_ENDPOINT_URL_BYTES} bytes`);
+            }
+            if (typeof apiKey !== 'string' ||
+                apiKey === '' ||
+                utf8ByteLength(apiKey) > MOCK_ENDPOINT_API_KEY_BYTES ||
+                MOCK_WHITESPACE_OR_CONTROL.test(apiKey)) {
+                throw new MinionryError('BAD_REQUEST', `endpoints.register: apiKey is required — a string of at most ${MOCK_ENDPOINT_API_KEY_BYTES} bytes, without whitespace or control characters`);
+            }
+            const model = endpointText(record.model, 'model', MOCK_ENDPOINT_MODEL_CHARS);
+            const contextLength = optionalPositiveInteger(record.contextLength, 'contextLength');
+            const ttlMs = Math.min(optionalPositiveInteger(record.ttlMs, 'ttlMs') ?? MOCK_ENDPOINT_DEFAULT_TTL_MS, AGENT_RUN_LIMITS.maxTtlMs);
+            const verdict = mockValidateEndpointUrl(baseUrl);
+            if (!verdict.ok)
+                throw new MinionryError('ENDPOINT_INVALID', `endpoints.register: baseUrl ${verdict.reason}`);
+            const now = Date.now();
+            const others = [...endpoints.values()].filter((candidate) => candidate.id !== id && isLiveEndpoint(candidate, now));
+            if (others.length >= AGENT_RUN_LIMITS.endpointsPerApp) {
+                throw new MinionryError('QUOTA_EXCEEDED', `endpoints.register: this app already holds ${AGENT_RUN_LIMITS.endpointsPerApp} endpoints in this Space — unregister one first`);
+            }
+            const registered = {
+                id,
+                label,
+                engine: 'hermes',
+                modelValue: `custom:${record.engine}:app-${MOCK_ENDPOINT_APP_ID}-${id}`,
+                model,
+                ...(contextLength !== undefined ? { contextLength } : {}),
+                expiresAt: new Date(now + ttlMs).toISOString(),
+            };
+            endpoints.set(id, registered);
+            return { ...registered };
+        },
+        'endpoints.unregister': (params) => {
+            const record = strictRecord(params, 'endpoints.unregister', '{ id }', new Set(['id']));
+            const id = endpointId(record.id, 'endpoints.unregister');
+            const endpoint = endpoints.get(id);
+            if (!endpoint) {
+                throw new MinionryError('BAD_REQUEST', `unknown endpoint id '${id}' — endpoints.unregister removes only this app's endpoints in this Space`);
+            }
+            endpoints.delete(id);
+            for (const session of runSessions.values()) {
+                if (session.modelValue === endpoint.modelValue)
+                    cancelRun(session.run);
+            }
+            return null;
+        },
+        'endpoints.list': () => {
+            const now = Date.now();
+            return [...endpoints.values()].filter((endpoint) => isLiveEndpoint(endpoint, now)).map((endpoint) => ({ ...endpoint }));
+        },
+        'agents.sessions.list': () => [...sessions.values()].map(mockSessionSummary),
+        'agents.sessions.create': (params) => {
+            const record = asRecord(params, 'agents.sessions.create');
+            const name = typeof record.name === 'string' ? record.name : undefined;
+            const id = `session-mock-${++seq}`;
+            const now = new Date().toISOString();
+            const session = {
+                id,
+                name: name ?? `Session ${sessions.size + 1}`,
+                createdAt: now,
+                lastActivityAt: now,
+                isExecuting: false,
+                entries: [],
+                seq: 0,
+            };
+            sessions.set(id, session);
+            return mockSessionSummary(session);
+        },
+        'agents.sessions.attach': (params) => {
+            const sessionId = asString(asRecord(params, 'agents.sessions.attach').sessionId, 'sessionId', 'agents.sessions.attach');
+            const session = sessions.get(sessionId);
+            if (!session)
+                throw new MinionryError('BAD_REQUEST', `agents.sessions.attach: unknown sessionId '${sessionId}'`);
+            return mockSessionSummary(session);
+        },
+        'agents.sessions.close': (params) => {
+            const sessionId = asString(asRecord(params, 'agents.sessions.close').sessionId, 'sessionId', 'agents.sessions.close');
+            if (!sessions.delete(sessionId)) {
+                throw new MinionryError('BAD_REQUEST', `agents.sessions.close: unknown sessionId '${sessionId}'`);
+            }
+            return null;
+        },
+        'agents.sessions.rename': (params) => {
+            const record = asRecord(params, 'agents.sessions.rename');
+            const sessionId = asString(record.sessionId, 'sessionId', 'agents.sessions.rename');
+            const session = sessions.get(sessionId);
+            if (!session)
+                throw new MinionryError('BAD_REQUEST', `agents.sessions.rename: unknown sessionId '${sessionId}'`);
+            session.name = asString(record.name, 'name', 'agents.sessions.rename');
+            return mockSessionSummary(session);
+        },
+        'agents.sessions.history': (params) => {
+            const sessionId = asString(asRecord(params, 'agents.sessions.history').sessionId, 'sessionId', 'agents.sessions.history');
+            const session = sessions.get(sessionId);
+            if (!session)
+                throw new MinionryError('BAD_REQUEST', `agents.sessions.history: unknown sessionId '${sessionId}'`);
+            return { sessionId, entries: [...session.entries], seq: session.seq };
+        },
+        'agents.sessions.replay': (params) => {
+            const record = asRecord(params, 'agents.sessions.replay');
+            const sessionId = asString(record.sessionId, 'sessionId', 'agents.sessions.replay');
+            const session = sessions.get(sessionId);
+            if (!session)
+                throw new MinionryError('BAD_REQUEST', `agents.sessions.replay: unknown sessionId '${sessionId}'`);
+            const afterSeq = record.afterSeq;
+            if (typeof afterSeq !== 'number' || !Number.isInteger(afterSeq) || afterSeq < 0) {
+                throw new MinionryError('BAD_REQUEST', 'agents.sessions.replay: afterSeq must be a non-negative integer');
+            }
+            return { sessionId, fromSeq: afterSeq, events: [], currentSeq: session.seq };
+        },
+        'agents.sessions.approve': (params) => {
+            const record = asRecord(params, 'agents.sessions.approve');
+            const sessionId = asString(record.sessionId, 'sessionId', 'agents.sessions.approve');
+            if (typeof record.approved !== 'boolean') {
+                throw new MinionryError('BAD_REQUEST', 'agents.sessions.approve: approved must be a boolean');
+            }
+            if (!sessions.has(sessionId)) {
+                throw new MinionryError('BAD_REQUEST', `agents.sessions.approve: unknown sessionId '${sessionId}'`);
+            }
+            return null;
+        },
+        'agents.sessions.answerQuestion': (params) => {
+            const record = asRecord(params, 'agents.sessions.answerQuestion');
+            const sessionId = asString(record.sessionId, 'sessionId', 'agents.sessions.answerQuestion');
+            asString(record.toolUseId, 'toolUseId', 'agents.sessions.answerQuestion');
+            if (typeof record.answers !== 'object' || record.answers === null || Array.isArray(record.answers)) {
+                throw new MinionryError('BAD_REQUEST', 'agents.sessions.answerQuestion: answers must be an object');
+            }
+            if (!sessions.has(sessionId)) {
+                throw new MinionryError('BAD_REQUEST', `agents.sessions.answerQuestion: unknown sessionId '${sessionId}'`);
+            }
+            return null;
+        },
+        'agents.sessions.prompt': (params) => {
+            const record = asRecord(params, 'agents.sessions.prompt');
+            const sessionId = asString(record.sessionId, 'sessionId', 'agents.sessions.prompt');
+            const prompt = asString(record.prompt, 'prompt', 'agents.sessions.prompt');
+            const attachments = Array.isArray(record.attachments)
+                ? record.attachments.map((ref, i) => {
+                    const path = asString(ref?.path, 'path', `agents.sessions.prompt attachments[${i}]`);
+                    return { fileName: path.split('/').pop() ?? path, isImage: false };
+                })
+                : undefined;
+            const session = sessions.get(sessionId);
+            if (!session)
+                throw new MinionryError('BAD_REQUEST', `agents.sessions.prompt: unknown sessionId '${sessionId}'`);
+            const now = new Date().toISOString();
+            session.lastActivityAt = now;
+            session.entries.push({
+                id: `entry-${sessionId}-${++session.seq}`,
+                kind: 'user',
+                at: Date.now(),
+                text: prompt,
+                ...(attachments ? { attachments } : {}),
+            });
+            session.entries.push({
+                id: `entry-${sessionId}-${++session.seq}`,
+                kind: 'text',
+                at: Date.now(),
+                text: `Working on: ${prompt} (mock)`,
+                open: false,
+            });
+            return { queued: false };
+        },
+        'agents.sessions.stop': (params) => {
+            const sessionId = asString(asRecord(params, 'agents.sessions.stop').sessionId, 'sessionId', 'agents.sessions.stop');
+            const session = sessions.get(sessionId);
+            if (!session)
+                throw new MinionryError('BAD_REQUEST', `agents.sessions.stop: unknown sessionId '${sessionId}'`);
+            session.isExecuting = false;
+            return null;
+        },
+        'apps.open': (params) => {
+            const record = asRecord(params, 'apps.open');
+            const app = asString(record.app, 'app', 'apps.open');
+            if (granted.size === 0) {
+                throw new MinionryError('SCOPE_DENIED', 'apps.open: no connected app session — call connect() first');
+            }
+            if (app === 'agents') {
+                const openParams = record.params;
+                if (typeof openParams !== 'object' || openParams === null || Array.isArray(openParams)) {
+                    throw new MinionryError('BAD_REQUEST', "apps.open: 'params' must be an object for the 'agents' target");
+                }
+                const sessionId = asString(openParams.sessionId, 'params.sessionId', 'apps.open');
+                const known = sessions.has(sessionId) ||
+                    runSessions.has(sessionId) ||
+                    [...automations.values()].some((run) => run.target.sessionId === sessionId) ||
+                    [...qualityRunsByPath.values()].some((run) => run.sessionId === sessionId) ||
+                    [...qualityResults.values()].some((result) => result.sessionId === sessionId) ||
+                    [...qualityReports.values()].some((report) => report.reviewSessionId === sessionId);
+                if (!known)
+                    throw new MinionryError('BAD_REQUEST', `apps.open: unknown sessionId '${sessionId}'`);
+                return null;
+            }
+            if (app === 'browser') {
+                if (!granted.has('browser:read')) {
+                    throw new MinionryError('SCOPE_DENIED', "apps.open: the 'browser' target requires scope 'browser:read'");
+                }
+                const openParams = record.params;
+                if (typeof openParams !== 'object' || openParams === null || Array.isArray(openParams)) {
+                    throw new MinionryError('BAD_REQUEST', "apps.open: 'params' must be an object for the 'browser' target");
+                }
+                const tabId = asString(openParams.tabId, 'params.tabId', 'apps.open');
+                if (tabId === '') {
+                    throw new MinionryError('BAD_REQUEST', "apps.open: 'params.tabId' must be a non-empty string");
+                }
+                currentTabId = requireBrowserTab(tabId, 'apps.open').id;
+                publishBrowserTabs();
+                return null;
+            }
+            if (app !== 'files') {
+                throw new MinionryError('SCOPE_DENIED', `apps.open: unknown app '${app}' (fail closed)`);
+            }
+            if (!granted.has('files:workspace:read')) {
+                throw new MinionryError('SCOPE_DENIED', "apps.open: the 'files' target requires scope 'files:workspace:read'");
+            }
+            const openParams = record.params;
+            if (typeof openParams !== 'object' || openParams === null || Array.isArray(openParams)) {
+                throw new MinionryError('BAD_REQUEST', "apps.open: 'params' must be an object for the 'files' target");
+            }
+            const path = asString(openParams.path, 'params.path', 'apps.open');
+            if (!path.startsWith('workspace:/')) {
+                throw new MinionryError('BAD_REQUEST', "apps.open: 'params.path' must use canonical workspace addressing ('workspace:/…')");
+            }
+            const line = openParams.line;
+            if (line !== undefined && (typeof line !== 'number' || !Number.isInteger(line) || line < 1)) {
+                throw new MinionryError('BAD_REQUEST', "apps.open: 'params.line' must be a positive integer");
+            }
+            return null;
+        },
+        cancel: (params) => {
+            const requestId = asString(asRecord(params, 'cancel').requestId, 'requestId', 'cancel');
+            const run = runsByRequestId.get(requestId);
+            if (run) {
+                cancelRun(run);
+                return null;
+            }
+            const inferenceRun = inferenceRunsByRequestId.get(requestId);
+            if (inferenceRun) {
+                cancelInferenceRun(inferenceRun);
+                return null;
+            }
+            const board = subscriptions.get(requestId);
+            if (board) {
+                subscriptions.delete(requestId);
+                board.subscribers.delete(requestId);
+                streamSeq.delete(requestId);
+                streamLog.delete(requestId);
+                return null;
+            }
+            const execRun = execRunsByRequestId.get(requestId);
+            if (execRun) {
+                execRun.requestIds.delete(requestId);
+                execRunsByRequestId.delete(requestId);
+                streamSeq.delete(requestId);
+                streamLog.delete(requestId);
+            }
+            if (fileChangeSubscriptions.delete(requestId)) {
+                streamSeq.delete(requestId);
+                streamLog.delete(requestId);
+            }
+            if (browserTabSubscriptions.delete(requestId)) {
+                streamSeq.delete(requestId);
+                streamLog.delete(requestId);
+            }
+            const automation = automations.get(requestId);
+            if (automation) {
+                automation.status = 'cancelled';
+                automation.pendingProposalId = null;
+                automation.steps = [];
+                automations.delete(requestId);
+                streamSeq.delete(requestId);
+                streamLog.delete(requestId);
+            }
+            const view = views.get(requestId);
+            if (view)
+                retireView(view);
+            if (gitWorktreeSubscriptions.delete(requestId)) {
+                streamSeq.delete(requestId);
+                streamLog.delete(requestId);
+            }
+            if (gitBranchChangeSubscriptions.delete(requestId)) {
+                streamSeq.delete(requestId);
+                streamLog.delete(requestId);
+            }
+            if (gitCommitSuggestionSubscriptions.delete(requestId)) {
+                streamSeq.delete(requestId);
+                streamLog.delete(requestId);
+            }
+            if (terminalSessionSubscriptions.delete(requestId)) {
+                streamSeq.delete(requestId);
+                streamLog.delete(requestId);
+            }
+            const ptySession = ptyAttachByRequestId.get(requestId);
+            if (ptySession) {
+                ptySession.attachedRequestIds.delete(requestId);
+                ptyAttachByRequestId.delete(requestId);
+                streamSeq.delete(requestId);
+            }
+            if (qualityChangeSubscriptions.delete(requestId)) {
+                streamSeq.delete(requestId);
+                streamLog.delete(requestId);
+            }
+            const qualityRun = qualityRunsByRequestId.get(requestId);
+            if (qualityRun) {
+                qualityRun.requestIds.delete(requestId);
+                qualityRunsByRequestId.delete(requestId);
+                streamSeq.delete(requestId);
+                streamLog.delete(requestId);
+            }
+            retireToolRegistration(requestId);
+            return null;
+        },
+        'pm.createBoard': (params) => {
+            const prompt = asString(asRecord(params, 'pm.createBoard').prompt, 'prompt', 'pm.createBoard');
+            const boardId = `board-mock-${++seq}`;
+            const board = {
+                boardId,
+                title: prompt.trim().slice(0, 60) || 'Mock board',
+                goal: prompt.trim() || 'Mock board',
+                status: 'active',
+                statuses: [...BOARD_STATUSES],
+                issues: [
+                    mockIssue('IS-1', 'Plan', 'P1'),
+                    mockIssue('IS-2', 'Implement', 'P1'),
+                    mockIssue('IS-3', 'Verify', 'P2'),
+                ],
+                subscribers: new Set(),
+                createdAt: new Date().toISOString(),
+                completedAt: null,
+            };
+            boards.set(boardId, board);
+            later(() => progressBoard(board));
+            return { boardId };
+        },
+        'pm.listBoards': () => Array.from(boards.values()).map(boardSummary),
+        'pm.getBoard': (params) => {
+            const boardId = asString(asRecord(params, 'pm.getBoard').boardId, 'boardId', 'pm.getBoard');
+            const board = boards.get(boardId);
+            if (!board)
+                throw new MinionryError('BAD_REQUEST', `pm.getBoard: unknown boardId '${boardId}'`);
+            return boardSnapshot(board);
+        },
+        'pm.createIssue': (params) => {
+            const method = 'pm.createIssue';
+            const { board, raw } = requireBoard(params, method);
+            const title = asString(raw.title, 'title', method);
+            const type = raw.type === undefined ? 'issue' : asString(raw.type, 'type', method);
+            const prefix = MOCK_ID_PREFIXES[type];
+            if (!prefix) {
+                throw new MinionryError('BAD_REQUEST', `${method}: 'type' must be one of ${Object.keys(MOCK_ID_PREFIXES).join(', ')}`);
+            }
+            const issue = mockIssue(nextIssueId(board, prefix), title, 'P2');
+            issue.type = type;
+            if (raw.description !== undefined)
+                issue.description = asString(raw.description, 'description', method);
+            if (raw.acceptanceCriteria !== undefined) {
+                issue.acceptanceCriteria = asStringList(raw.acceptanceCriteria, 'acceptanceCriteria', method).map((text) => ({
+                    text,
+                    checked: false,
+                }));
+            }
+            applyIssuePatch(board, issue, raw, method);
+            board.issues.push(issue);
+            publishBoard(board);
+            return { ...issue };
+        },
+        'pm.updateIssue': (params) => {
+            const method = 'pm.updateIssue';
+            const { board, raw } = requireBoard(params, method);
+            const issue = requireIssue(board, asString(raw.issueId, 'issueId', method), method);
+            applyIssuePatch(board, issue, raw.fields, method);
+            issue.updated = MOCK_ISSUE_CREATED;
+            publishBoard(board);
+            return { ...issue };
+        },
+        'pm.deleteIssue': (params) => {
+            const method = 'pm.deleteIssue';
+            const { board, raw } = requireBoard(params, method);
+            const issueId = asString(raw.issueId, 'issueId', method);
+            requireIssue(board, issueId, method);
+            board.issues = board.issues.filter((candidate) => candidate.id !== issueId);
+            publishBoard(board);
+            return { deleted: true, issueId };
+        },
+        'pm.updateBoard': (params) => {
+            const method = 'pm.updateBoard';
+            const { board, raw } = requireBoard(params, method);
+            const fields = asRecord(raw.fields, method);
+            if (fields.title !== undefined)
+                board.title = asString(fields.title, 'title', method);
+            if (fields.goal !== undefined)
+                board.goal = asString(fields.goal, 'goal', method);
+            if (fields.status !== undefined) {
+                const status = asString(fields.status, 'status', method);
+                if (status !== 'draft' && status !== 'active' && status !== 'completed') {
+                    throw new MinionryError('BAD_REQUEST', `${method}: 'status' must be draft, active, or completed`);
+                }
+                board.status = status;
+            }
+            publishBoard(board);
+            return boardSummary(board);
+        },
+        'pm.execute': (params, requestId) => {
+            const boardId = asString(asRecord(params, 'pm.execute').boardId, 'boardId', 'pm.execute');
+            const board = boards.get(boardId);
+            if (!board)
+                throw new MinionryError('BAD_REQUEST', `pm.execute: unknown boardId '${boardId}'`);
+            let run = execRunsByBoardId.get(boardId);
+            if (!run || run.status === 'done' || run.status === 'stopped') {
+                run = { runId: `boardrun-mock-${++seq}`, boardId, status: 'running', requestIds: new Set(), issueIndex: 0 };
+                execRunsByBoardId.set(boardId, run);
+                execRunsByRunId.set(run.runId, run);
+                later(() => advanceExec(run));
+            }
+            run.requestIds.add(requestId);
+            execRunsByRequestId.set(requestId, run);
+            return { runId: run.runId };
+        },
+        'pm.pause': (params) => {
+            const runId = asString(asRecord(params, 'pm.pause').runId, 'runId', 'pm.pause');
+            const run = execRunsByRunId.get(runId);
+            if (!run)
+                throw new MinionryError('BAD_REQUEST', `pm.pause: unknown runId '${runId}'`);
+            if (run.status === 'running')
+                run.status = 'paused';
+            return null;
+        },
+        'pm.resume': (params) => {
+            const runId = asString(asRecord(params, 'pm.resume').runId, 'runId', 'pm.resume');
+            const run = execRunsByRunId.get(runId);
+            if (!run)
+                throw new MinionryError('BAD_REQUEST', `pm.resume: unknown runId '${runId}'`);
+            if (run.status === 'paused') {
+                run.status = 'running';
+                later(() => advanceExec(run));
+            }
+            return null;
+        },
+        'pm.stop': (params) => {
+            const runId = asString(asRecord(params, 'pm.stop').runId, 'runId', 'pm.stop');
+            const run = execRunsByRunId.get(runId);
+            if (!run)
+                throw new MinionryError('BAD_REQUEST', `pm.stop: unknown runId '${runId}'`);
+            if (run.status === 'running' || run.status === 'paused') {
+                run.status = 'stopped';
+                emitToRun(run, 'complete', { reason: 'Stopped by app' });
+            }
+            return null;
+        },
+        'pm.schedules.list': () => ({ schedules: [...schedules.values()].map((s) => ({ ...s })) }),
+        'pm.schedules.create': (params) => {
+            const record = asRecord(params, 'pm.schedules.create');
+            const source = asRecord(record.source, 'pm.schedules.create');
+            if (source.kind !== 'template-json' || typeof source.content !== 'string' || source.content === '') {
+                throw new MinionryError('BAD_REQUEST', "pm.schedules.create: source must be { kind: 'template-json', content }");
+            }
+            const timing = mockScheduleTiming(record.timing, 'pm.schedules.create');
+            const id = `sched-mock-${++seq}`;
+            const now = new Date();
+            const snapshot = {
+                id,
+                createdAt: now.toISOString(),
+                source: { kind: 'template-json' },
+                timing,
+                enabled: record.enabled === undefined ? true : record.enabled === true,
+                nextFireAt: mockNextFireAt(timing, now),
+                history: [],
+            };
+            if (typeof record.name === 'string')
+                snapshot.name = record.name;
+            if (record.input !== undefined)
+                snapshot.input = record.input;
+            schedules.set(id, snapshot);
+            return { ...snapshot };
+        },
+        'pm.schedules.update': (params) => {
+            const record = asRecord(params, 'pm.schedules.update');
+            const scheduleId = asString(record.scheduleId, 'scheduleId', 'pm.schedules.update');
+            const existing = schedules.get(scheduleId);
+            if (!existing)
+                throw new MinionryError('BAD_REQUEST', `pm.schedules.update: unknown scheduleId '${scheduleId}'`);
+            const patch = record.patch === undefined ? {} : asRecord(record.patch, 'pm.schedules.update');
+            const updated = { ...existing };
+            if ('name' in patch)
+                updated.name = typeof patch.name === 'string' ? patch.name : undefined;
+            if ('enabled' in patch)
+                updated.enabled = patch.enabled === true;
+            if ('input' in patch)
+                updated.input = patch.input === null ? undefined : patch.input;
+            if ('timing' in patch) {
+                updated.timing = mockScheduleTiming(patch.timing, 'pm.schedules.update');
+                updated.nextFireAt = mockNextFireAt(updated.timing, new Date());
+            }
+            schedules.set(scheduleId, updated);
+            return { ...updated };
+        },
+        'pm.schedules.delete': (params) => {
+            const scheduleId = asString(asRecord(params, 'pm.schedules.delete').scheduleId, 'scheduleId', 'pm.schedules.delete');
+            schedules.delete(scheduleId);
+            return null;
+        },
+        'stream.resume': (params) => {
+            const record = asRecord(params, 'stream.resume');
+            const requestId = asString(record.requestId, 'requestId', 'stream.resume');
+            const rawAfterSeq = record.afterSeq;
+            if (rawAfterSeq !== undefined && (typeof rawAfterSeq !== 'number' || !Number.isInteger(rawAfterSeq) || rawAfterSeq < 0)) {
+                throw new MinionryError('BAD_REQUEST', 'stream.resume: afterSeq must be a non-negative integer when present');
+            }
+            const afterSeq = rawAfterSeq ?? 0;
+            const currentSeq = streamSeq.get(requestId) ?? 0;
+            const log = streamLog.get(requestId);
+            if (!log) {
+                if (runsByRequestId.has(requestId) ||
+                    inferenceRunsByRequestId.has(requestId) ||
+                    subscriptions.has(requestId) ||
+                    execRunsByRequestId.has(requestId) ||
+                    toolRegistrations.has(requestId)) {
+                    return { requestId, fromSeq: afterSeq, events: [], currentSeq: 0 };
+                }
+                throw new MinionryError('STREAM_GAP', `stream.resume: '${requestId}' is not a stream this mock host is holding — reconcile with a snapshot read`);
+            }
+            return {
+                requestId,
+                fromSeq: afterSeq,
+                events: log.filter((entry) => entry.seq > afterSeq),
+                currentSeq,
+            };
+        },
+        'pm.subscribeBoard': (params, requestId) => {
+            const boardId = asString(asRecord(params, 'pm.subscribeBoard').boardId, 'boardId', 'pm.subscribeBoard');
+            const board = boards.get(boardId);
+            if (!board)
+                throw new MinionryError('BAD_REQUEST', `pm.subscribeBoard: unknown boardId '${boardId}'`);
+            board.subscribers.add(requestId);
+            subscriptions.set(requestId, board);
+            emit(requestId, 'boardUpdate', boardSnapshot(board));
+            return null;
+        },
+        'files.read': (params) => {
+            const path = asString(asRecord(params, 'files.read').path, 'path', 'files.read');
+            const content = files.get(path);
+            if (content === undefined)
+                throw new MinionryError('BAD_REQUEST', `files.read: no such file '${path}'`);
+            return content;
+        },
+        'files.readEntry': (params) => {
+            const path = asString(asRecord(params, 'files.readEntry').path, 'path', 'files.readEntry');
+            const content = files.get(path);
+            if (content === undefined)
+                throw new MinionryError('BAD_REQUEST', `files.readEntry: no such file '${path}'`);
+            return { kind: 'text', content };
+        },
+        'files.write': (params) => {
+            const record = asRecord(params, 'files.write');
+            const path = asString(record.path, 'path', 'files.write');
+            files.set(path, asString(record.content, 'content', 'files.write'));
+            timestamps.set(path, new Date().toISOString());
+            notifyMockFileChanged(path, 'changed');
+            return null;
+        },
+        'files.list': (params) => {
+            const path = asString(asRecord(params, 'files.list').path, 'path', 'files.list');
+            const prefix = path === '' || path === '.' ? '' : `${path.replace(/\/+$/, '')}/`;
+            const children = new Map();
+            for (const key of files.keys()) {
+                if (!key.startsWith(prefix))
+                    continue;
+                const rest = key.slice(prefix.length);
+                if (!rest)
+                    continue;
+                const slash = rest.indexOf('/');
+                if (slash === -1)
+                    children.set(rest, children.get(rest) ?? false);
+                else
+                    children.set(rest.slice(0, slash), true);
+            }
+            for (const dirPath of dirs) {
+                if (!dirPath.startsWith(prefix))
+                    continue;
+                const rest = dirPath.slice(prefix.length);
+                if (!rest)
+                    continue;
+                const slash = rest.indexOf('/');
+                children.set(slash === -1 ? rest : rest.slice(0, slash), true);
+            }
+            return [...children]
+                .map(([name, dir]) => {
+                const fullPath = `${prefix}${name}`;
+                const content = dir ? undefined : files.get(fullPath);
+                return {
+                    name,
+                    dir,
+                    kind: dir ? 'directory' : 'file',
+                    size: content === undefined ? undefined : new TextEncoder().encode(content).length,
+                    modifiedAt: timestamps.get(fullPath),
+                };
+            })
+                .sort((a, b) => (a.name < b.name ? -1 : 1));
+        },
+        'files.delete': (params) => {
+            const path = asString(asRecord(params, 'files.delete').path, 'path', 'files.delete');
+            files.delete(path);
+            dirs.delete(path);
+            timestamps.delete(path);
+            const prefix = `${path}/`;
+            for (const key of [...files.keys()]) {
+                if (!key.startsWith(prefix))
+                    continue;
+                files.delete(key);
+                timestamps.delete(key);
+            }
+            for (const dirPath of [...dirs]) {
+                if (dirPath.startsWith(prefix))
+                    dirs.delete(dirPath);
+            }
+            return null;
+        },
+        'files.mkdir': (params) => {
+            const path = asString(asRecord(params, 'files.mkdir').path, 'path', 'files.mkdir');
+            dirs.add(path);
+            timestamps.set(path, new Date().toISOString());
+            return null;
+        },
+        'files.rename': (params) => {
+            const record = asRecord(params, 'files.rename');
+            const from = asString(record.path, 'path', 'files.rename');
+            const to = asString(record.newPath, 'newPath', 'files.rename');
+            const fromPrefix = `${from}/`;
+            const exists = files.has(from) ||
+                dirs.has(from) ||
+                [...files.keys(), ...dirs].some((key) => key.startsWith(fromPrefix));
+            if (!exists) {
+                throw new MinionryError('BAD_REQUEST', `files.rename: no such file or directory '${from}'`);
+            }
+            const rewrite = (key) => (key === from ? to : `${to}${key.slice(from.length)}`);
+            const moveTimestamp = (oldKey, newKey) => {
+                const ts = timestamps.get(oldKey);
+                timestamps.delete(oldKey);
+                if (ts !== undefined)
+                    timestamps.set(newKey, ts);
+            };
+            for (const key of [...files.keys()]) {
+                if (key !== from && !key.startsWith(fromPrefix))
+                    continue;
+                const content = files.get(key);
+                files.delete(key);
+                const newKey = rewrite(key);
+                files.set(newKey, content);
+                moveTimestamp(key, newKey);
+            }
+            for (const key of [...dirs]) {
+                if (key !== from && !key.startsWith(fromPrefix))
+                    continue;
+                dirs.delete(key);
+                const newKey = rewrite(key);
+                dirs.add(newKey);
+                moveTimestamp(key, newKey);
+            }
+            return null;
+        },
+        'files.uploadStart': (params) => {
+            const record = asRecord(params, 'files.uploadStart');
+            const path = asString(record.path, 'path', 'files.uploadStart');
+            const totalChunks = record.totalChunks;
+            if (typeof totalChunks !== 'number' || !Number.isInteger(totalChunks) || totalChunks < 1) {
+                throw new MinionryError('BAD_REQUEST', 'files.uploadStart: totalChunks must be a positive integer');
+            }
+            const overwrite = record.overwrite === true;
+            if (dirs.has(path)) {
+                throw new MinionryError('BAD_REQUEST', `files.uploadStart: '${path}' is a directory — cannot upload over it`);
+            }
+            if (files.has(path) && !overwrite) {
+                throw new MinionryError('BAD_REQUEST', `files.uploadStart: '${path}' already exists — pass overwrite to replace it`);
+            }
+            const uploadId = `upload-mock-${++seq}`;
+            uploads.set(uploadId, {
+                path,
+                overwrite,
+                totalChunks,
+                chunks: new Array(totalChunks),
+                nextExpectedChunk: 0,
+                bytesWritten: 0,
+                scope: resolveFilesWriteScope(path),
+            });
+            return { uploadId, chunkSize: 256 * 1024, nextExpectedChunk: 0 };
+        },
+        'files.uploadChunk': (params) => {
+            const record = asRecord(params, 'files.uploadChunk');
+            const uploadId = asString(record.uploadId, 'uploadId', 'files.uploadChunk');
+            const chunkIndex = record.chunkIndex;
+            if (typeof chunkIndex !== 'number' || !Number.isInteger(chunkIndex) || chunkIndex < 0) {
+                throw new MinionryError('BAD_REQUEST', 'files.uploadChunk: chunkIndex must be a non-negative integer');
+            }
+            const content = asString(record.content, 'content', 'files.uploadChunk');
+            const session = uploads.get(uploadId);
+            if (!session)
+                throw new MinionryError('BAD_REQUEST', `files.uploadChunk: unknown uploadId '${uploadId}'`);
+            if (chunkIndex < session.nextExpectedChunk) {
+                return { chunkIndex, bytesWritten: session.bytesWritten };
+            }
+            if (chunkIndex !== session.nextExpectedChunk) {
+                throw new MinionryError('BAD_REQUEST', `files.uploadChunk: expected chunk ${session.nextExpectedChunk}, got ${chunkIndex} — chunks must arrive in order`);
+            }
+            if (chunkIndex >= session.totalChunks) {
+                throw new MinionryError('BAD_REQUEST', `files.uploadChunk: upload '${uploadId}' already has all ${session.totalChunks} chunks`);
+            }
+            session.chunks[chunkIndex] = base64ToBytes(content);
+            session.nextExpectedChunk += 1;
+            session.bytesWritten += session.chunks[chunkIndex].byteLength;
+            if (session.nextExpectedChunk === session.totalChunks) {
+                const joined = new Uint8Array(session.bytesWritten);
+                let offset = 0;
+                for (const chunk of session.chunks) {
+                    joined.set(chunk, offset);
+                    offset += chunk.byteLength;
+                }
+                files.set(session.path, new TextDecoder().decode(joined));
+                timestamps.set(session.path, new Date().toISOString());
+                uploads.delete(uploadId);
+            }
+            return { chunkIndex, bytesWritten: session.bytesWritten };
+        },
+        'files.uploadStatus': (params) => {
+            const uploadId = asString(asRecord(params, 'files.uploadStatus').uploadId, 'uploadId', 'files.uploadStatus');
+            const session = uploads.get(uploadId);
+            if (!session)
+                throw new MinionryError('BAD_REQUEST', `files.uploadStatus: unknown uploadId '${uploadId}'`);
+            return { nextExpectedChunk: session.nextExpectedChunk };
+        },
+        'files.uploadCancel': (params) => {
+            const uploadId = asString(asRecord(params, 'files.uploadCancel').uploadId, 'uploadId', 'files.uploadCancel');
+            uploads.delete(uploadId);
+            return null;
+        },
+        'files.downloadStart': (params) => {
+            const record = asRecord(params, 'files.downloadStart');
+            const path = asString(record.path, 'path', 'files.downloadStart');
+            if (dirs.has(path) || [...files.keys()].some((key) => key.startsWith(`${path}/`))) {
+                throw new MinionryError('BAD_REQUEST', "files.downloadStart: directory (zip) download isn't modeled in mock mode — test this path against a real host");
+            }
+            const content = files.get(path);
+            if (content === undefined)
+                throw new MinionryError('BAD_REQUEST', `files.downloadStart: no such file '${path}'`);
+            const bytes = new TextEncoder().encode(content);
+            const chunkSize = 256 * 1024;
+            const totalChunks = Math.max(1, Math.ceil(bytes.byteLength / chunkSize));
+            const downloadId = `download-mock-${++seq}`;
+            downloads.set(downloadId, {
+                content: bytesToBase64(bytes),
+                fileSize: bytes.byteLength,
+                totalChunks,
+                mimeType: 'text/plain',
+                isZip: false,
+                scope: resolveFilesReadScope(path),
+            });
+            return {
+                downloadId,
+                fileSize: bytes.byteLength,
+                totalChunks,
+                chunkSize,
+                mimeType: 'text/plain',
+                isZip: false,
+            };
+        },
+        'files.downloadChunk': (params) => {
+            const record = asRecord(params, 'files.downloadChunk');
+            const downloadId = asString(record.downloadId, 'downloadId', 'files.downloadChunk');
+            const chunkIndex = record.chunkIndex;
+            if (typeof chunkIndex !== 'number' || !Number.isInteger(chunkIndex) || chunkIndex < 0) {
+                throw new MinionryError('BAD_REQUEST', 'files.downloadChunk: chunkIndex must be a non-negative integer');
+            }
+            const session = downloads.get(downloadId);
+            if (!session)
+                throw new MinionryError('BAD_REQUEST', `files.downloadChunk: unknown downloadId '${downloadId}'`);
+            if (chunkIndex >= session.totalChunks) {
+                throw new MinionryError('BAD_REQUEST', `files.downloadChunk: download '${downloadId}' has only ${session.totalChunks} chunks`);
+            }
+            const bytes = base64ToBytes(session.content);
+            const chunkSize = 256 * 1024;
+            const from = chunkIndex * chunkSize;
+            const to = Math.min(from + chunkSize, bytes.byteLength);
+            return { content: bytesToBase64(bytes.subarray(from, to)) };
+        },
+        'files.downloadCancel': (params) => {
+            const downloadId = asString(asRecord(params, 'files.downloadCancel').downloadId, 'downloadId', 'files.downloadCancel');
+            downloads.delete(downloadId);
+            return null;
+        },
+        'files.search': (params, requestId) => {
+            const record = asRecord(params, 'files.search');
+            const path = asString(record.path, 'path', 'files.search');
+            const query = asString(record.query, 'query', 'files.search');
+            const options = typeof record.options === 'object' && record.options !== null ? record.options : {};
+            const caseSensitive = options.caseSensitive === true;
+            const regex = options.regex === true;
+            const prefix = path === '' || path === '.' ? '' : `${path.replace(/\/+$/, '')}/`;
+            const pattern = regex ? new RegExp(query, caseSensitive ? '' : 'i') : undefined;
+            const needle = caseSensitive ? query : query.toLowerCase();
+            const matches = [];
+            for (const [filePath, content] of files) {
+                if (prefix && !filePath.startsWith(prefix))
+                    continue;
+                const relPath = prefix ? filePath.slice(prefix.length) : filePath;
+                content.split('\n').forEach((line, index) => {
+                    const column = pattern ? line.search(pattern) : (caseSensitive ? line : line.toLowerCase()).indexOf(needle);
+                    if (column === -1)
+                        return;
+                    matches.push({ path: relPath, line: index + 1, column: column + 1, lineContent: line, contextBefore: [], contextAfter: [] });
+                });
+            }
+            later(() => {
+                if (matches.length > 0)
+                    emit(requestId, 'results', { matches });
+                emit(requestId, 'complete', {
+                    totalMatches: matches.length,
+                    fileCount: new Set(matches.map((m) => m.path)).size,
+                    truncated: false,
+                });
+            });
+            return null;
+        },
+        'files.definition': (params) => {
+            const record = asRecord(params, 'files.definition');
+            const path = asString(record.path, 'path', 'files.definition');
+            const symbolName = asString(record.symbolName, 'symbolName', 'files.definition');
+            const escaped = symbolName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const pattern = new RegExp(`\\b(function|const|let|var|class|interface|type|enum)\\s+${escaped}\\b`);
+            const prefix = path === '' || path === '.' ? '' : `${path.replace(/\/+$/, '')}/`;
+            const definitions = [];
+            for (const [filePath, content] of files) {
+                if (prefix && !filePath.startsWith(prefix))
+                    continue;
+                const relPath = prefix ? filePath.slice(prefix.length) : filePath;
+                content.split('\n').forEach((line, index) => {
+                    const match = pattern.exec(line);
+                    if (!match)
+                        return;
+                    definitions.push({ path: relPath, line: index + 1, column: match.index + 1, lineContent: line, kind: 'function' });
+                });
+            }
+            return definitions;
+        },
+        'files.subscribeChanges': (params, requestId) => {
+            const path = asString(asRecord(params, 'files.subscribeChanges').path, 'path', 'files.subscribeChanges');
+            fileChangeSubscriptions.set(requestId, path);
+            return { subscribed: true };
+        },
+        'storage.get': (params) => {
+            const value = storage.get(asString(asRecord(params, 'storage.get').key, 'key', 'storage.get'));
+            return value === undefined ? undefined : structuredClone(value);
+        },
+        'storage.set': (params) => {
+            const record = asRecord(params, 'storage.set');
+            const key = asString(record.key, 'key', 'storage.set');
+            let value;
+            try {
+                value = structuredClone(record.value);
+            }
+            catch {
+                throw new MinionryError('BAD_REQUEST', 'storage.set: value must be structured-cloneable');
+            }
+            storage.set(key, value);
+            return null;
+        },
+        'storage.delete': (params) => {
+            storage.delete(asString(asRecord(params, 'storage.delete').key, 'key', 'storage.delete'));
+            return null;
+        },
+        'storage.keys': () => [...storage.keys()],
+        'notifications.request': () => {
+            notificationGranted = true;
+            return null;
+        },
+        'notifications.status': () => ({ granted: notificationGranted }),
+        'notifications.revoke': () => {
+            notificationGranted = false;
+            return null;
+        },
+        'theme.get': () => ({ ...theme, tokens: { ...theme.tokens } }),
+        'locale.get': () => ({ ...locale }),
+        'browser.tabs.list': () => browserTabsPayload(),
+        'browser.tabs.subscribe': (_params, requestId) => {
+            browserTabSubscriptions.add(requestId);
+            return { subscribed: true };
+        },
+        'browser.navigate': (params) => {
+            const record = asRecord(params, 'browser.navigate');
+            const url = asString(record.url, 'url', 'browser.navigate');
+            const tabId = typeof record.tabId === 'string' ? record.tabId : currentTabId;
+            if (tabId === null)
+                throw new MinionryError('BAD_REQUEST', 'browser.navigate: no tab is open to navigate');
+            const tab = requireBrowserTab(tabId, 'browser.navigate');
+            tab.canGoBack = true;
+            tab.url = url;
+            tab.title = originOf(url) ?? url;
+            browserEpoch += 1;
+            publishBrowserTabs();
+            return null;
+        },
+        'browser.open': (params) => {
+            const record = asRecord(params, 'browser.open');
+            const url = asString(record.url, 'url', 'browser.open');
+            const origin = originOf(url);
+            if (record.pinnedApp === true && origin !== undefined) {
+                const existing = browserTabs.find((tab) => originOf(tab.url) === origin);
+                if (existing) {
+                    currentTabId = existing.id;
+                    publishBrowserTabs();
+                    return { tabId: existing.id };
+                }
+            }
+            const tabId = `tab-mock-${++seq}`;
+            browserTabs.push({
+                id: tabId,
+                url,
+                title: origin ?? url,
+                isLoading: false,
+                canGoBack: false,
+                canGoForward: false,
+            });
+            currentTabId = tabId;
+            browserEpoch += 1;
+            publishBrowserTabs();
+            return { tabId };
+        },
+        'browser.close': (params) => {
+            const tabId = asString(asRecord(params, 'browser.close').tabId, 'tabId', 'browser.close');
+            const index = browserTabs.findIndex((tab) => tab.id === tabId);
+            if (index === -1)
+                throw new MinionryError('BAD_REQUEST', `browser.close: unknown tabId '${tabId}'`);
+            browserTabs.splice(index, 1);
+            if (currentTabId === tabId)
+                currentTabId = browserTabs[Math.min(index, browserTabs.length - 1)]?.id ?? null;
+            publishBrowserTabs();
+            return null;
+        },
+        'browser.select': (params) => {
+            const tabId = asString(asRecord(params, 'browser.select').tabId, 'tabId', 'browser.select');
+            currentTabId = requireBrowserTab(tabId, 'browser.select').id;
+            publishBrowserTabs();
+            return null;
+        },
+        'browser.back': (params) => moveHistory(params, 'browser.back'),
+        'browser.forward': (params) => moveHistory(params, 'browser.forward'),
+        'browser.reload': (params) => {
+            const tab = historyTarget(params, 'browser.reload');
+            tab.isLoading = true;
+            browserEpoch += 1;
+            publishBrowserTabs();
+            later(() => {
+                tab.isLoading = false;
+                publishBrowserTabs();
+            });
+            return null;
+        },
+        'browser.stop': (params) => {
+            const tab = historyTarget(params, 'browser.stop');
+            tab.isLoading = false;
+            publishBrowserTabs();
+            return null;
+        },
+        'browser.preflight': () => ({ ok: true }),
+        'browser.resumeDriver': (params) => {
+            const tabId = asString(asRecord(params, 'browser.resumeDriver').tabId, 'tabId', 'browser.resumeDriver');
+            requireBrowserTab(tabId, 'browser.resumeDriver');
+            return null;
+        },
+        'browser.setDeviceProfile': (params) => {
+            const record = asRecord(params, 'browser.setDeviceProfile');
+            const tabId = asString(record.tabId, 'tabId', 'browser.setDeviceProfile');
+            if (record.formFactor !== 'desktop' && record.formFactor !== 'mobile') {
+                throw new MinionryError('BAD_REQUEST', "browser.setDeviceProfile: formFactor must be 'desktop' or 'mobile'");
+            }
+            const tab = requireBrowserTab(tabId, 'browser.setDeviceProfile');
+            tab.deviceProfile =
+                record.formFactor === 'mobile'
+                    ? { formFactor: 'mobile', width: 390, height: 844, label: 'Mobile' }
+                    : { formFactor: 'desktop', width: 1280, height: 720, label: 'Desktop' };
+            publishBrowserTabs();
+            return null;
+        },
+        'browser.view.attach': (params, requestId) => {
+            const record = params === undefined || params === null ? {} : asRecord(params, 'browser.view.attach');
+            const tabId = record.tabId === undefined || record.tabId === null
+                ? currentTabId
+                : asString(record.tabId, 'tabId', 'browser.view.attach');
+            if (tabId === null) {
+                throw new MinionryError('BAD_REQUEST', 'browser.view.attach: no tab is open to stream');
+            }
+            const tab = requireBrowserTab(tabId, 'browser.view.attach');
+            const view = {
+                sessionId: `view-mock-${++seq}`,
+                requestId,
+                tabId: tab.id,
+                detached: false,
+            };
+            views.set(requestId, view);
+            later(() => {
+                if (view.detached)
+                    return;
+                emit(requestId, 'connectionState', { state: 'negotiating' });
+                publishViewNavigation(view);
+                emit(requestId, 'driverState', { tabId: view.tabId, state: 'idle', since: 0 });
+            });
+            return { sessionId: view.sessionId, tabId: view.tabId };
+        },
+        'browser.view.answer': (params) => {
+            requireView(params, 'browser.view.answer');
+            asString(asRecord(params, 'browser.view.answer').sdp, 'sdp', 'browser.view.answer');
+            return null;
+        },
+        'browser.view.ice': (params) => {
+            requireView(params, 'browser.view.ice');
+            const candidate = asRecord(params, 'browser.view.ice').candidate;
+            if (candidate !== null && (typeof candidate !== 'object' || candidate === undefined)) {
+                throw new MinionryError('BAD_REQUEST', 'browser.view.ice: candidate must be an object or null');
+            }
+            return null;
+        },
+        'browser.view.state': (params) => {
+            const view = requireView(params, 'browser.view.state');
+            const state = asString(asRecord(params, 'browser.view.state').state, 'state', 'browser.view.state');
+            if (!['negotiating', 'connected', 'failed', 'closed'].includes(state)) {
+                throw new MinionryError('BAD_REQUEST', `browser.view.state: unknown state '${state}'`);
+            }
+            emit(view.requestId, 'connectionState', { state });
+            if (state === 'closed')
+                retireView(view);
+            return null;
+        },
+        'browser.view.input': (params) => {
+            const view = requireView(params, 'browser.view.input');
+            const raw = asRecord(params, 'browser.view.input').input;
+            const batch = Array.isArray(raw) ? raw : [raw];
+            if (batch.length === 0 || batch.length > MOCK_INPUT_BATCH_MAX) {
+                throw new MinionryError('BAD_REQUEST', `browser.view.input: input must be 1–${MOCK_INPUT_BATCH_MAX} envelopes`);
+            }
+            const bad = batch.find((entry) => typeof entry !== 'object' || entry === null || typeof entry.kind !== 'string');
+            if (bad !== undefined) {
+                emit(view.requestId, 'inputRejected', { kind: 'unknown', reason: 'malformed', message: 'invalid input envelope' });
+                return { delivered: false, reason: 'malformed' };
+            }
+            return { delivered: true };
+        },
+        'browser.view.bounds': (params) => {
+            requireView(params, 'browser.view.bounds');
+            const bounds = asRecord(params, 'browser.view.bounds').bounds;
+            const record = bounds === undefined || bounds === null ? null : asRecord(bounds, 'browser.view.bounds');
+            if (!record || typeof record.width !== 'number' || typeof record.height !== 'number') {
+                throw new MinionryError('BAD_REQUEST', 'browser.view.bounds: bounds requires numeric { width, height }');
+            }
+            return null;
+        },
+        'browser.snapshot': (params) => {
+            const tabId = asString(asRecord(params, 'browser.snapshot').tabId, 'tabId', 'browser.snapshot');
+            const tab = requireBrowserTab(tabId, 'browser.snapshot');
+            return {
+                url: tab.url,
+                title: tab.title,
+                epoch: browserEpoch,
+                root: mockSnapshotRoot(tab),
+            };
+        },
+        'browser.screenshot': (params) => {
+            const record = asRecord(params, 'browser.screenshot');
+            const tabId = asString(record.tabId, 'tabId', 'browser.screenshot');
+            requireBrowserTab(tabId, 'browser.screenshot');
+            return { format: record.format === 'jpeg' ? 'jpeg' : 'png', data: MOCK_SCREENSHOT_PNG };
+        },
+        'browser.evaluate': (params) => {
+            const record = asRecord(params, 'browser.evaluate');
+            const tabId = asString(record.tabId, 'tabId', 'browser.evaluate');
+            asString(record.expr, 'expr', 'browser.evaluate');
+            requireBrowserTab(tabId, 'browser.evaluate');
+            return { value: null, type: 'object' };
+        },
+        'browser.automate': (params, requestId) => {
+            const record = asRecord(params, 'browser.automate');
+            const prompt = asString(record.prompt, 'prompt', 'browser.automate');
+            if (prompt.trim() === '') {
+                throw new MinionryError('BAD_REQUEST', 'browser.automate: prompt must be a non-empty string');
+            }
+            let engine;
+            if (record.engine !== undefined && record.engine !== null) {
+                engine = asString(record.engine, 'engine', 'browser.automate');
+                if (!MOCK_ENGINES.includes(engine)) {
+                    throw new MinionryError('BAD_REQUEST', `browser.automate: unknown engine '${engine}' — expected one of ${MOCK_ENGINES.join(', ')}`);
+                }
+            }
+            let model;
+            if (record.model !== undefined && record.model !== null) {
+                model = asString(record.model, 'model', 'browser.automate');
+                if (model === '') {
+                    throw new MinionryError('BAD_REQUEST', 'browser.automate: model must be a non-empty string when present');
+                }
+            }
+            const resolvedEngine = engine ?? (model ? mockEngineForModel(model) : MOCK_DEFAULT_ENGINE);
+            if (model && mockEngineForModel(model) !== resolvedEngine) {
+                throw new MinionryError('BAD_REQUEST', `browser.automate: model '${model}' is not a ${resolvedEngine} model — it belongs to ${mockEngineForModel(model)}`);
+            }
+            const resolvedModel = model ?? (mockEngineForModel(MOCK_DEFAULT_MODEL) === resolvedEngine ? MOCK_DEFAULT_MODEL : undefined);
+            if (record.tabId !== undefined && record.tabId !== null) {
+                requireBrowserTab(asString(record.tabId, 'tabId', 'browser.automate'), 'browser.automate');
+            }
+            const taskId = `automation-mock-${++seq}`;
+            const sessionId = `agent-mock-${++seq}`;
+            const sessionName = prompt.split('\n').find((line) => line.trim() !== '')?.trim() ?? prompt;
+            const target = { engine: resolvedEngine, ...(resolvedModel ? { model: resolvedModel } : {}), sessionId };
+            const run = {
+                taskId,
+                requestId,
+                status: 'running',
+                pendingProposalId: null,
+                steps: [
+                    { event: 'step', payload: { phase: 'plan', detail: `1. Read the page\n2. ${prompt}` } },
+                    { event: 'step', payload: { phase: 'observe', detail: 'Read the page (mock)' } },
+                ],
+                target,
+            };
+            automations.set(requestId, run);
+            later(() => emit(run.requestId, 'session', { sessionId, name: sessionName }));
+            const toProposal = () => {
+                if (run.status !== 'running')
+                    return;
+                if (run.steps.length === 0) {
+                    proposeAutomationAction(run);
+                    return;
+                }
+                const step = run.steps.shift();
+                emit(run.requestId, step.event, stampTarget(run, step));
+                later(toProposal);
+            };
+            later(toProposal);
+            return { taskId };
+        },
+        'browser.automate.approve': (params) => {
+            const record = asRecord(params, 'browser.automate.approve');
+            const proposalId = asString(record.proposalId, 'proposalId', 'browser.automate.approve');
+            const verdict = record.verdict === undefined ? 'approve' : record.verdict;
+            if (verdict !== 'approve' && verdict !== 'edit' && verdict !== 'deny') {
+                throw new MinionryError('BAD_REQUEST', "browser.automate.approve: verdict must be 'approve', 'edit' or 'deny' when present");
+            }
+            const run = [...automations.values()].find((candidate) => candidate.pendingProposalId === proposalId);
+            if (!run) {
+                throw new MinionryError('BAD_REQUEST', `browser.automate.approve: no proposal '${proposalId}' is awaiting a verdict`);
+            }
+            run.pendingProposalId = null;
+            run.status = 'running';
+            if (verdict === 'deny') {
+                run.steps = [{ event: 'done', payload: { status: 'cancelled' } }];
+            }
+            else {
+                const edited = verdict === 'edit' && typeof record.editedText === 'string' ? record.editedText : null;
+                run.steps = [
+                    {
+                        event: 'step',
+                        payload: {
+                            phase: 'act',
+                            detail: edited === null ? 'Clicked "Continue" (mock)' : `Typed "${edited}" (mock)`,
+                            proposalId,
+                        },
+                    },
+                    { event: 'step', payload: { phase: 'extract', detail: 'Read the resulting page (mock)' } },
+                    { event: 'done', payload: { status: 'success', result: `Completed: ${run.taskId} (mock)` } },
+                ];
+            }
+            later(() => advanceAutomation(run));
+            return null;
+        },
+        'composer.autocomplete': (params) => {
+            const query = asString(asRecord(params, 'composer.autocomplete').query, 'query', 'composer.autocomplete').toLowerCase();
+            return [...files.keys()]
+                .filter((path) => query === '' || path.toLowerCase().includes(query))
+                .slice(0, 15)
+                .map((path) => ({
+                value: path,
+                label: path,
+                isDirectory: false,
+                isRecent: false,
+                fileType: path.split('.').pop() ?? '',
+                matchedIndices: [],
+            }));
+        },
+        'composer.skills': () => MOCK_SKILLS.map((s) => ({ ...s })),
+        'composer.snippets': (params) => {
+            const record = asRecord(params, 'composer.snippets');
+            const query = typeof record.query === 'string' ? record.query.trim().toLowerCase() : '';
+            const all = MOCK_SNIPPETS.map((s) => ({ ...s, aliases: [...s.aliases] }));
+            if (query === '')
+                return all;
+            return all.filter((s) => s.name.includes(query) || s.description.toLowerCase().includes(query));
+        },
+        'composer.settings': () => ({
+            engines: [...MOCK_ENGINES],
+            defaults: { engine: MOCK_DEFAULT_ENGINE, model: MOCK_DEFAULT_MODEL, effortLevel: 'auto', fastMode: false },
+            models: MOCK_MODEL_CATALOG.map((entry) => ({ ...entry })),
+            modelsStatus: { fetchedAt: new Date().toISOString(), stale: false, refreshing: false },
+            effortLevels: Object.fromEntries(Object.entries(MOCK_EFFORT_LEVELS).map(([id, levels]) => [id, [...levels]])),
+            inferenceEngines: [...MOCK_INFERENCE_ENGINES],
+        }),
+        'terminal.sessions.list': () => [...ptySessions.values()].map(mockPtySessionSummary),
+        'terminal.sessions.subscribe': (_params, requestId) => {
+            terminalSessionSubscriptions.add(requestId);
+            return { subscribed: true };
+        },
+        'terminal.open': (params) => {
+            const record = asRecord(params, 'terminal.open');
+            const cols = record.cols;
+            const rows = record.rows;
+            if (typeof cols !== 'number' || !Number.isInteger(cols) || cols < 1) {
+                throw new MinionryError('BAD_REQUEST', 'terminal.open: cols must be a positive integer');
+            }
+            if (typeof rows !== 'number' || !Number.isInteger(rows) || rows < 1) {
+                throw new MinionryError('BAD_REQUEST', 'terminal.open: rows must be a positive integer');
+            }
+            const cwd = record.cwd === undefined ? '/workspace' : asString(record.cwd, 'cwd', 'terminal.open');
+            const id = `pty-mock-${++seq}`;
+            const now = new Date().toISOString();
+            const session = {
+                id,
+                shell: 'mock-shell',
+                cwd,
+                cols,
+                rows,
+                platform: 'linux',
+                createdAt: now,
+                lastActivityAt: now,
+                scrollback: `Mock shell ready (${id})\n$ `,
+                closed: false,
+                attachedRequestIds: new Set(),
+            };
+            ptySessions.set(id, session);
+            notifyTerminalSessionChanged({ kind: 'opened', session: mockPtySessionSummary(session) });
+            return { id, shell: session.shell, cwd, cols, rows, platform: session.platform };
+        },
+        'terminal.attach': (params, requestId) => {
+            const id = asString(asRecord(params, 'terminal.attach').id, 'id', 'terminal.attach');
+            const session = ptySessions.get(id);
+            if (!session || session.closed)
+                throw new MinionryError('BAD_REQUEST', `terminal.attach: unknown session '${id}'`);
+            session.attachedRequestIds.add(requestId);
+            ptyAttachByRequestId.set(requestId, session);
+            later(() => {
+                if (!session.attachedRequestIds.has(requestId))
+                    return;
+                emitEphemeral(requestId, 'scrollback', { data: session.scrollback });
+            });
+            return { id };
+        },
+        'terminal.write': (params) => {
+            const record = asRecord(params, 'terminal.write');
+            const id = asString(record.id, 'id', 'terminal.write');
+            const data = asString(record.data, 'data', 'terminal.write');
+            const session = ptySessions.get(id);
+            if (!session || session.closed)
+                throw new MinionryError('BAD_REQUEST', `terminal.write: unknown session '${id}'`);
+            session.lastActivityAt = new Date().toISOString();
+            appendPtyScrollback(session, data);
+            emitToPty(session, 'output', { data });
+            const command = data.replace(/[\r\n]+$/, '');
+            if (command === 'burst')
+                triggerPtyBurst(session);
+            else if (command === 'exit')
+                closePtySession(session, 0);
+            return null;
+        },
+        'terminal.resize': (params) => {
+            const record = asRecord(params, 'terminal.resize');
+            const id = asString(record.id, 'id', 'terminal.resize');
+            const session = ptySessions.get(id);
+            if (!session || session.closed)
+                throw new MinionryError('BAD_REQUEST', `terminal.resize: unknown session '${id}'`);
+            const cols = record.cols;
+            const rows = record.rows;
+            if (typeof cols !== 'number' || !Number.isInteger(cols) || cols < 1) {
+                throw new MinionryError('BAD_REQUEST', 'terminal.resize: cols must be a positive integer');
+            }
+            if (typeof rows !== 'number' || !Number.isInteger(rows) || rows < 1) {
+                throw new MinionryError('BAD_REQUEST', 'terminal.resize: rows must be a positive integer');
+            }
+            session.cols = cols;
+            session.rows = rows;
+            return null;
+        },
+        'terminal.close': (params) => {
+            const id = asString(asRecord(params, 'terminal.close').id, 'id', 'terminal.close');
+            const session = ptySessions.get(id);
+            if (session)
+                closePtySession(session, 0);
+            return null;
+        },
+        'git.status': (params) => {
+            const { worktree } = requireWorktree(params, 'git.status');
+            const branch = gitBranches.get(worktree.branch);
+            return {
+                branch: worktree.branch,
+                isDirty: worktree.staged.length + worktree.unstaged.length + worktree.untracked.length > 0,
+                staged: worktree.staged.map((file) => ({ ...file })),
+                unstaged: worktree.unstaged.map((file) => ({ ...file })),
+                untracked: worktree.untracked.map((file) => ({ ...file })),
+                ahead: 0,
+                behind: 0,
+                hasUpstream: branch?.upstream !== undefined,
+            };
+        },
+        'git.log': (params) => {
+            const { record } = requireWorktree(params, 'git.log');
+            const limitRaw = record.limit;
+            if (limitRaw !== undefined && (typeof limitRaw !== 'number' || !Number.isInteger(limitRaw) || limitRaw < 1)) {
+                throw new MinionryError('BAD_REQUEST', 'git.log: limit must be a positive integer when present');
+            }
+            const skipRaw = record.skip;
+            if (skipRaw !== undefined && (typeof skipRaw !== 'number' || !Number.isInteger(skipRaw) || skipRaw < 0)) {
+                throw new MinionryError('BAD_REQUEST', 'git.log: skip must be a non-negative integer when present');
+            }
+            const limit = limitRaw ?? 20;
+            const skip = skipRaw ?? 0;
+            const search = record.search === undefined || record.search === null ? undefined : asString(record.search, 'search', 'git.log');
+            const filtered = search ? gitCommits.filter((commit) => commit.subject.toLowerCase().includes(search.toLowerCase())) : gitCommits;
+            const page = filtered.slice(skip, skip + limit);
+            const result = {
+                entries: page.map(({ hash, shortHash, subject, author, date }) => ({ hash, shortHash, subject, author, date })),
+                hasMore: skip + limit < filtered.length,
+                skip,
+            };
+            if (search !== undefined)
+                result.search = search;
+            return result;
+        },
+        'git.diff': (params) => {
+            const { worktree, record } = requireWorktree(params, 'git.diff');
+            const path = asString(record.path, 'path', 'git.diff');
+            const staged = record.staged === true;
+            const pending = [...worktree.staged, ...worktree.unstaged, ...worktree.untracked];
+            if (!pending.some((file) => file.path === path)) {
+                throw new MinionryError('BAD_REQUEST', `git.diff: '${path}' has no pending changes in this worktree`);
+            }
+            return {
+                path,
+                original: `// ${path} (mock) — before\n`,
+                modified: `// ${path} (mock) — after\n`,
+                staged,
+            };
+        },
+        'git.show': (params) => {
+            const hash = asString(asRecord(params, 'git.show').hash, 'hash', 'git.show');
+            const commit = findGitCommit(hash);
+            if (!commit)
+                throw new MinionryError('BAD_REQUEST', `git.show: unknown commit '${hash}'`);
+            return {
+                hash: commit.hash,
+                shortHash: commit.shortHash,
+                subject: commit.subject,
+                body: commit.body,
+                author: commit.author,
+                date: commit.date,
+                files: commit.files.map((file) => ({ ...file })),
+            };
+        },
+        'git.commitDiff': (params) => {
+            const record = asRecord(params, 'git.commitDiff');
+            const hash = asString(record.hash, 'hash', 'git.commitDiff');
+            const path = asString(record.path, 'path', 'git.commitDiff');
+            const commit = findGitCommit(hash);
+            if (!commit)
+                throw new MinionryError('BAD_REQUEST', `git.commitDiff: unknown commit '${hash}'`);
+            if (!commit.files.some((file) => file.path === path)) {
+                throw new MinionryError('BAD_REQUEST', `git.commitDiff: '${path}' was not changed in commit '${hash}'`);
+            }
+            return {
+                hash: commit.hash,
+                path,
+                original: `// ${path} (mock) — before ${commit.shortHash}\n`,
+                modified: `// ${path} (mock) — at ${commit.shortHash}\n`,
+            };
+        },
+        'git.branches.list': (params) => {
+            const { worktree } = requireWorktree(params, 'git.branches.list');
+            const branches = [...gitBranches.values()].map((branch) => {
+                const headCommit = findGitCommit(branch.head);
+                return {
+                    name: branch.name,
+                    shortHash: headCommit?.shortHash ?? gitShortHash(branch.head),
+                    isRemote: branch.isRemote,
+                    isCurrent: branch.name === worktree.branch,
+                    upstream: branch.upstream,
+                    lastCommitDate: headCommit?.date,
+                    ahead: 0,
+                    behind: 0,
+                };
+            });
+            return { branches, current: worktree.branch };
+        },
+        'git.branches.create': (params) => {
+            const { worktree, record } = requireWorktree(params, 'git.branches.create');
+            const name = asString(record.name, 'name', 'git.branches.create');
+            if (gitBranches.has(name))
+                throw new MinionryError('BAD_REQUEST', `git.branches.create: branch '${name}' already exists`);
+            const startPoint = record.startPoint === undefined ? undefined : asString(record.startPoint, 'startPoint', 'git.branches.create');
+            let head;
+            if (startPoint === undefined) {
+                head = gitBranches.get(worktree.branch)?.head ?? gitCommits[0]?.hash ?? mintGitHash();
+            }
+            else {
+                head = gitBranches.get(startPoint)?.head ?? findGitCommit(startPoint)?.hash ?? '';
+                if (!head)
+                    throw new MinionryError('BAD_REQUEST', `git.branches.create: unknown startPoint '${startPoint}'`);
+            }
+            gitBranches.set(name, { name, head, isRemote: false });
+            if (record.checkout === true) {
+                worktree.branch = name;
+                publishGitBranchChanged(worktree);
+            }
+            return { name, hash: head };
+        },
+        'git.branches.delete': (params) => {
+            const { record } = requireWorktree(params, 'git.branches.delete');
+            const name = asString(record.name, 'name', 'git.branches.delete');
+            if (!gitBranches.has(name))
+                throw new MinionryError('BAD_REQUEST', `git.branches.delete: unknown branch '${name}'`);
+            const force = record.force === true;
+            const checkedOut = [...gitWorktrees.values()].some((candidate) => candidate.branch === name);
+            if (checkedOut && !force) {
+                throw new MinionryError('BAD_REQUEST', `git.branches.delete: '${name}' is checked out in a worktree — pass force to delete anyway`);
+            }
+            gitBranches.delete(name);
+            return null;
+        },
+        'git.tags.list': () => ({
+            tags: [...gitTags.values()].map((tag) => ({ name: tag.name, shortHash: gitShortHash(tag.hash), date: tag.date, message: tag.message })),
+        }),
+        'git.tags.create': (params) => {
+            const { worktree, record } = requireWorktree(params, 'git.tags.create');
+            const name = asString(record.name, 'name', 'git.tags.create');
+            if (gitTags.has(name))
+                throw new MinionryError('BAD_REQUEST', `git.tags.create: tag '${name}' already exists`);
+            const commitArg = record.commit === undefined ? undefined : asString(record.commit, 'commit', 'git.tags.create');
+            const hash = commitArg === undefined
+                ? gitBranches.get(worktree.branch)?.head
+                : (findGitCommit(commitArg)?.hash ?? gitBranches.get(commitArg)?.head);
+            if (!hash)
+                throw new MinionryError('BAD_REQUEST', `git.tags.create: unknown commit '${commitArg}'`);
+            const message = record.message === undefined ? '' : asString(record.message, 'message', 'git.tags.create');
+            gitTags.set(name, { name, hash, message, date: new Date().toISOString() });
+            return { name, hash };
+        },
+        'git.tags.push': (params) => {
+            const record = asRecord(params, 'git.tags.push');
+            const name = record.name === undefined || record.name === null ? undefined : asString(record.name, 'name', 'git.tags.push');
+            const all = record.all === true;
+            if (!all && name === undefined)
+                throw new MinionryError('BAD_REQUEST', 'git.tags.push: pass a name or all: true');
+            if (name !== undefined && !gitTags.has(name))
+                throw new MinionryError('BAD_REQUEST', `git.tags.push: unknown tag '${name}'`);
+            return { name: name ?? '*', output: `Pushed ${all ? 'all tags' : `tag '${name}'`} to origin (mock)` };
+        },
+        'git.remote.info': (params) => {
+            const { worktree } = requireWorktree(params, 'git.remote.info');
+            return {
+                hasRemote: true,
+                remoteUrl: MOCK_GIT_REMOTE_URL,
+                provider: 'github',
+                defaultBranch: MOCK_GIT_DEFAULT_BRANCH,
+                currentBranch: worktree.branch,
+                hasGhCli: true,
+                ghCliAuthenticated: true,
+                ghCliBinary: 'gh',
+                remoteBranches: [...gitBranches.keys()],
+                preferredBaseBranch: MOCK_GIT_DEFAULT_BRANCH,
+            };
+        },
+        'git.repos.discover': () => ({
+            repos: [{ path: MOCK_GIT_MAIN_WORKTREE_PATH, name: 'mock-repo', branch: gitWorktrees.get(MOCK_GIT_MAIN_WORKTREE_PATH)?.branch }],
+            rootIsGitRepo: true,
+        }),
+        'git.worktrees.list': () => gitWorktreesSnapshot(),
+        'git.worktrees.create': (params) => {
+            const record = asRecord(params, 'git.worktrees.create');
+            const branchName = asString(record.branchName, 'branchName', 'git.worktrees.create');
+            const baseBranch = record.baseBranch === undefined ? undefined : asString(record.baseBranch, 'baseBranch', 'git.worktrees.create');
+            const path = record.path === undefined ? `/workspace-worktrees/${branchName}` : asString(record.path, 'path', 'git.worktrees.create');
+            if (gitWorktrees.has(path))
+                throw new MinionryError('BAD_REQUEST', `git.worktrees.create: '${path}' already has a worktree`);
+            let branch = gitBranches.get(branchName);
+            if (!branch) {
+                if (baseBranch !== undefined && !gitBranches.has(baseBranch)) {
+                    throw new MinionryError('BAD_REQUEST', `git.worktrees.create: unknown baseBranch '${baseBranch}'`);
+                }
+                const base = gitBranches.get(baseBranch ?? MOCK_GIT_DEFAULT_BRANCH);
+                branch = { name: branchName, head: base?.head ?? gitCommits[0]?.hash ?? mintGitHash(), isRemote: false };
+                gitBranches.set(branchName, branch);
+            }
+            const worktree = { path, branch: branchName, isMain: false, staged: [], unstaged: [], untracked: [] };
+            gitWorktrees.set(path, worktree);
+            if (record.assign === true)
+                gitActiveWorktreePath = path;
+            publishGitWorktrees();
+            return { path, branch: branchName, head: branch.head };
+        },
+        'git.worktrees.remove': (params) => {
+            const record = asRecord(params, 'git.worktrees.remove');
+            const path = asString(record.path, 'path', 'git.worktrees.remove');
+            const worktree = gitWorktrees.get(path);
+            if (!worktree)
+                throw new MinionryError('BAD_REQUEST', `git.worktrees.remove: unknown worktree '${path}'`);
+            if (worktree.isMain)
+                throw new MinionryError('BAD_REQUEST', 'git.worktrees.remove: the main worktree cannot be removed');
+            gitWorktrees.delete(path);
+            if (gitActiveWorktreePath === path)
+                gitActiveWorktreePath = null;
+            if (record.deleteBranch === true)
+                gitBranches.delete(worktree.branch);
+            publishGitWorktrees();
+            return null;
+        },
+        'git.worktrees.switchActive': (params) => {
+            const record = asRecord(params, 'git.worktrees.switchActive');
+            const path = record.path === undefined || record.path === null ? null : asString(record.path, 'path', 'git.worktrees.switchActive');
+            if (path !== null && !gitWorktrees.has(path)) {
+                throw new MinionryError('BAD_REQUEST', `git.worktrees.switchActive: unknown worktree '${path}'`);
+            }
+            gitActiveWorktreePath = path;
+            const active = gitWorktrees.get(path ?? MOCK_GIT_MAIN_WORKTREE_PATH);
+            publishGitWorktrees();
+            if (active)
+                publishGitBranchChanged(active);
+            return { path: gitActiveWorktreePath, branch: active?.branch ?? null };
+        },
+        'git.worktrees.subscribe': (_params, requestId) => {
+            gitWorktreeSubscriptions.add(requestId);
+            return { subscribed: true };
+        },
+        'git.merge.preview': (params) => {
+            const record = asRecord(params, 'git.merge.preview');
+            const sourceBranch = asString(record.sourceBranch, 'sourceBranch', 'git.merge.preview');
+            const targetBranch = asString(record.targetBranch, 'targetBranch', 'git.merge.preview');
+            if (!gitBranches.has(sourceBranch))
+                throw new MinionryError('BAD_REQUEST', `git.merge.preview: unknown sourceBranch '${sourceBranch}'`);
+            if (!gitBranches.has(targetBranch))
+                throw new MinionryError('BAD_REQUEST', `git.merge.preview: unknown targetBranch '${targetBranch}'`);
+            return { clean: true, conflicts: [], stat: '0 files changed (mock)', commits: [], ahead: 0 };
+        },
+        'git.merge.run': (params) => {
+            const record = asRecord(params, 'git.merge.run');
+            const sourceBranch = asString(record.sourceBranch, 'sourceBranch', 'git.merge.run');
+            const targetBranch = asString(record.targetBranch, 'targetBranch', 'git.merge.run');
+            const strategy = record.strategy;
+            if (strategy !== 'merge' && strategy !== 'squash' && strategy !== 'rebase') {
+                throw new MinionryError('BAD_REQUEST', "git.merge.run: strategy must be 'merge', 'squash', or 'rebase'");
+            }
+            if (!gitBranches.has(sourceBranch))
+                throw new MinionryError('BAD_REQUEST', `git.merge.run: unknown sourceBranch '${sourceBranch}'`);
+            const target = gitBranches.get(targetBranch);
+            if (!target)
+                throw new MinionryError('BAD_REQUEST', `git.merge.run: unknown targetBranch '${targetBranch}'`);
+            const message = record.commitMessage === undefined
+                ? `Merge '${sourceBranch}' into '${targetBranch}' (mock)`
+                : asString(record.commitMessage, 'commitMessage', 'git.merge.run');
+            const hash = mintGitHash();
+            gitCommits.unshift({
+                hash,
+                shortHash: gitShortHash(hash),
+                subject: message,
+                body: '',
+                author: user?.name ?? 'Mock User',
+                date: new Date().toISOString(),
+                files: [],
+            });
+            target.head = hash;
+            return { success: true, mergeCommit: hash };
+        },
+        'git.merge.abort': () => ({ aborted: true }),
+        'git.merge.complete': () => ({
+            success: true,
+            mergeCommit: gitCommits[0]?.hash ?? mintGitHash(),
+        }),
+        'git.merge.stashPop': (params) => {
+            const record = asRecord(params, 'git.merge.stashPop');
+            asString(record.stashSha, 'stashSha', 'git.merge.stashPop');
+            return { success: true };
+        },
+        'git.merge.discardBlockers': (params) => {
+            const record = asRecord(params, 'git.merge.discardBlockers');
+            const paths = asStringList(record.paths, 'paths', 'git.merge.discardBlockers');
+            return { success: true, paths };
+        },
+        'git.pr.generateDescription': (params) => {
+            const { worktree } = requireWorktree(params, 'git.pr.generateDescription');
+            return {
+                title: `${worktree.branch} (mock)`,
+                body: `Generated description for '${worktree.branch}' (mock).`,
+            };
+        },
+        'git.pr.create': (params) => {
+            const record = asRecord(params, 'git.pr.create');
+            asString(record.title, 'title', 'git.pr.create');
+            const prNumber = ++seq;
+            return {
+                url: `${MOCK_GIT_REMOTE_URL.replace(/\.git$/, '')}/pull/${prNumber}`,
+                method: 'gh',
+                prNumber,
+            };
+        },
+        'git.stage': (params) => {
+            const { worktree, record } = requireWorktree(params, 'git.stage');
+            const stageAll = record.stageAll === true;
+            const paths = stageAll
+                ? [...worktree.unstaged, ...worktree.untracked].map((file) => file.path)
+                : asStringList(record.paths, 'paths', 'git.stage');
+            for (const path of paths)
+                gitStageFile(worktree, path, 'git.stage');
+            return { paths };
+        },
+        'git.unstage': (params) => {
+            const { worktree, record } = requireWorktree(params, 'git.unstage');
+            const paths = asStringList(record.paths, 'paths', 'git.unstage');
+            for (const path of paths)
+                gitUnstageFile(worktree, path, 'git.unstage');
+            return { paths };
+        },
+        'git.commit': (params) => {
+            const { worktree, record } = requireWorktree(params, 'git.commit');
+            const message = asString(record.message, 'message', 'git.commit');
+            if (worktree.staged.length === 0)
+                throw new MinionryError('BAD_REQUEST', 'git.commit: nothing staged to commit');
+            const hash = mintGitHash();
+            const files = worktree.staged.map((file) => ({
+                path: file.path,
+                status: file.status,
+                additions: file.status === 'D' ? 0 : 1,
+                deletions: file.status === 'D' ? 1 : 0,
+            }));
+            gitCommits.unshift({
+                hash,
+                shortHash: gitShortHash(hash),
+                subject: message,
+                body: '',
+                author: user?.name ?? 'Mock User',
+                date: new Date().toISOString(),
+                files,
+            });
+            const branch = gitBranches.get(worktree.branch);
+            if (branch)
+                branch.head = hash;
+            worktree.staged = [];
+            return { hash, message };
+        },
+        'git.generateCommitMessage': (params) => {
+            const { worktree } = requireWorktree(params, 'git.generateCommitMessage');
+            const total = worktree.staged.length;
+            if (total === 0)
+                throw new MinionryError('BAD_REQUEST', 'git.generateCommitMessage: nothing staged to summarize');
+            return { message: `Update ${total} file${total === 1 ? '' : 's'} (mock)` };
+        },
+        'git.checkout': (params) => {
+            const { worktree, record } = requireWorktree(params, 'git.checkout');
+            const branchName = asString(record.branch, 'branch', 'git.checkout');
+            const previous = worktree.branch;
+            if (record.create === true) {
+                if (gitBranches.has(branchName))
+                    throw new MinionryError('BAD_REQUEST', `git.checkout: branch '${branchName}' already exists`);
+                const startPoint = record.startPoint === undefined ? undefined : asString(record.startPoint, 'startPoint', 'git.checkout');
+                const base = gitBranches.get(startPoint ?? previous);
+                if (startPoint !== undefined && !base)
+                    throw new MinionryError('BAD_REQUEST', `git.checkout: unknown startPoint '${startPoint}'`);
+                gitBranches.set(branchName, { name: branchName, head: base?.head ?? gitCommits[0]?.hash ?? mintGitHash(), isRemote: false });
+            }
+            else if (!gitBranches.has(branchName)) {
+                throw new MinionryError('BAD_REQUEST', `git.checkout: unknown branch '${branchName}'`);
+            }
+            worktree.branch = branchName;
+            publishGitBranchChanged(worktree);
+            return { branch: branchName, previous };
+        },
+        'git.push': (params) => {
+            const { worktree, record } = requireWorktree(params, 'git.push');
+            const setUpstream = record.setUpstream === true;
+            const branch = gitBranches.get(worktree.branch);
+            if (branch && setUpstream)
+                branch.upstream = `origin/${worktree.branch}`;
+            return { output: `Pushed '${worktree.branch}' to origin (mock)`, upstream: branch?.upstream };
+        },
+        'git.pull': (params) => {
+            requireWorktree(params, 'git.pull');
+            return { output: 'Already up to date (mock)' };
+        },
+        'git.subscribeBranchChanged': (_params, requestId) => {
+            gitBranchChangeSubscriptions.add(requestId);
+            return { subscribed: true };
+        },
+        'git.subscribeCommitSuggestion': (_params, requestId) => {
+            gitCommitSuggestionSubscriptions.add(requestId);
+            return { subscribed: true };
+        },
+        'tools.register': (params, requestId) => {
+            const record = asRecord(params, 'tools.register');
+            const rawTools = record.tools;
+            if (!Array.isArray(rawTools) || rawTools.length === 0) {
+                throw new MinionryError('BAD_REQUEST', 'tools.register: tools must be a non-empty array');
+            }
+            const rawProfile = record.profile;
+            if (rawProfile !== undefined && rawProfile !== 'browser') {
+                throw new MinionryError('BAD_REQUEST', `tools.register: unknown profile '${String(rawProfile)}' (fail closed)`);
+            }
+            const tools = new Map();
+            for (const raw of rawTools) {
+                const entry = asRecord(raw, 'tools.register');
+                const name = asString(entry.name, 'tools[].name', 'tools.register');
+                if (name.length === 0 || name.includes('__')) {
+                    throw new MinionryError('BAD_REQUEST', `tools.register: invalid tool name '${name}' — must be non-empty and contain no '__'`);
+                }
+                if (tools.has(name))
+                    throw new MinionryError('BAD_REQUEST', `tools.register: duplicate tool name '${name}'`);
+                for (const live of toolRegistrations.values()) {
+                    if (live.tools.has(name)) {
+                        throw new MinionryError('BAD_REQUEST', `tools.register: '${name}' is already served by registration '${live.requestId}'`);
+                    }
+                }
+                const description = asString(entry.description, 'tools[].description', 'tools.register');
+                if (typeof entry.inputSchema !== 'object' || entry.inputSchema === null || Array.isArray(entry.inputSchema)) {
+                    throw new MinionryError('BAD_REQUEST', `tools.register: '${name}' needs an inputSchema object`);
+                }
+                const timeoutMs = entry.timeoutMs;
+                if (timeoutMs !== undefined && (typeof timeoutMs !== 'number' || !Number.isInteger(timeoutMs) || timeoutMs <= 0)) {
+                    throw new MinionryError('BAD_REQUEST', `tools.register: '${name}' timeoutMs must be a positive integer`);
+                }
+                tools.set(name, {
+                    name,
+                    description,
+                    inputSchema: entry.inputSchema,
+                    timeoutMs: timeoutMs,
+                });
+            }
+            toolRegistrations.set(requestId, { requestId, tools, profile: rawProfile });
+            config.tools?.onRegister?.(toolsController);
+            return { registered: true };
+        },
+        'tools.result': (params) => {
+            const record = asRecord(params, 'tools.result');
+            const callId = asString(record.callId, 'callId', 'tools.result');
+            let failure;
+            if (record.ok === false) {
+                const error = asRecord(record.error, 'tools.result');
+                failure = new MinionryError(asString(error.code, 'error.code', 'tools.result'), asString(error.message, 'error.message', 'tools.result'));
+            }
+            else if (record.ok !== true) {
+                throw new MinionryError('BAD_REQUEST', "tools.result: 'ok' must be a boolean");
+            }
+            const call = takeToolCall(callId);
+            if (!call)
+                return null;
+            if (failure)
+                call.fail(failure);
+            else
+                call.settle(record.result);
+            return null;
+        },
+        'quality.state': () => {
+            const drained = qualityPendingResults;
+            qualityPendingResults = [];
+            return {
+                directories: qualityDirectories.map((directory) => ({ ...directory })),
+                reports: Object.fromEntries([...qualityReports].map(([path, report]) => [path, stampQualityReport(report)])),
+                history: qualityHistory.map((entry) => ({ ...entry })),
+                activeOperations: [...qualityRunsByPath.values()].map((run) => ({
+                    kind: run.kind,
+                    path: run.path,
+                    startedAt: run.startedAt,
+                    ...(run.kind === 'reviewing' && run.sessionId !== undefined ? { sessionId: run.sessionId } : {}),
+                })),
+                pendingResults: drained.map((pending) => pending.kind === 'scanResults'
+                    ? { ...pending, report: stampQualityReport(pending.report) }
+                    : { ...pending, findings: stampQualityFindings(pending.path, pending.findings) }),
+                schedules: qualitySchedules.map(cloneQualitySchedule),
+            };
+        },
+        'quality.detectTools': (params) => qualityToolsFor(qualityPathOf(asRecord(params, 'quality.detectTools').path, 'quality.detectTools')),
+        'quality.result': (params, requestId) => {
+            const path = qualityPathOf(asRecord(params, 'quality.result').path, 'quality.result');
+            const run = qualityRunsByPath.get(path);
+            if (run && run.status === 'running') {
+                run.waiters.push(requestId);
+                return DEFER;
+            }
+            const result = qualityResults.get(path);
+            if (!result)
+                throw new MinionryError('BAD_REQUEST', `quality.result: no run for path '${path}'`);
+            return stampQualityResult(result);
+        },
+        'quality.settings': () => ({ ...qualitySettings }),
+        'quality.subscribeChanges': (_params, requestId) => {
+            qualityChangeSubscriptions.add(requestId);
+            return { subscribed: true };
+        },
+        'quality.run': (params, requestId) => {
+            const path = qualityPathOf(asRecord(params, 'quality.run').path, 'quality.run');
+            const existing = qualityRunsByPath.get(path);
+            if (existing) {
+                existing.requestIds.add(requestId);
+                qualityRunsByRequestId.set(requestId, existing);
+                return { path, attached: true };
+            }
+            const sessionId = path === MOCK_QUALITY_PARTIAL_PATH ? undefined : `quality-review-mock-${path}`;
+            const run = {
+                path,
+                status: 'running',
+                kind: 'scanning',
+                startedAt: new Date().toISOString(),
+                requestIds: new Set([requestId]),
+                steps: qualityRunSteps(Date.now(), sessionId),
+                waiters: [],
+                ...(sessionId === undefined ? {} : { sessionId }),
+            };
+            qualityRunsByPath.set(path, run);
+            qualityRunsByRequestId.set(requestId, run);
+            later(() => advanceQualityRun(run));
+            return { path, attached: false };
+        },
+        'quality.cancel': (params) => {
+            const path = qualityPathOf(asRecord(params, 'quality.cancel').path, 'quality.cancel');
+            const run = qualityRunsByPath.get(path);
+            if (run)
+                cancelQualityRun(run);
+            return null;
+        },
+        'quality.installTools': (params) => {
+            const record = asRecord(params, 'quality.installTools');
+            const path = qualityPathOf(record.path, 'quality.installTools');
+            if (qualityRunsByPath.has(path)) {
+                throw new MinionryError('OPERATION_IN_PROGRESS', `quality.installTools: an operation already holds '${path}'`);
+            }
+            const roster = qualityToolsFor(path);
+            const requested = record.tools === undefined
+                ? roster.tools.filter((tool) => !tool.installed).map((tool) => tool.name)
+                : asStringList(record.tools, 'tools', 'quality.installTools');
+            const installed = qualityToolState(path);
+            for (const name of requested) {
+                if (!roster.tools.some((tool) => tool.name === name)) {
+                    throw new MinionryError('BAD_REQUEST', `quality.installTools: unknown tool '${name}' for '${path}'`);
+                }
+                installed.add(name);
+            }
+            const result = qualityToolsFor(path);
+            publishQualityChange({ kind: 'tools', path, tools: result.tools, ecosystem: result.ecosystem });
+            return result;
+        },
+        'quality.saveDirectories': (params) => {
+            const raw = asRecord(params, 'quality.saveDirectories').directories;
+            if (!Array.isArray(raw)) {
+                throw new MinionryError('BAD_REQUEST', 'quality.saveDirectories: directories must be an array');
+            }
+            const next = raw.map((entry) => {
+                const directory = asRecord(entry, 'quality.saveDirectories');
+                return {
+                    path: qualityPathOf(directory.path, 'quality.saveDirectories'),
+                    label: asString(directory.label, 'directories[].label', 'quality.saveDirectories'),
+                };
+            });
+            qualityDirectories = next;
+            publishQualityChange({ kind: 'directories', directories: next.map((directory) => ({ ...directory })) });
+            return null;
+        },
+        'quality.setSettings': (params) => {
+            const record = asRecord(params, 'quality.setSettings');
+            if (record.engine !== undefined)
+                qualitySettings.engine = asString(record.engine, 'engine', 'quality.setSettings');
+            if (record.model !== undefined)
+                qualitySettings.model = asString(record.model, 'model', 'quality.setSettings');
+            if (record.effortLevel !== undefined) {
+                qualitySettings.effortLevel = asString(record.effortLevel, 'effortLevel', 'quality.setSettings');
+            }
+            if (record.fastMode !== undefined) {
+                if (typeof record.fastMode !== 'boolean') {
+                    throw new MinionryError('BAD_REQUEST', "quality.setSettings: 'fastMode' must be a boolean");
+                }
+                qualitySettings.fastMode = record.fastMode;
+            }
+            if (record.agentNotes !== undefined) {
+                if (typeof record.agentNotes !== 'boolean') {
+                    throw new MinionryError('BAD_REQUEST', 'quality.setSettings: agentNotes must be a boolean');
+                }
+                qualitySettings.agentNotes = record.agentNotes;
+            }
+            return { ...qualitySettings };
+        },
+        'quality.schedules.list': () => ({ schedules: qualitySchedules.map(cloneQualitySchedule) }),
+        'quality.schedules.create': (params) => {
+            const method = 'quality.schedules.create';
+            const record = asRecord(params, method);
+            const path = qualityPathOf(record.path, method);
+            const timing = qualityTimingOf(record.timing, method);
+            if (record.enabled !== undefined && typeof record.enabled !== 'boolean') {
+                throw new MinionryError('BAD_REQUEST', `${method}: enabled must be a boolean when present`);
+            }
+            const enabled = record.enabled !== false;
+            const now = Date.now();
+            qualityScheduleCounter += 1;
+            const schedule = {
+                id: `qsched-mock${qualityScheduleCounter}`,
+                createdAt: new Date(now).toISOString(),
+                ...(typeof record.name === 'string' ? { name: record.name } : {}),
+                path,
+                timing,
+                enabled,
+                nextFireAt: enabled ? nextQualityFireAt(timing, now) : null,
+                history: [],
+            };
+            qualitySchedules.push(schedule);
+            publishQualitySchedules();
+            return cloneQualitySchedule(schedule);
+        },
+        'quality.schedules.update': (params) => {
+            const method = 'quality.schedules.update';
+            const record = asRecord(params, method);
+            const schedule = qualityScheduleById(record.scheduleId, method);
+            const patch = record.patch === undefined ? {} : asRecord(record.patch, method);
+            if ('path' in patch)
+                throw new MinionryError('BAD_REQUEST', `${method}: path is immutable — delete and re-create to move a schedule`);
+            if (patch.name !== undefined)
+                schedule.name = asString(patch.name, 'patch.name', method);
+            if (patch.enabled !== undefined) {
+                if (typeof patch.enabled !== 'boolean')
+                    throw new MinionryError('BAD_REQUEST', `${method}: patch.enabled must be a boolean`);
+                schedule.enabled = patch.enabled;
+            }
+            if (patch.timing !== undefined)
+                schedule.timing = qualityTimingOf(patch.timing, method);
+            schedule.nextFireAt = schedule.enabled ? nextQualityFireAt(schedule.timing, Date.now()) : null;
+            publishQualitySchedules();
+            return cloneQualitySchedule(schedule);
+        },
+        'quality.schedules.delete': (params) => {
+            const method = 'quality.schedules.delete';
+            const schedule = qualityScheduleById(asRecord(params, method).scheduleId, method);
+            qualitySchedules.splice(qualitySchedules.indexOf(schedule), 1);
+            publishQualitySchedules();
+            return null;
+        },
+        'quality.setFindingState': (params) => {
+            const method = 'quality.setFindingState';
+            const record = asRecord(params, method);
+            if (typeof record.path !== 'string' || record.path.trim() === '') {
+                throw new MinionryError('BAD_REQUEST', `${method}: path is required (a directory relative to the working directory)`);
+            }
+            const path = record.path.trim();
+            if (path.startsWith('/') || path.split('/').includes('..')) {
+                throw new MinionryError('BAD_REQUEST', `${method}: path '${path}' resolves outside the working directory`);
+            }
+            const raw = record.fingerprints;
+            if (!Array.isArray(raw) || raw.length === 0 || raw.some((entry) => typeof entry !== 'string' || entry === '')) {
+                throw new MinionryError('BAD_REQUEST', `${method}: fingerprints must be a non-empty array of non-empty strings`);
+            }
+            if (raw.length > MOCK_QUALITY_FINGERPRINTS_PER_CALL) {
+                throw new MinionryError('BAD_REQUEST', `${method}: fingerprints holds ${raw.length} entries; at most ${MOCK_QUALITY_FINGERPRINTS_PER_CALL} per call`);
+            }
+            const fingerprints = [...new Set(raw)];
+            if (record.state !== 'dismissed' && record.state !== 'active') {
+                throw new MinionryError('BAD_REQUEST', `${method}: state must be 'dismissed' or 'active'`);
+            }
+            const report = qualityReports.get(path);
+            if (record.state === 'active') {
+                let applied = 0;
+                for (const fingerprint of fingerprints) {
+                    if (qualitySuppressions.delete(qualitySuppressionKey(path, fingerprint)))
+                        applied++;
+                }
+                if (report)
+                    publishQualityChange({ kind: 'results', path, report });
+                return { applied, dropped: 0 };
+            }
+            const reason = typeof record.reason === 'string' ? record.reason.trim() : '';
+            if (reason === '' || reason.length > MOCK_QUALITY_REASON_MAX) {
+                throw new MinionryError('BAD_REQUEST', `${method}: reason is required to dismiss (1–${MOCK_QUALITY_REASON_MAX} characters after trimming)`);
+            }
+            const known = new Map();
+            for (const finding of [...(report?.findings ?? []), ...(report?.codeReview ?? [])]) {
+                if (finding.fingerprint !== undefined && !known.has(finding.fingerprint))
+                    known.set(finding.fingerprint, finding);
+            }
+            const unknown = fingerprints.filter((fingerprint) => !known.has(fingerprint));
+            if (!report || unknown.length > 0) {
+                throw new MinionryError('BAD_REQUEST', `${method}: unknown fingerprint(s) for '${path}': ${unknown.join(', ')}`);
+            }
+            const dismissedAt = new Date().toISOString();
+            let applied = 0;
+            for (const fingerprint of fingerprints) {
+                const finding = known.get(fingerprint);
+                if (!finding)
+                    continue;
+                qualitySuppressions.set(qualitySuppressionKey(path, fingerprint), {
+                    fingerprint,
+                    path,
+                    reason,
+                    dismissedAt,
+                    title: finding.title,
+                    file: finding.file,
+                });
+                applied++;
+            }
+            publishQualityChange({ kind: 'results', path, report });
+            return { applied, dropped: 0 };
+        },
+    };
+    const scopeParams = (params) => typeof params === 'object' && params !== null && !Array.isArray(params) ? params : {};
+    const resolveScope = (method, params) => {
+        if (FILES_READ_PATH_METHODS.has(method)) {
+            const path = scopeParams(params).path;
+            return typeof path === 'string' ? resolveFilesReadScope(path) : 'files:app';
+        }
+        if (FILES_WRITE_PATH_METHODS.has(method)) {
+            const path = scopeParams(params).path;
+            return typeof path === 'string' ? resolveFilesWriteScope(path) : 'files:app';
+        }
+        if (method === 'files.uploadChunk' || method === 'files.uploadStatus' || method === 'files.uploadCancel') {
+            const uploadId = scopeParams(params).uploadId;
+            return typeof uploadId === 'string' ? (uploads.get(uploadId)?.scope ?? null) : null;
+        }
+        if (method === 'files.downloadChunk' || method === 'files.downloadCancel') {
+            const downloadId = scopeParams(params).downloadId;
+            return typeof downloadId === 'string' ? (downloads.get(downloadId)?.scope ?? null) : null;
+        }
+        return METHOD_SCOPES[method];
+    };
+    const dispatch = (frame) => {
+        const { requestId, method } = frame;
+        const forced = forcedErrors[method];
+        if (forced !== undefined) {
+            fail(requestId, { code: forced, message: `mock: forced '${forced}' for ${method} (MockConfig.errors)` });
+            return;
+        }
+        if (!Object.prototype.hasOwnProperty.call(METHOD_SCOPES, method)) {
+            fail(requestId, { code: 'SCOPE_DENIED', message: `mock: unknown method '${String(method)}' (fail closed)` });
+            return;
+        }
+        const scope = resolveScope(method, frame.params);
+        if (scope !== null && !granted.has(scope)) {
+            const hint = granted.size === 0 ? 'call connect() first' : 'not granted on connect';
+            fail(requestId, { code: 'SCOPE_DENIED', message: `mock: ${method} requires scope '${scope}' — ${hint}` });
+            return;
+        }
+        try {
+            const result = methodHandlers[method](frame.params, requestId);
+            if (result !== DEFER)
+                respond(requestId, result);
+        }
+        catch (cause) {
+            if (cause instanceof MinionryError)
+                fail(requestId, { code: cause.code, message: cause.message });
+            else
+                fail(requestId, { code: 'INTERNAL', message: `mock: ${method} handler threw (${String(cause)})` });
+        }
+    };
+    return {
+        start(startHandlers) {
+            if (closed)
+                throw new Error('mock transport is closed');
+            if (handlers)
+                throw new Error('mock transport already started — create one transport per provider');
+            handlers = startHandlers;
+        },
+        send(frame) {
+            if (!handlers)
+                throw new Error('mock transport not started');
+            if (closed)
+                throw new Error('mock transport is closed');
+            dispatch(frame);
+        },
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            for (const id of timers)
+                clearTimeout(id);
+            timers.clear();
+            for (const requestId of [...toolRegistrations.keys()])
+                retireToolRegistration(requestId);
+            handlers?.onClose();
+        },
+    };
+}
+export function mock(config = {}) {
+    return createProvider(createMockTransport(config));
+}