@minionry/sdk 0.4.23 → 0.5.2

package/dist/transports/mock.js

@@ -45,7 +45,16 @@ const MOCK_FEATURES = [
     'agentsAppEndpoint',
     'qualityFindingState',
     'agentsModelSelection',
+    'filesChangeKinds',
+    'filesConditionalWrite',
+    'inferenceFastMode',
     'qualitySchedules',
+    'pmChains',
+    'agentsEngineSelection',
+    'agentSchedules',
+    'scheduleWallClock',
+    'pmScheduleZip',
+    'pmScheduleRunNow',
 ];
 const DEFAULT_BROWSER_TABS = [
     {
@@ -111,6 +120,11 @@ const METHOD_SCOPES = {
     'agents.sessions.answerQuestion': 'agents:sessions',
     'agents.sessions.prompt': 'agents:sessions',
     'agents.sessions.stop': 'agents:sessions',
+    'agents.schedules.list': 'agents:schedule',
+    'agents.schedules.create': 'agents:schedule',
+    'agents.schedules.update': 'agents:schedule',
+    'agents.schedules.delete': 'agents:schedule',
+    'agents.schedules.runNow': 'agents:schedule',
     'apps.open': null,
     cancel: null,
     'pm.createBoard': 'pm:write',
@@ -130,6 +144,11 @@ const METHOD_SCOPES = {
     'pm.schedules.create': 'pm:schedule',
     'pm.schedules.update': 'pm:schedule',
     'pm.schedules.delete': 'pm:schedule',
+    'pm.schedules.runNow': 'pm:schedule',
+    'pm.chains.list': 'pm:chain',
+    'pm.chains.create': 'pm:chain',
+    'pm.chains.update': 'pm:chain',
+    'pm.chains.delete': 'pm:chain',
     'files.read': 'files:app',
     'files.readEntry': 'files:app',
     'files.write': 'files:app',
@@ -271,16 +290,19 @@ const MOCK_ENDPOINT_REGISTER_KEYS = new Set([
 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_PARAMS_SHAPE = '{ prompt, title?, model?, modelSelection?, engineSelection?, systemPrompt?, budget?: { maxTurns?, maxSeconds? }, sessionId? }';
 const MOCK_RUN_PARAM_KEYS = new Set([
     'prompt',
     'title',
     'model',
     'modelSelection',
+    'engineSelection',
     'systemPrompt',
     'budget',
     'sessionId',
 ]);
+const MOCK_ENGINE_SELECTION_SHAPE = '{ engine?, model?, effortLevel?, fastMode? }';
+const MOCK_ENGINE_SELECTION_KEYS = new Set(['engine', 'model', 'effortLevel', 'fastMode']);
 const MOCK_RUN_BUDGET_KEYS = new Set(['maxTurns', 'maxSeconds']);
 const utf8ByteLength = (value) => new TextEncoder().encode(value).length;
 function mockValidateEndpointUrl(value) {
@@ -314,6 +336,7 @@ function mockValidateEndpointUrl(value) {
     }
     return { ok: true };
 }
+const MOCK_SCHEDULE_MIN_LATENESS_MS = 60_000;
 const MOCK_TOOL_CALL_TIMEOUT_MS = 30_000;
 const MOCK_TOOL_CALL_TIMEOUT_MAX_MS = 120_000;
 const MOCK_GIT_MAIN_WORKTREE_PATH = '/workspace';
@@ -730,6 +753,11 @@ const mockQualityHistoryEntry = (report) => ({
 });
 const MOCK_QUALITY_FINGERPRINTS_PER_CALL = 1_000;
 const MOCK_QUALITY_REASON_MAX = 500;
+const MAX_CHAIN_DEPTH = 5;
+const MAX_OUT_LINKS_PER_BOARD = 3;
+const MAX_LINKS_PER_APP = 20;
+const MAX_LINKS_PER_SPACE = 100;
+const MAX_CHAIN_HISTORY = 20;
 export function createMockTransport(config = {}) {
     const space = { ...DEFAULT_SPACE, ...config.space };
     const user = config.user === null ? null : { ...DEFAULT_USER, ...config.user };
@@ -746,6 +774,13 @@ export function createMockTransport(config = {}) {
     const files = new Map(Object.entries(config.files ?? {}));
     const dirs = new Set();
     const timestamps = new Map();
+    let lastStamp = 0;
+    const stamp = (path) => {
+        lastStamp = Math.max(Date.now(), lastStamp + 1);
+        timestamps.set(path, new Date(lastStamp).toISOString());
+    };
+    for (const path of files.keys())
+        stamp(path);
     const uploads = new Map();
     const downloads = new Map();
     const storage = new Map();
@@ -763,6 +798,8 @@ export function createMockTransport(config = {}) {
     const execRunsByRunId = new Map();
     const execRunsByRequestId = new Map();
     const schedules = new Map();
+    const agentSchedules = new Map();
+    const chainLinks = new Map();
     const fileChangeSubscriptions = new Map();
     const browserTabs = DEFAULT_BROWSER_TABS.map((tab) => ({ ...tab }));
     let currentTabId = browserTabs[0]?.id ?? null;
@@ -879,6 +916,108 @@ export function createMockTransport(config = {}) {
         }
         return value;
     };
+    const isValidTimeZone = (value) => {
+        if (typeof value !== 'string' || value === '')
+            return false;
+        try {
+            new Intl.DateTimeFormat('en-US', { timeZone: value });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    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 second = guess - zoneOffsetMs(first, timeZone);
+        const landed = zonedParts(second, timeZone);
+        if (landed.hh === hh && landed.mm === mm)
+            return second;
+        return Math.max(first, second);
+    };
+    const nextDailyFireAt = (timing, from) => {
+        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 nextMonthlyFireAt = (timing, from) => {
+        const [hh, mm] = timing.time.split(':').map(Number);
+        const today = zonedParts(from, timing.timeZone);
+        for (let offset = 0; offset < 13; offset++) {
+            const monthIndex = today.m - 1 + offset;
+            const year = today.y + Math.floor(monthIndex / 12);
+            const month = (monthIndex % 12) + 1;
+            const lastDay = new Date(Date.UTC(year, month, 0)).getUTCDate();
+            const day = timing.dayOfMonth === 'last' ? lastDay : timing.dayOfMonth;
+            if (day > lastDay)
+                continue;
+            const candidate = zonedWallTimeToInstant(year, month, day, hh, mm, timing.timeZone);
+            if (candidate <= from)
+                continue;
+            return new Date(candidate).toISOString();
+        }
+        return new Date(from + 31 * 24 * 60 * 60 * 1000).toISOString();
+    };
+    const wallClockTimingOf = (t, method) => {
+        if (typeof t.time !== 'string' || !/^([01]\d|2[0-3]):[0-5]\d$/.test(t.time)) {
+            throw new MinionryError('BAD_REQUEST', `${method}: timing.time must be 24-hour HH:MM`);
+        }
+        if (!isValidTimeZone(t.timeZone))
+            throw new MinionryError('BAD_REQUEST', `${method}: timing.timeZone must be an IANA zone name`);
+        if (t.kind === 'monthly') {
+            const dayOfMonth = t.dayOfMonth;
+            if (dayOfMonth !== 'last' && !(Number.isInteger(dayOfMonth) && dayOfMonth >= 1 && dayOfMonth <= 31)) {
+                throw new MinionryError('BAD_REQUEST', `${method}: timing.dayOfMonth must be 1–31 or 'last'`);
+            }
+            return { kind: 'monthly', time: t.time, timeZone: t.timeZone, dayOfMonth: dayOfMonth };
+        }
+        const timing = { kind: 'daily', time: t.time, timeZone: t.timeZone };
+        if (t.days !== undefined) {
+            if (!Array.isArray(t.days) || t.days.length === 0 || t.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(t.days)].sort((a, b) => a - b);
+        }
+        return timing;
+    };
     const mockScheduleTiming = (raw, method) => {
         if (typeof raw !== 'object' || raw === null) {
             throw new MinionryError('BAD_REQUEST', `${method}: timing must be an object`);
@@ -892,8 +1031,31 @@ export function createMockTransport(config = {}) {
         }
         if (t.kind === 'continuous')
             return { kind: 'continuous' };
+        if (t.kind === 'daily' || t.kind === 'monthly')
+            return wallClockTimingOf(t, method);
         throw new MinionryError('BAD_REQUEST', `${method}: invalid timing`);
     };
+    const mockAgentScheduleTiming = (raw, method) => {
+        const timing = mockScheduleTiming(raw, method);
+        if (timing.kind === 'continuous') {
+            throw new MinionryError('BAD_REQUEST', `${method}: timing must be {kind:'once',at}, {kind:'interval',everyMs}, {kind:'daily',time,timeZone,days?} or {kind:'monthly',time,timeZone,dayOfMonth} — 'continuous' is not supported for agent-prompt schedules`);
+        }
+        return timing;
+    };
+    const mockMaxLatenessMs = (raw, method) => {
+        if (typeof raw !== 'number' || !Number.isInteger(raw) || raw < MOCK_SCHEDULE_MIN_LATENESS_MS) {
+            throw new MinionryError('BAD_REQUEST', `${method}: maxLatenessMs must be an integer >= the schedule minimum, or null to clear it`);
+        }
+        return raw;
+    };
+    const patchMaxLatenessMs = (target, raw, method) => {
+        if (raw === undefined)
+            return;
+        if (raw === null)
+            delete target.maxLatenessMs;
+        else
+            target.maxLatenessMs = mockMaxLatenessMs(raw, method);
+    };
     const mockNextFireAt = (timing, from) => {
         if (timing.kind === 'once') {
             const at = new Date(timing.at);
@@ -901,8 +1063,220 @@ export function createMockTransport(config = {}) {
         }
         if (timing.kind === 'interval')
             return new Date(from.getTime() + timing.everyMs).toISOString();
+        if (timing.kind === 'daily')
+            return nextDailyFireAt(timing, from.getTime());
+        if (timing.kind === 'monthly')
+            return nextMonthlyFireAt(timing, from.getTime());
         return null;
     };
+    const workspaceFileParam = (raw, field, method) => {
+        if (typeof raw !== 'string' || !raw.startsWith(WORKSPACE_PATH_PREFIX)) {
+            throw new MinionryError('BAD_REQUEST', `${method}: ${field} must be a workspace-rooted path ('${WORKSPACE_PATH_PREFIX}/<path>')`);
+        }
+        const rel = raw.slice(WORKSPACE_PATH_PREFIX.length).replace(/^\/+/, '');
+        if (rel === '' || rel.split('/').some((segment) => segment === '..')) {
+            throw new MinionryError('BAD_REQUEST', `${method}: ${field} '${raw}' must not be empty or contain a '..' segment`);
+        }
+        if (!files.has(raw))
+            throw new MinionryError('BAD_REQUEST', `${method}: ${field} '${raw}' does not exist`);
+        return raw;
+    };
+    const promptFileContent = (path, method) => {
+        const content = (files.get(path) ?? '').trim();
+        if (content === '')
+            throw new MinionryError('BAD_REQUEST', `${method}: promptFile '${path}' is empty after trimming`);
+        return content;
+    };
+    const cloneAgentSchedule = (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 ownedAgentScheduleById = (value, method) => {
+        const id = asString(value, 'scheduleId', method);
+        const schedule = agentSchedules.get(id);
+        if (!schedule || schedule.initiator.appId !== MOCK_ENDPOINT_APP_ID) {
+            throw new MinionryError('BAD_REQUEST', `schedule '${id}' not found in this Space`);
+        }
+        return schedule;
+    };
+    const chainBoardStatus = (board) => (board.completedAt ? 'completed' : board.status);
+    const chainToSnapshot = (link) => ({
+        id: link.id,
+        from: link.from,
+        to: link.to,
+        on: link.on,
+        passOutputs: link.passOutputs,
+        name: link.name,
+        enabled: link.enabled,
+        state: link.state,
+        createdAt: link.createdAt,
+        ownedByCaller: true,
+        history: link.history,
+    });
+    const chainArmedEdges = (extra) => {
+        const edges = [...chainLinks.values()]
+            .filter((link) => link.state === 'armed')
+            .map((link) => ({ from: link.from, to: link.to }));
+        if (extra)
+            edges.push(extra);
+        return edges;
+    };
+    const chainGraphHasCycle = (edges) => {
+        const adjacency = new Map();
+        for (const edge of edges) {
+            const list = adjacency.get(edge.from);
+            if (list)
+                list.push(edge.to);
+            else
+                adjacency.set(edge.from, [edge.to]);
+        }
+        const color = new Map();
+        const visit = (node) => {
+            color.set(node, 'gray');
+            for (const next of adjacency.get(node) ?? []) {
+                const state = color.get(next);
+                if (state === 'gray')
+                    return true;
+                if (state !== 'black' && visit(next))
+                    return true;
+            }
+            color.set(node, 'black');
+            return false;
+        };
+        for (const node of adjacency.keys()) {
+            if (!color.has(node) && visit(node))
+                return true;
+        }
+        return false;
+    };
+    const chainGraphDepthThrough = (edges, target) => {
+        const incoming = new Map();
+        for (const edge of edges) {
+            const list = incoming.get(edge.to);
+            if (list)
+                list.push(edge.from);
+            else
+                incoming.set(edge.to, [edge.from]);
+        }
+        const memo = new Map();
+        const longestTo = (node, path) => {
+            const cached = memo.get(node);
+            if (cached !== undefined)
+                return cached;
+            if (path.has(node))
+                return 1;
+            path.add(node);
+            let best = 0;
+            for (const predecessor of incoming.get(node) ?? [])
+                best = Math.max(best, longestTo(predecessor, path));
+            path.delete(node);
+            const depth = best + 1;
+            memo.set(node, depth);
+            return depth;
+        };
+        return longestTo(target, new Set());
+    };
+    const chainPushHistory = (link, entry) => {
+        link.history.push(entry);
+        if (link.history.length > MAX_CHAIN_HISTORY)
+            link.history.splice(0, link.history.length - MAX_CHAIN_HISTORY);
+    };
+    const CHAIN_ERROR = {
+        boardGone: 'target board no longer exists',
+        notRunnable: 'target board is not runnable',
+        noIssues: 'target board has no issues',
+    };
+    const settleBoardImpl = (boardId, outcome) => {
+        const at = new Date().toISOString();
+        for (const link of chainLinks.values()) {
+            if (link.from !== boardId || !link.enabled || link.state !== 'armed')
+                continue;
+            const matched = link.on === 'settled' || link.on === outcome;
+            if (!matched) {
+                chainPushHistory(link, {
+                    at,
+                    completedAt: at,
+                    status: 'skipped',
+                    upstreamOutcome: outcome,
+                    downstreamBoardId: null,
+                    skipReason: 'condition_not_met',
+                });
+                continue;
+            }
+            const edges = chainArmedEdges();
+            if (chainGraphHasCycle(edges)) {
+                chainPushHistory(link, {
+                    at,
+                    completedAt: at,
+                    status: 'skipped',
+                    upstreamOutcome: outcome,
+                    downstreamBoardId: null,
+                    skipReason: 'cycle',
+                });
+                link.state = 'disabled';
+                continue;
+            }
+            if (chainGraphDepthThrough(edges, link.to) > MAX_CHAIN_DEPTH) {
+                chainPushHistory(link, {
+                    at,
+                    completedAt: at,
+                    status: 'skipped',
+                    upstreamOutcome: outcome,
+                    downstreamBoardId: null,
+                    skipReason: 'max_depth',
+                });
+                link.state = 'disabled';
+                continue;
+            }
+            const toBoard = boards.get(link.to);
+            const nonEpicIssues = toBoard?.issues.filter((issue) => issue.type !== 'epic') ?? [];
+            if (!toBoard) {
+                chainPushHistory(link, {
+                    at,
+                    completedAt: at,
+                    status: 'failed',
+                    upstreamOutcome: outcome,
+                    downstreamBoardId: null,
+                    error: CHAIN_ERROR.boardGone,
+                });
+            }
+            else if (chainBoardStatus(toBoard) === 'completed' || chainBoardStatus(toBoard) === 'archived') {
+                chainPushHistory(link, {
+                    at,
+                    completedAt: at,
+                    status: 'failed',
+                    upstreamOutcome: outcome,
+                    downstreamBoardId: null,
+                    error: CHAIN_ERROR.notRunnable,
+                });
+            }
+            else if (nonEpicIssues.length === 0) {
+                chainPushHistory(link, {
+                    at,
+                    completedAt: at,
+                    status: 'failed',
+                    upstreamOutcome: outcome,
+                    downstreamBoardId: null,
+                    error: CHAIN_ERROR.noIssues,
+                });
+            }
+            else {
+                chainPushHistory(link, {
+                    at,
+                    completedAt: at,
+                    status: 'started',
+                    upstreamOutcome: outcome,
+                    downstreamBoardId: link.to,
+                    downstreamRunId: `chain-run-mock-${++seq}`,
+                });
+            }
+            link.state = 'fired';
+        }
+    };
+    const chainsController = { settleBoard: settleBoardImpl };
+    config.chains?.onReady?.(chainsController);
     const settleWaiters = (run) => {
         if (run.status === 'running')
             return;
@@ -1015,6 +1389,55 @@ export function createMockTransport(config = {}) {
         }
         return name;
     };
+    const admitEngineSelection = (raw) => {
+        if (raw === undefined)
+            return undefined;
+        if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+            throw new MinionryError('BAD_REQUEST', `agents.run engineSelection must be an object ${MOCK_ENGINE_SELECTION_SHAPE}`);
+        }
+        const record = raw;
+        refuseUnknownKeys(record, MOCK_ENGINE_SELECTION_KEYS, 'agents.run engineSelection', MOCK_ENGINE_SELECTION_SHAPE);
+        const nonEmptyString = (value, field) => {
+            if (value === undefined)
+                return undefined;
+            if (typeof value !== 'string' || value === '') {
+                throw new MinionryError('BAD_REQUEST', `agents.run engineSelection.${field} must be a non-empty string when present`);
+            }
+            return value;
+        };
+        const engine = nonEmptyString(record.engine, 'engine');
+        const model = nonEmptyString(record.model, 'model');
+        const effortLevel = nonEmptyString(record.effortLevel, 'effortLevel');
+        if (record.fastMode !== undefined && typeof record.fastMode !== 'boolean') {
+            throw new MinionryError('BAD_REQUEST', 'agents.run engineSelection.fastMode must be a boolean when present');
+        }
+        const fastMode = record.fastMode === true;
+        if (!granted.has('settings:read')) {
+            throw new MinionryError('SCOPE_DENIED', 'agents.run: engineSelection needs the settings:read scope');
+        }
+        if (engine !== undefined && !MOCK_ENGINES.includes(engine)) {
+            throw new MinionryError('BAD_REQUEST', `agents.run engineSelection: unknown engine '${engine}' — expected one of ${MOCK_ENGINES.join(', ')}`);
+        }
+        const resolvedEngine = engine ?? (model ? mockEngineForModel(model) : MOCK_DEFAULT_ENGINE);
+        if (!resolvedAgentRunEngines.includes(resolvedEngine)) {
+            throw new MinionryError('ENGINE_UNAVAILABLE', `agents.run: ${resolvedEngine} cannot run a confined app session with tools on this host`);
+        }
+        if (model && mockEngineForModel(model) !== resolvedEngine) {
+            throw new MinionryError('BAD_REQUEST', `agents.run: engineSelection model '${model}' is not a ${resolvedEngine} model — it belongs to ${mockEngineForModel(model)}`);
+        }
+        if (effortLevel !== undefined && effortLevel !== 'auto' && !MOCK_EFFORT_LEVELS[resolvedEngine]?.includes(effortLevel)) {
+            throw new MinionryError('BAD_REQUEST', `agents.run: engineSelection effortLevel '${effortLevel}' is not a ${resolvedEngine} effort level`);
+        }
+        if (fastMode && resolvedEngine !== 'claude-code') {
+            throw new MinionryError('BAD_REQUEST', `agents.run: engineSelection.fastMode is a claude-code setting — ${resolvedEngine} has no fast mode`);
+        }
+        return {
+            ...(engine !== undefined ? { engine } : {}),
+            ...(model !== undefined ? { model } : {}),
+            ...(effortLevel !== undefined ? { effortLevel } : {}),
+            ...(fastMode ? { fastMode } : {}),
+        };
+    };
     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');
@@ -1030,7 +1453,7 @@ export function createMockTransport(config = {}) {
         };
         const model = optional('model');
         const sessionId = optional('sessionId');
-        const { systemPrompt, budget, modelSelection } = record;
+        const { systemPrompt, budget, modelSelection, engineSelection } = 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`);
         }
@@ -1058,6 +1481,21 @@ export function createMockTransport(config = {}) {
             throw new MinionryError('BAD_REQUEST', 'agents.run systemPrompt and budget apply only to a run on an app-registered model — pass model');
         }
         admitModelSelection(modelSelection);
+        if (engineSelection !== undefined) {
+            const conflicts = [
+                ['model', model !== undefined],
+                ['modelSelection', modelSelection !== undefined],
+                ['systemPrompt', systemPrompt !== undefined],
+                ['budget', budget !== undefined],
+                ['sessionId', sessionId !== undefined],
+            ]
+                .filter(([, present]) => present)
+                .map(([field]) => field);
+            if (conflicts.length > 0) {
+                throw new MinionryError('BAD_REQUEST', `agents.run engineSelection is not allowed alongside ${conflicts.join(', ')} — pass only one way of choosing the run's engine or model`);
+            }
+        }
+        admitEngineSelection(engineSelection);
         return { prompt, title, model, sessionId };
     };
     const endpointRunSteps = (endpoint, prompt, turn) => {
@@ -1269,14 +1707,28 @@ export function createMockTransport(config = {}) {
         run.issueIndex += 1;
         later(() => advanceExec(run));
     };
-    const notifyMockFileChanged = (path, kind) => {
+    const withinMockRoot = (root, path) => {
+        const base = root === '.' ? '' : root.replace(/\/+$/, '');
+        if (base === '' || path === base)
+            return path.slice(base.length);
+        return path.startsWith(`${base}/`) ? path.slice(base.length + 1) : undefined;
+    };
+    const notifyMockFileChanged = (path, kind, dir = false, newPath) => {
         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 from = withinMockRoot(root, path);
+            const to = newPath === undefined ? undefined : withinMockRoot(root, newPath);
+            let change;
+            if (from !== undefined) {
+                change = to !== undefined ? { path: from, kind, newPath: to } : { path: from, kind: newPath === undefined ? kind : 'deleted' };
+            }
+            else if (to !== undefined) {
+                change = { path: to, kind: 'created' };
+            }
+            if (change)
+                emit(requestId, 'changed', dir ? { ...change, dir } : change);
         }
     };
+    const isMockDir = (path) => dirs.has(path) || [...files.keys(), ...dirs].some((key) => key.startsWith(`${path}/`));
     const browserTabsPayload = () => ({
         tabs: browserTabs.map((tab) => ({ ...tab })),
         currentTabId,
@@ -1374,6 +1826,10 @@ export function createMockTransport(config = {}) {
         hermes: [],
     };
     const MOCK_INFERENCE_ENGINES = ['claude-code'];
+    const MOCK_AGENT_RUN_ENGINES = ['claude-code'];
+    const resolvedAgentRunEngines = config.agentRunEngines === null || config.agentRunEngines === undefined
+        ? MOCK_AGENT_RUN_ENGINES
+        : config.agentRunEngines;
     const mockInferenceMessages = (raw) => {
         const valid = Array.isArray(raw) &&
             raw.length > 0 &&
@@ -1675,17 +2131,6 @@ export function createMockTransport(config = {}) {
         ...(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') {
@@ -1710,56 +2155,7 @@ export function createMockTransport(config = {}) {
         }
         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 nextQualityFireAt = (timing, from) => timing.kind === 'interval' ? new Date(from + timing.everyMs).toISOString() : nextDailyFireAt(timing, from);
     const publishQualitySchedules = () => {
         publishQualityChange({ kind: 'schedules', schedules: qualitySchedules.map(cloneQualitySchedule) });
     };
@@ -2146,6 +2542,13 @@ export function createMockTransport(config = {}) {
             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 (record.fastMode !== undefined && typeof record.fastMode !== 'boolean') {
+                throw new MinionryError('BAD_REQUEST', 'inference.chat: fastMode must be a boolean');
+            }
+            const fastMode = record.fastMode === true;
+            if (fastMode && resolvedEngine !== 'claude-code') {
+                throw new MinionryError('BAD_REQUEST', `inference.chat: fastMode is a claude-code setting — ${resolvedEngine} has no fast mode`);
+            }
             if (!MOCK_INFERENCE_ENGINES.includes(resolvedEngine)) {
                 throw new MinionryError('UNSUPPORTED', `inference.chat: ${resolvedEngine} cannot run a tool-less completion on this host`);
             }
@@ -2164,9 +2567,10 @@ export function createMockTransport(config = {}) {
                 status: 'running',
                 engine: resolvedEngine,
                 ...(resolvedModel ? { model: resolvedModel } : {}),
+                ...(fastMode ? { fastMode } : {}),
                 text: '',
                 deltas: [
-                    `(mock ${resolvedEngine}${resolvedModel ? ` · ${resolvedModel}` : ''}) `,
+                    `(mock ${resolvedEngine}${resolvedModel ? ` · ${resolvedModel}` : ''}${fastMode ? ' · fast' : ''}) `,
                     prompt.length > 120 ? `${prompt.slice(0, 119)}…` : prompt,
                 ],
                 waiters: [],
@@ -2372,6 +2776,127 @@ export function createMockTransport(config = {}) {
             session.isExecuting = false;
             return null;
         },
+        'agents.schedules.list': () => ({
+            schedules: [...agentSchedules.values()]
+                .filter((schedule) => schedule.initiator.appId === MOCK_ENDPOINT_APP_ID)
+                .map((schedule) => cloneAgentSchedule(schedule.snapshot)),
+        }),
+        'agents.schedules.create': (params) => {
+            const method = 'agents.schedules.create';
+            const record = asRecord(params, method);
+            const hasPrompt = record.prompt !== undefined;
+            const hasPromptFile = record.promptFile !== undefined;
+            if (hasPrompt === hasPromptFile) {
+                throw new MinionryError('BAD_REQUEST', `${method} requires exactly one of params.prompt or params.promptFile`);
+            }
+            let prompt;
+            let promptFile;
+            if (hasPromptFile) {
+                promptFile = workspaceFileParam(record.promptFile, 'promptFile', method);
+                prompt = promptFileContent(promptFile, method);
+            }
+            else {
+                if (typeof record.prompt !== 'string' || record.prompt.trim() === '') {
+                    throw new MinionryError('BAD_REQUEST', `${method}: params.prompt must be a non-empty string`);
+                }
+                prompt = record.prompt.trim();
+            }
+            const timing = mockAgentScheduleTiming(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 now = new Date();
+            const snapshot = {
+                id: `agsched-mock-${++seq}`,
+                createdAt: now.toISOString(),
+                prompt,
+                timing,
+                enabled: record.enabled !== false,
+                nextFireAt: mockNextFireAt(timing, now),
+                history: [],
+            };
+            if (typeof record.name === 'string')
+                snapshot.name = record.name;
+            if (promptFile !== undefined)
+                snapshot.promptFile = promptFile;
+            if (record.maxLatenessMs !== undefined)
+                snapshot.maxLatenessMs = mockMaxLatenessMs(record.maxLatenessMs, method);
+            agentSchedules.set(snapshot.id, { snapshot, initiator: { appId: MOCK_ENDPOINT_APP_ID } });
+            return cloneAgentSchedule(snapshot);
+        },
+        'agents.schedules.update': (params) => {
+            const method = 'agents.schedules.update';
+            const record = asRecord(params, method);
+            const { snapshot } = ownedAgentScheduleById(record.scheduleId, method);
+            if (typeof record.patch !== 'object' || record.patch === null || Array.isArray(record.patch)) {
+                throw new MinionryError('BAD_REQUEST', `${method} requires params.patch to be an object`);
+            }
+            const patch = record.patch;
+            if (patch.prompt !== undefined && patch.promptFile !== undefined) {
+                throw new MinionryError('BAD_REQUEST', `${method}: provide at most one of patch.prompt or patch.promptFile`);
+            }
+            if (patch.name !== undefined)
+                snapshot.name = asString(patch.name, 'patch.name', method);
+            if (patch.prompt !== undefined) {
+                if (typeof patch.prompt !== 'string' || patch.prompt.trim() === '') {
+                    throw new MinionryError('BAD_REQUEST', `${method}: patch.prompt must be a non-empty string`);
+                }
+                snapshot.prompt = patch.prompt.trim();
+                delete snapshot.promptFile;
+            }
+            if (patch.promptFile !== undefined) {
+                const promptFile = workspaceFileParam(patch.promptFile, 'promptFile', method);
+                snapshot.prompt = promptFileContent(promptFile, method);
+                snapshot.promptFile = promptFile;
+            }
+            if (patch.enabled !== undefined) {
+                if (typeof patch.enabled !== 'boolean')
+                    throw new MinionryError('BAD_REQUEST', `${method}: patch.enabled must be a boolean when present`);
+                snapshot.enabled = patch.enabled;
+            }
+            if (patch.timing !== undefined) {
+                snapshot.timing = mockAgentScheduleTiming(patch.timing, method);
+                snapshot.nextFireAt = mockNextFireAt(snapshot.timing, new Date());
+            }
+            patchMaxLatenessMs(snapshot, patch.maxLatenessMs, method);
+            return cloneAgentSchedule(snapshot);
+        },
+        'agents.schedules.delete': (params) => {
+            const method = 'agents.schedules.delete';
+            const { snapshot } = ownedAgentScheduleById(asRecord(params, method).scheduleId, method);
+            agentSchedules.delete(snapshot.id);
+            return null;
+        },
+        'agents.schedules.runNow': (params) => {
+            const method = 'agents.schedules.runNow';
+            const { snapshot } = ownedAgentScheduleById(asRecord(params, method).scheduleId, method);
+            if (!snapshot.enabled) {
+                throw new MinionryError('BAD_REQUEST', `schedule '${snapshot.id}' is disabled — enable it before running it now`);
+            }
+            const now = new Date().toISOString();
+            let entry;
+            const content = snapshot.promptFile === undefined ? snapshot.prompt : (files.get(snapshot.promptFile) ?? '').trim();
+            if (content === '') {
+                entry = { at: now, status: 'failed', tabId: null, error: `promptFile '${snapshot.promptFile}' is missing or empty` };
+            }
+            else {
+                snapshot.prompt = content;
+                const tabId = `session-mock-${++seq}`;
+                sessions.set(tabId, {
+                    id: tabId,
+                    name: snapshot.name ?? `Session ${sessions.size + 1}`,
+                    createdAt: now,
+                    lastActivityAt: now,
+                    isExecuting: false,
+                    entries: [],
+                    seq: 0,
+                });
+                entry = { at: now, status: 'started', tabId };
+            }
+            snapshot.lastFire = { at: entry.at, tabId: entry.tabId, status: entry.status };
+            snapshot.history.push(entry);
+            return cloneAgentSchedule(snapshot);
+        },
         'apps.open': (params) => {
             const record = asRecord(params, 'apps.open');
             const app = asString(record.app, 'app', 'apps.open');
@@ -2652,18 +3177,27 @@ export function createMockTransport(config = {}) {
         },
         '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 method = 'pm.schedules.create';
+            const record = asRecord(params, method);
+            const source = asRecord(record.source, method);
+            let snapshotSource;
+            if (source.kind === 'template-json' && typeof source.content === 'string' && source.content !== '') {
+                snapshotSource = { kind: 'template-json' };
             }
-            const timing = mockScheduleTiming(record.timing, 'pm.schedules.create');
+            else if (source.kind === 'board-zip') {
+                const path = workspaceFileParam(source.path, 'a board-zip source.path', method);
+                snapshotSource = { kind: 'board-zip', originalName: path.slice(path.lastIndexOf('/') + 1) };
+            }
+            else {
+                throw new MinionryError('BAD_REQUEST', `${method}: source must be { kind: 'template-json', content } or { kind: 'board-zip', path: 'workspace:/…' }`);
+            }
+            const timing = mockScheduleTiming(record.timing, method);
             const id = `sched-mock-${++seq}`;
             const now = new Date();
             const snapshot = {
                 id,
                 createdAt: now.toISOString(),
-                source: { kind: 'template-json' },
+                source: snapshotSource,
                 timing,
                 enabled: record.enabled === undefined ? true : record.enabled === true,
                 nextFireAt: mockNextFireAt(timing, now),
@@ -2673,6 +3207,8 @@ export function createMockTransport(config = {}) {
                 snapshot.name = record.name;
             if (record.input !== undefined)
                 snapshot.input = record.input;
+            if (record.maxLatenessMs !== undefined)
+                snapshot.maxLatenessMs = mockMaxLatenessMs(record.maxLatenessMs, method);
             schedules.set(id, snapshot);
             return { ...snapshot };
         },
@@ -2694,6 +3230,7 @@ export function createMockTransport(config = {}) {
                 updated.timing = mockScheduleTiming(patch.timing, 'pm.schedules.update');
                 updated.nextFireAt = mockNextFireAt(updated.timing, new Date());
             }
+            patchMaxLatenessMs(updated, patch.maxLatenessMs, 'pm.schedules.update');
             schedules.set(scheduleId, updated);
             return { ...updated };
         },
@@ -2702,6 +3239,133 @@ export function createMockTransport(config = {}) {
             schedules.delete(scheduleId);
             return null;
         },
+        'pm.schedules.runNow': (params) => {
+            const method = 'pm.schedules.runNow';
+            const scheduleId = asString(asRecord(params, method).scheduleId, 'scheduleId', method);
+            const existing = schedules.get(scheduleId);
+            if (!existing)
+                throw new MinionryError('BAD_REQUEST', `schedule '${scheduleId}' not found in this Space`);
+            if (!existing.enabled) {
+                throw new MinionryError('BAD_REQUEST', `schedule '${scheduleId}' is disabled — enable it before running it now`);
+            }
+            const boardId = `board-mock-${++seq}`;
+            const board = {
+                boardId,
+                title: existing.name ?? 'Scheduled board',
+                goal: existing.name ?? 'Scheduled 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));
+            const entry = { at: board.createdAt, status: 'started', boardId };
+            const fired = {
+                ...existing,
+                lastFire: { at: entry.at, boardId, status: entry.status },
+                history: [...existing.history, entry],
+            };
+            schedules.set(scheduleId, fired);
+            return { ...fired };
+        },
+        'pm.chains.list': () => ({ links: [...chainLinks.values()].map(chainToSnapshot) }),
+        'pm.chains.create': (params) => {
+            const method = 'pm.chains.create';
+            const record = asRecord(params, method);
+            const from = asString(record.from, 'from', method);
+            const to = asString(record.to, 'to', method);
+            const on = record.on;
+            if (on !== 'success' && on !== 'failure' && on !== 'settled') {
+                throw new MinionryError('BAD_REQUEST', `${method}: 'on' must be one of 'success', 'failure', 'settled'`);
+            }
+            if (from === to) {
+                throw new MinionryError('BAD_REQUEST', `${method}: 'from' and 'to' must name different boards`);
+            }
+            const fromBoard = boards.get(from);
+            const toBoard = boards.get(to);
+            if (!fromBoard)
+                throw new MinionryError('BAD_REQUEST', `${method}: unknown board '${from}'`);
+            if (!toBoard)
+                throw new MinionryError('BAD_REQUEST', `${method}: unknown board '${to}'`);
+            if (chainBoardStatus(fromBoard) === 'completed' || chainBoardStatus(fromBoard) === 'archived') {
+                throw new MinionryError('BAD_REQUEST', `${method}: 'from' board '${from}' is not runnable`);
+            }
+            if (chainBoardStatus(toBoard) === 'completed' || chainBoardStatus(toBoard) === 'archived') {
+                throw new MinionryError('BAD_REQUEST', `${method}: 'to' board '${to}' is not runnable`);
+            }
+            const passOutputs = record.passOutputs === undefined ? false : record.passOutputs === true;
+            const name = typeof record.name === 'string' ? record.name : undefined;
+            const enabled = record.enabled === undefined ? true : record.enabled === true;
+            const existing = [...chainLinks.values()].find((link) => link.state === 'armed' && link.from === from && link.to === to && link.on === on);
+            if (existing) {
+                if (existing.passOutputs === passOutputs && existing.name === name)
+                    return chainToSnapshot(existing);
+                throw new MinionryError('BAD_REQUEST', `${method}: a link (${from} -> ${to}, on=${on}) already exists with a different passOutputs/name`);
+            }
+            const edges = chainArmedEdges({ from, to });
+            if (chainGraphHasCycle(edges)) {
+                throw new MinionryError('BAD_REQUEST', `${method}: would close a cycle`);
+            }
+            if (chainGraphDepthThrough(edges, to) > MAX_CHAIN_DEPTH) {
+                throw new MinionryError('BAD_REQUEST', `${method}: would exceed the max chain depth of ${MAX_CHAIN_DEPTH}`);
+            }
+            const outLinks = [...chainLinks.values()].filter((link) => link.state === 'armed' && link.from === from).length;
+            if (outLinks >= MAX_OUT_LINKS_PER_BOARD) {
+                throw new MinionryError('QUOTA_EXCEEDED', `${method}: board '${from}' already has ${MAX_OUT_LINKS_PER_BOARD} outgoing links`);
+            }
+            const armedCount = [...chainLinks.values()].filter((link) => link.state === 'armed').length;
+            if (armedCount >= MAX_LINKS_PER_APP || armedCount >= MAX_LINKS_PER_SPACE) {
+                throw new MinionryError('QUOTA_EXCEEDED', `${method}: at most ${MAX_LINKS_PER_APP} links per app`);
+            }
+            const id = `chain-mock-${++seq}`;
+            const link = {
+                id,
+                from,
+                to,
+                on,
+                passOutputs,
+                name,
+                enabled,
+                state: 'armed',
+                createdAt: new Date().toISOString(),
+                history: [],
+            };
+            chainLinks.set(id, link);
+            return chainToSnapshot(link);
+        },
+        'pm.chains.update': (params) => {
+            const method = 'pm.chains.update';
+            const record = asRecord(params, method);
+            const linkId = asString(record.linkId, 'linkId', method);
+            const link = chainLinks.get(linkId);
+            if (!link)
+                throw new MinionryError('BAD_REQUEST', `${method}: unknown linkId '${linkId}'`);
+            if (link.state !== 'armed') {
+                throw new MinionryError('BAD_REQUEST', `${method}: link '${linkId}' is ${link.state} and can no longer be updated`);
+            }
+            const patch = record.patch === undefined ? {} : asRecord(record.patch, method);
+            for (const immutable of ['from', 'to', 'on', 'passOutputs']) {
+                if (immutable in patch) {
+                    throw new MinionryError('BAD_REQUEST', `${method}: '${immutable}' is immutable — create a new link instead`);
+                }
+            }
+            if ('enabled' in patch)
+                link.enabled = patch.enabled === true;
+            if ('name' in patch) {
+                link.name = patch.name === null ? undefined : typeof patch.name === 'string' ? patch.name : link.name;
+            }
+            return chainToSnapshot(link);
+        },
+        'pm.chains.delete': (params) => {
+            const method = 'pm.chains.delete';
+            const linkId = asString(asRecord(params, method).linkId, 'linkId', method);
+            if (!chainLinks.delete(linkId))
+                throw new MinionryError('BAD_REQUEST', `${method}: unknown linkId '${linkId}'`);
+            return null;
+        },
         'stream.resume': (params) => {
             const record = asRecord(params, 'stream.resume');
             const requestId = asString(record.requestId, 'requestId', 'stream.resume');
@@ -2751,13 +3415,25 @@ export function createMockTransport(config = {}) {
             const content = files.get(path);
             if (content === undefined)
                 throw new MinionryError('BAD_REQUEST', `files.readEntry: no such file '${path}'`);
-            return { kind: 'text', content };
+            const size = new TextEncoder().encode(content).length;
+            return { kind: 'text', content, modifiedAt: timestamps.get(path), size };
         },
         '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());
+            const content = asString(record.content, 'content', 'files.write');
+            const expected = record.expectedModifiedAt;
+            if (expected !== undefined) {
+                if (typeof expected !== 'string' || Number.isNaN(Date.parse(expected))) {
+                    throw new MinionryError('BAD_REQUEST', 'files.write: expectedModifiedAt must be an ISO-8601 timestamp');
+                }
+                const current = files.has(path) ? timestamps.get(path) : undefined;
+                if (current === undefined || Date.parse(current) !== Date.parse(expected)) {
+                    throw new MinionryError('CONFLICT', `files.write: '${path}' ${current === undefined ? 'no longer exists' : `was modified at ${current}`}, not ${expected} — nothing was written`);
+                }
+            }
+            files.set(path, content);
+            stamp(path);
             notifyMockFileChanged(path, 'changed');
             return null;
         },
@@ -2802,6 +3478,8 @@ export function createMockTransport(config = {}) {
         },
         'files.delete': (params) => {
             const path = asString(asRecord(params, 'files.delete').path, 'path', 'files.delete');
+            const dir = isMockDir(path);
+            const existed = dir || files.has(path);
             files.delete(path);
             dirs.delete(path);
             timestamps.delete(path);
@@ -2816,12 +3494,17 @@ export function createMockTransport(config = {}) {
                 if (dirPath.startsWith(prefix))
                     dirs.delete(dirPath);
             }
+            if (existed)
+                notifyMockFileChanged(path, 'deleted', dir);
             return null;
         },
         'files.mkdir': (params) => {
             const path = asString(asRecord(params, 'files.mkdir').path, 'path', 'files.mkdir');
+            const existed = isMockDir(path);
             dirs.add(path);
-            timestamps.set(path, new Date().toISOString());
+            stamp(path);
+            if (!existed)
+                notifyMockFileChanged(path, 'created', true);
             return null;
         },
         'files.rename': (params) => {
@@ -2829,10 +3512,8 @@ export function createMockTransport(config = {}) {
             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) {
+            const dir = isMockDir(from);
+            if (!dir && !files.has(from)) {
                 throw new MinionryError('BAD_REQUEST', `files.rename: no such file or directory '${from}'`);
             }
             const rewrite = (key) => (key === from ? to : `${to}${key.slice(from.length)}`);
@@ -2859,6 +3540,7 @@ export function createMockTransport(config = {}) {
                 dirs.add(newKey);
                 moveTimestamp(key, newKey);
             }
+            notifyMockFileChanged(from, 'renamed', dir, to);
             return null;
         },
         'files.uploadStart': (params) => {
@@ -2917,9 +3599,11 @@ export function createMockTransport(config = {}) {
                     joined.set(chunk, offset);
                     offset += chunk.byteLength;
                 }
+                const existed = files.has(session.path);
                 files.set(session.path, new TextDecoder().decode(joined));
-                timestamps.set(session.path, new Date().toISOString());
+                stamp(session.path);
                 uploads.delete(uploadId);
+                notifyMockFileChanged(session.path, existed ? 'changed' : 'created');
             }
             return { chunkIndex, bytesWritten: session.bytesWritten };
         },
@@ -3400,6 +4084,7 @@ export function createMockTransport(config = {}) {
             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],
+            ...(config.agentRunEngines === null ? {} : { agentRunEngines: [...resolvedAgentRunEngines] }),
         }),
         'terminal.sessions.list': () => [...ptySessions.values()].map(mockPtySessionSummary),
         'terminal.sessions.subscribe': (_params, requestId) => {
@@ -4224,6 +4909,19 @@ export function createMockTransport(config = {}) {
         }
         return METHOD_SCOPES[method];
     };
+    const resolveScopes = (method, params) => {
+        const scope = resolveScope(method, params);
+        const scopes = scope === null ? [] : [scope];
+        const raw = scopeParams(params);
+        if (method === 'agents.schedules.create' || method === 'agents.schedules.update') {
+            if (raw.promptFile !== undefined || scopeParams(raw.patch).promptFile !== undefined)
+                scopes.push('files:workspace:read');
+        }
+        else if (method === 'pm.schedules.create' && scopeParams(raw.source).kind === 'board-zip') {
+            scopes.push('files:workspace:read');
+        }
+        return scopes;
+    };
     const dispatch = (frame) => {
         const { requestId, method } = frame;
         const forced = forcedErrors[method];
@@ -4235,8 +4933,8 @@ export function createMockTransport(config = {}) {
             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 scope = resolveScopes(method, frame.params).find((required) => !granted.has(required));
+        if (scope !== undefined) {
             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;