onbuzz 4.4.0 → 4.6.0

package/src/tools/__tests__/platformControlPermissions.test.js

@@ -0,0 +1,128 @@
+/**
+ * Tests for the permission helper used by platformControlTool.
+ *
+ * The helper is the actual security boundary — every (level × scenario)
+ * combination is pinned here so a future edit can't quietly widen access.
+ */
+
+import { describe, test, expect } from '@jest/globals';
+import {
+  SCHEDULE_ACCESS_LEVELS,
+  getScheduleAccessLevel,
+  isOwnTargetAgentSchedule,
+  checkScheduleAccess,
+  filterAccessibleSchedules,
+} from '../platformControl/permissions.js';
+
+const { DISABLED, OWN, ALL } = SCHEDULE_ACCESS_LEVELS;
+
+const ownSchedule = (over = {}) => ({
+  id: 's1', targetType: 'agent', targetId: 'agent-self', enabled: true, ...over,
+});
+const otherSchedule = (over = {}) => ({
+  id: 's2', targetType: 'agent', targetId: 'agent-other', enabled: true, ...over,
+});
+const flowSchedule = (over = {}) => ({
+  id: 's3', targetType: 'flow',  targetId: 'flow-1',     enabled: true, ...over,
+});
+
+describe('getScheduleAccessLevel', () => {
+  test('absent config → disabled', () => {
+    expect(getScheduleAccessLevel(undefined)).toBe('disabled');
+    expect(getScheduleAccessLevel(null)).toBe('disabled');
+    expect(getScheduleAccessLevel({})).toBe('disabled');
+  });
+  test('valid values pass through', () => {
+    expect(getScheduleAccessLevel({ scheduledTasks: 'disabled' })).toBe('disabled');
+    expect(getScheduleAccessLevel({ scheduledTasks: 'own' })).toBe('own');
+    expect(getScheduleAccessLevel({ scheduledTasks: 'all' })).toBe('all');
+  });
+  test('unknown values collapse to disabled — no silent grant', () => {
+    expect(getScheduleAccessLevel({ scheduledTasks: 'admin' })).toBe('disabled');
+    expect(getScheduleAccessLevel({ scheduledTasks: '' })).toBe('disabled');
+    expect(getScheduleAccessLevel({ scheduledTasks: 42 })).toBe('disabled');
+  });
+});
+
+describe('isOwnTargetAgentSchedule', () => {
+  test('matches agent-target schedule with same id', () => {
+    expect(isOwnTargetAgentSchedule(ownSchedule(), 'agent-self')).toBe(true);
+  });
+  test('rejects different agent id', () => {
+    expect(isOwnTargetAgentSchedule(otherSchedule(), 'agent-self')).toBe(false);
+  });
+  test('rejects flow-target even when ids match coincidentally', () => {
+    expect(isOwnTargetAgentSchedule({ targetType: 'flow', targetId: 'agent-self' }, 'agent-self')).toBe(false);
+  });
+  test('defensive: nullish inputs', () => {
+    expect(isOwnTargetAgentSchedule(null, 'a')).toBe(false);
+    expect(isOwnTargetAgentSchedule(ownSchedule(), null)).toBe(false);
+    expect(isOwnTargetAgentSchedule(ownSchedule(), '')).toBe(false);
+  });
+});
+
+describe('checkScheduleAccess', () => {
+  test('disabled denies everything', () => {
+    expect(checkScheduleAccess(DISABLED, 'agent-self', ownSchedule()).allow).toBe(false);
+    expect(checkScheduleAccess(DISABLED, 'agent-self', otherSchedule()).allow).toBe(false);
+    expect(checkScheduleAccess(DISABLED, 'agent-self', flowSchedule()).allow).toBe(false);
+    expect(checkScheduleAccess(DISABLED, 'agent-self', null).allow).toBe(false);
+  });
+
+  test('flow schedules denied at every level (security invariant)', () => {
+    for (const level of [OWN, ALL]) {
+      const r = checkScheduleAccess(level, 'agent-self', flowSchedule());
+      expect(r.allow).toBe(false);
+      expect(r.reason).toMatch(/Flow-target schedules/);
+    }
+  });
+
+  test('own mode: own agent-target schedule allowed', () => {
+    expect(checkScheduleAccess(OWN, 'agent-self', ownSchedule()).allow).toBe(true);
+  });
+
+  test('own mode: another agent\'s schedule denied', () => {
+    const r = checkScheduleAccess(OWN, 'agent-self', otherSchedule());
+    expect(r.allow).toBe(false);
+    expect(r.reason).toMatch(/Out of scope/);
+  });
+
+  test('own mode: null schedule (asking permission to access at all) → allowed', () => {
+    expect(checkScheduleAccess(OWN, 'agent-self', null).allow).toBe(true);
+  });
+
+  test('all mode: own + other agent-target schedules allowed', () => {
+    expect(checkScheduleAccess(ALL, 'agent-self', ownSchedule()).allow).toBe(true);
+    expect(checkScheduleAccess(ALL, 'agent-self', otherSchedule()).allow).toBe(true);
+  });
+
+  test('all mode: flow schedule still denied (per-feature invariant)', () => {
+    expect(checkScheduleAccess(ALL, 'agent-self', flowSchedule()).allow).toBe(false);
+  });
+
+  test('unknown level (defensive) → denied', () => {
+    const r = checkScheduleAccess('weird', 'a', ownSchedule());
+    expect(r.allow).toBe(false);
+    expect(r.reason).toMatch(/Unknown permission level/);
+  });
+});
+
+describe('filterAccessibleSchedules', () => {
+  const all = [ownSchedule(), otherSchedule(), flowSchedule()];
+
+  test('disabled → empty', () => {
+    expect(filterAccessibleSchedules(DISABLED, 'agent-self', all)).toEqual([]);
+  });
+  test('own → only own agent-target schedules', () => {
+    const out = filterAccessibleSchedules(OWN, 'agent-self', all);
+    expect(out.map(s => s.id)).toEqual(['s1']);
+  });
+  test('all → all agent-target schedules; flows excluded', () => {
+    const out = filterAccessibleSchedules(ALL, 'agent-self', all);
+    expect(out.map(s => s.id).sort()).toEqual(['s1', 's2']);
+  });
+  test('non-array → empty', () => {
+    expect(filterAccessibleSchedules(ALL, 'a', null)).toEqual([]);
+    expect(filterAccessibleSchedules(ALL, 'a', undefined)).toEqual([]);
+  });
+});

package/src/tools/__tests__/platformControlPersistence.test.js

@@ -0,0 +1,134 @@
+/**
+ * Persistence round-trip tests for platformcontrol's createdBy field.
+ *
+ * Pin that the field we stamp on agent and team records ACTUALLY survives
+ * save → load. Without these tests, a future refactor that strips
+ * "unknown" fields during normalization (or adds a JSON schema with a
+ * fixed allow-list) could silently drop createdBy and every "self-created"
+ * permission check would quietly pass through to "all" mode.
+ *
+ * Strategy: redirect userDataDir to a tmpdir, instantiate the real
+ * StateManager + AgentPool stubs, exercise the actual save/load paths,
+ * read the on-disk JSON back, assert the field is present.
+ */
+
+import { jest, describe, test, expect, beforeAll, afterAll, beforeEach } from '@jest/globals';
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+
+let tmpRoot;
+
+// IMPORTANT: this mock redirects every userDataDir read into a tmpdir.
+// Done with unstable_mockModule so it applies before StateManager is imported.
+jest.unstable_mockModule('../../utilities/userDataDir.js', () => ({
+  getUserDataDir: () => tmpRoot,
+  getUserDataPaths: () => ({
+    base:            tmpRoot,
+    state:           path.join(tmpRoot, 'state'),
+    agents:          path.join(tmpRoot, 'state', 'agents'),
+    settings:        path.join(tmpRoot, 'settings'),
+    attachments:     path.join(tmpRoot, 'attachments'),
+    logs:            path.join(tmpRoot, 'logs'),
+    cache:           path.join(tmpRoot, 'cache'),
+    operations:      path.join(tmpRoot, 'state', 'operations'),
+    models:          path.join(tmpRoot, 'state', 'models'),
+    runtime:         path.join(tmpRoot, 'runtime'),
+    skills:          path.join(tmpRoot, 'state', 'skills'),
+    gallery:         path.join(tmpRoot, 'gallery'),
+    galleryImages:   path.join(tmpRoot, 'gallery', 'images'),
+    galleryVideos:   path.join(tmpRoot, 'gallery', 'videos'),
+  }),
+  ensureUserDataDirs: async () => {},
+}));
+
+const { default: StateManager } = await import('../../core/stateManager.js');
+
+const LOGGER = { info() {}, warn() {}, error() {}, debug() {} };
+
+beforeAll(async () => {
+  tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'pc-persistence-'));
+  await fs.mkdir(path.join(tmpRoot, 'state', 'agents'),     { recursive: true });
+  await fs.mkdir(path.join(tmpRoot, 'state', 'operations'), { recursive: true });
+});
+afterAll(async () => {
+  await fs.rm(tmpRoot, { recursive: true, force: true }).catch(() => {});
+});
+
+describe('team — createdBy survives save → load', () => {
+  let sm;
+  beforeEach(async () => {
+    sm = new StateManager({}, LOGGER);
+    // Fresh team index for each test
+    const teamIndexPath = path.join(tmpRoot, 'state', 'team-index.json');
+    await fs.writeFile(teamIndexPath, '{}');
+  });
+
+  test('createdBy persists through createTeam → getAllTeams', async () => {
+    const team = await sm.createTeam({ name: 'Squad', createdBy: 'agent-7' });
+    expect(team.createdBy).toBe('agent-7');
+    // Round-trip: read fresh through getAllTeams
+    const fresh = await sm.getAllTeams();
+    const found = fresh.find(t => t.id === team.id);
+    expect(found).toBeDefined();
+    expect(found.createdBy).toBe('agent-7');
+  });
+
+  test('createdBy is also visible on disk (raw JSON read)', async () => {
+    const team = await sm.createTeam({ name: 'Disk-check', createdBy: 'agent-7' });
+    const raw = JSON.parse(await fs.readFile(path.join(tmpRoot, 'state', 'team-index.json'), 'utf8'));
+    expect(raw[team.id].createdBy).toBe('agent-7');
+  });
+
+  test('createdBy survives an updateTeam call (not stripped by allowed-fields filter)', async () => {
+    const team = await sm.createTeam({ name: 'Original', createdBy: 'agent-7' });
+    await sm.updateTeam(team.id, { name: 'Renamed', description: 'updated' });
+    const fresh = await sm.getTeam(team.id);
+    expect(fresh.createdBy).toBe('agent-7');
+    expect(fresh.name).toBe('Renamed');
+  });
+
+  test('null createdBy (UI-created team) round-trips as null', async () => {
+    const team = await sm.createTeam({ name: 'UI-team' });
+    expect(team.createdBy).toBeNull();
+    const fresh = await sm.getTeam(team.id);
+    expect(fresh.createdBy).toBeNull();
+  });
+});
+
+describe('agent — createdBy survives persist → reload', () => {
+  // The full agentPool is too heavy to construct in a unit test; we exercise
+  // the persistence layer directly. agentPool.createAgent already sets
+  // createdBy on the agent object (covered separately by the tool tests),
+  // so the only thing we need to pin here is that StateManager's
+  // persistAgentState writes the field through saveJSON intact.
+  let sm;
+  beforeEach(() => { sm = new StateManager({}, LOGGER); });
+
+  test('createdBy is included in the persisted agent JSON state', async () => {
+    const agent = {
+      id: 'agent-test-1',
+      name: 'Persistence test',
+      createdBy: 'parent-agent',
+      conversations: {},   // separated by persistAgentState
+      otherField: 42,
+    };
+    await sm.persistAgentState(agent, tmpRoot);
+    const stateFile = path.join(tmpRoot, 'state', 'agents', `agent-${agent.id}-state.json`);
+    const raw = JSON.parse(await fs.readFile(stateFile, 'utf8'));
+    expect(raw.state.createdBy).toBe('parent-agent');
+    expect(raw.state.id).toBe('agent-test-1');
+    // Other fields still present too
+    expect(raw.state.otherField).toBe(42);
+  });
+
+  test('null createdBy (UI-created agent) round-trips as null', async () => {
+    const agent = {
+      id: 'agent-test-2', name: 'UI', createdBy: null, conversations: {},
+    };
+    await sm.persistAgentState(agent, tmpRoot);
+    const stateFile = path.join(tmpRoot, 'state', 'agents', `agent-${agent.id}-state.json`);
+    const raw = JSON.parse(await fs.readFile(stateFile, 'utf8'));
+    expect(raw.state).toHaveProperty('createdBy', null);
+  });
+});

package/src/tools/__tests__/platformControlTool.test.js

@@ -0,0 +1,391 @@
+/**
+ * platformControlTool — end-to-end action tests against a stubbed
+ * ScheduleService. The tool is the dispatcher; the security boundary
+ * lives in permissions.js (covered separately). These tests pin the
+ * dispatch behavior:
+ *
+ *   - disabled / no service → tool returns disabled or unavailable shape
+ *   - 'own' mode → can list/CRUD only own; cannot probe others (404'd)
+ *   - 'all' mode → full access
+ *   - 'self' resolves to context.agentId
+ *   - schedule-self-resume converts a future ISO into a one-shot cron
+ *   - flow-target schedules are unreachable at any level
+ */
+
+import { describe, test, expect, beforeEach, jest } from '@jest/globals';
+import { PlatformControlTool } from '../platformControlTool.js';
+
+const LOGGER = { info() {}, warn() {}, error() {}, debug() {} };
+
+function makeStubService(initial = []) {
+  const map = new Map(initial.map(s => [s.id, s]));
+  return {
+    listSchedules: jest.fn(() => Array.from(map.values())),
+    getSchedule:   jest.fn((id) => map.get(id) || null),
+    createSchedule: jest.fn(async (cfg) => {
+      const id = `sched-${map.size + 1}`;
+      const sched = {
+        id, ...cfg,
+        nextRun: '2099-01-01T00:00:00Z',
+        runCount: 0, createdAt: '2026-04-26T00:00:00Z', updatedAt: '2026-04-26T00:00:00Z',
+      };
+      map.set(id, sched);
+      return sched;
+    }),
+    updateSchedule: jest.fn(async (id, updates) => {
+      const sched = map.get(id);
+      if (!sched) throw new Error(`Schedule not found: ${id}`);
+      Object.assign(sched, updates, { updatedAt: '2026-04-26T00:00:00Z' });
+      return sched;
+    }),
+    deleteSchedule: jest.fn(async (id) => {
+      if (!map.has(id)) throw new Error(`Schedule not found: ${id}`);
+      map.delete(id);
+    }),
+    _executeSchedule: jest.fn(async () => undefined),
+    _store: map,
+  };
+}
+
+function ctx({ agentId = 'agent-self', level } = {}) {
+  return {
+    agentId,
+    toolConfig: level !== undefined ? { scheduledTasks: level } : {},
+  };
+}
+
+const ownSched = (over = {}) => ({
+  id: 's-own', name: 'own', targetType: 'agent', targetId: 'agent-self',
+  cronExpression: '0 9 * * *', enabled: true, prompt: 'do thing', ...over,
+});
+const otherSched = (over = {}) => ({
+  id: 's-other', name: 'other', targetType: 'agent', targetId: 'agent-other',
+  cronExpression: '0 9 * * *', enabled: true, prompt: 'do thing', ...over,
+});
+const flowSched = (over = {}) => ({
+  id: 's-flow', name: 'flow', targetType: 'flow', targetId: 'flow-1',
+  cronExpression: '0 9 * * *', enabled: true, prompt: 'do thing', ...over,
+});
+
+describe('disabled (default)', () => {
+  let tool, svc;
+  beforeEach(() => { tool = new PlatformControlTool({}, LOGGER); svc = makeStubService(); tool.setScheduleService(svc); });
+
+  test('list-schedules → success: false, disabled: true', async () => {
+    const r = await tool.execute({ action: 'list-schedules' }, ctx());
+    expect(r).toMatchObject({ success: false, disabled: true });
+  });
+  test('create-schedule → success: false, disabled: true (regardless of params)', async () => {
+    const r = await tool.execute({ action: 'create-schedule', name: 'x' }, ctx());
+    expect(r).toMatchObject({ success: false, disabled: true });
+  });
+  test('schedule-self-resume → disabled', async () => {
+    const r = await tool.execute({ action: 'schedule-self-resume', runAt: '2099-01-01T00:00:00Z', prompt: 'x' }, ctx());
+    expect(r).toMatchObject({ success: false, disabled: true });
+  });
+  test('list-capabilities IS allowed even when disabled (so agent can self-discover)', async () => {
+    const r = await tool.execute({ action: 'list-capabilities' }, ctx());
+    expect(r.success).toBe(true);
+    expect(r.capabilities.scheduledTasks.level).toBe('disabled');
+    expect(r.capabilities.scheduledTasks.canMutateOwn).toBe(false);
+  });
+});
+
+describe('no ScheduleService injected', () => {
+  test('any feature action → success: false (excluding capabilities)', async () => {
+    const tool = new PlatformControlTool({}, LOGGER);
+    // service NOT set — schedulable actions must report unavailable
+    const r = await tool.execute({ action: 'list-schedules' }, ctx({ level: 'own' }));
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/ScheduleService is not available/);
+  });
+});
+
+describe('own mode', () => {
+  let tool, svc;
+  beforeEach(() => {
+    tool = new PlatformControlTool({}, LOGGER);
+    svc = makeStubService([ownSched(), otherSched(), flowSched()]);
+    tool.setScheduleService(svc);
+  });
+
+  test('list-schedules returns only own agent-target schedules; flows excluded', async () => {
+    const r = await tool.execute({ action: 'list-schedules' }, ctx({ level: 'own' }));
+    expect(r.success).toBe(true);
+    expect(r.scope).toBe('own');
+    expect(r.schedules.map(s => s.id)).toEqual(['s-own']);
+    expect(r.count).toBe(1);
+  });
+
+  test('get-schedule on own → returns it', async () => {
+    const r = await tool.execute({ action: 'get-schedule', scheduleId: 's-own' }, ctx({ level: 'own' }));
+    expect(r.success).toBe(true);
+    expect(r.schedule.id).toBe('s-own');
+  });
+
+  test('get-schedule on another agent\'s schedule → 404 shape (cannot probe)', async () => {
+    const r = await tool.execute({ action: 'get-schedule', scheduleId: 's-other' }, ctx({ level: 'own' }));
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/not found/i);
+  });
+
+  test('get-schedule on flow → 404 shape (flows out of scope)', async () => {
+    const r = await tool.execute({ action: 'get-schedule', scheduleId: 's-flow' }, ctx({ level: 'own' }));
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/not found/i);
+  });
+
+  test('create-schedule defaults targetAgentId to self', async () => {
+    const r = await tool.execute({
+      action: 'create-schedule',
+      name: 'mine', prompt: 'go', cronExpression: '0 9 * * *',
+    }, ctx({ level: 'own' }));
+    expect(r.success).toBe(true);
+    expect(svc.createSchedule).toHaveBeenCalledWith(expect.objectContaining({
+      targetType: 'agent', targetId: 'agent-self',
+    }));
+  });
+
+  test('create-schedule with explicit "self" works', async () => {
+    const r = await tool.execute({
+      action: 'create-schedule',
+      name: 'mine', prompt: 'go', cronExpression: '0 9 * * *',
+      targetAgentId: 'self',
+    }, ctx({ level: 'own' }));
+    expect(r.success).toBe(true);
+    expect(svc.createSchedule).toHaveBeenCalledWith(expect.objectContaining({ targetId: 'agent-self' }));
+  });
+
+  test('create-schedule with another agent\'s id is REJECTED', async () => {
+    const r = await tool.execute({
+      action: 'create-schedule',
+      name: 'sneaky', prompt: 'go', cronExpression: '0 9 * * *',
+      targetAgentId: 'agent-other',
+    }, ctx({ level: 'own' }));
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/Out of scope/i);
+    expect(svc.createSchedule).not.toHaveBeenCalled();
+  });
+
+  test('update-schedule on own works', async () => {
+    const r = await tool.execute({
+      action: 'update-schedule', scheduleId: 's-own', name: 'renamed',
+    }, ctx({ level: 'own' }));
+    expect(r.success).toBe(true);
+    expect(svc.updateSchedule).toHaveBeenCalledWith('s-own', expect.objectContaining({ name: 'renamed' }));
+  });
+
+  test('update-schedule on another agent\'s → 404', async () => {
+    const r = await tool.execute({
+      action: 'update-schedule', scheduleId: 's-other', name: 'x',
+    }, ctx({ level: 'own' }));
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/not found/i);
+    expect(svc.updateSchedule).not.toHaveBeenCalled();
+  });
+
+  test('update-schedule cannot reassign own→other in own mode', async () => {
+    const r = await tool.execute({
+      action: 'update-schedule', scheduleId: 's-own', targetAgentId: 'agent-other',
+    }, ctx({ level: 'own' }));
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/Out of scope/i);
+  });
+
+  test('delete-schedule on own works', async () => {
+    const r = await tool.execute({ action: 'delete-schedule', scheduleId: 's-own' }, ctx({ level: 'own' }));
+    expect(r.success).toBe(true);
+    expect(svc.deleteSchedule).toHaveBeenCalledWith('s-own');
+  });
+
+  test('delete-schedule on another\'s → 404', async () => {
+    const r = await tool.execute({ action: 'delete-schedule', scheduleId: 's-other' }, ctx({ level: 'own' }));
+    expect(r.success).toBe(false);
+    expect(svc.deleteSchedule).not.toHaveBeenCalled();
+  });
+
+  test('toggle-schedule flips by default', async () => {
+    const r = await tool.execute({ action: 'toggle-schedule', scheduleId: 's-own' }, ctx({ level: 'own' }));
+    expect(r.success).toBe(true);
+    expect(r.enabled).toBe(false);   // was true → flipped to false
+  });
+  test('toggle-schedule with explicit enabled sets it', async () => {
+    const r = await tool.execute({ action: 'toggle-schedule', scheduleId: 's-own', enabled: false }, ctx({ level: 'own' }));
+    expect(r.enabled).toBe(false);
+  });
+
+  test('trigger-schedule on own fires _executeSchedule', async () => {
+    const r = await tool.execute({ action: 'trigger-schedule', scheduleId: 's-own' }, ctx({ level: 'own' }));
+    expect(r.success).toBe(true);
+    expect(svc._executeSchedule).toHaveBeenCalled();
+  });
+
+  test('trigger-schedule on another\'s → 404, no exec', async () => {
+    const r = await tool.execute({ action: 'trigger-schedule', scheduleId: 's-other' }, ctx({ level: 'own' }));
+    expect(r.success).toBe(false);
+    expect(svc._executeSchedule).not.toHaveBeenCalled();
+  });
+});
+
+describe('all mode', () => {
+  let tool, svc;
+  beforeEach(() => {
+    tool = new PlatformControlTool({}, LOGGER);
+    svc = makeStubService([ownSched(), otherSched(), flowSched()]);
+    tool.setScheduleService(svc);
+  });
+
+  test('list-schedules returns all agent-target schedules; flows still excluded', async () => {
+    const r = await tool.execute({ action: 'list-schedules' }, ctx({ level: 'all' }));
+    expect(r.scope).toBe('all');
+    expect(r.schedules.map(s => s.id).sort()).toEqual(['s-other', 's-own']);
+  });
+
+  test('get-schedule on another agent\'s → success', async () => {
+    const r = await tool.execute({ action: 'get-schedule', scheduleId: 's-other' }, ctx({ level: 'all' }));
+    expect(r.success).toBe(true);
+    expect(r.schedule.id).toBe('s-other');
+  });
+
+  test('get-schedule on flow → STILL 404 (flows out of scope at every level)', async () => {
+    const r = await tool.execute({ action: 'get-schedule', scheduleId: 's-flow' }, ctx({ level: 'all' }));
+    expect(r.success).toBe(false);
+  });
+
+  test('create-schedule for another agent works in all mode', async () => {
+    const r = await tool.execute({
+      action: 'create-schedule', name: 'cross', prompt: 'go',
+      cronExpression: '0 9 * * *', targetAgentId: 'agent-other',
+    }, ctx({ level: 'all' }));
+    expect(r.success).toBe(true);
+    expect(svc.createSchedule).toHaveBeenCalledWith(expect.objectContaining({ targetId: 'agent-other' }));
+  });
+
+  test('update-schedule can reassign target in all mode', async () => {
+    const r = await tool.execute({
+      action: 'update-schedule', scheduleId: 's-own', targetAgentId: 'agent-other',
+    }, ctx({ level: 'all' }));
+    expect(r.success).toBe(true);
+    expect(svc.updateSchedule).toHaveBeenCalledWith('s-own', expect.objectContaining({ targetId: 'agent-other' }));
+  });
+});
+
+describe('schedule-self-resume', () => {
+  let tool, svc;
+  beforeEach(() => {
+    tool = new PlatformControlTool({}, LOGGER);
+    svc = makeStubService();
+    tool.setScheduleService(svc);
+  });
+
+  test('future ISO → creates one-shot agent-target schedule for caller', async () => {
+    const future = new Date(Date.now() + 60 * 60 * 1000); // +1 hour
+    const r = await tool.execute({
+      action: 'schedule-self-resume',
+      runAt: future.toISOString(),
+      prompt: 'wake up and check email',
+    }, ctx({ level: 'own' }));
+    expect(r.success).toBe(true);
+    expect(svc.createSchedule).toHaveBeenCalledWith(expect.objectContaining({
+      targetType: 'agent',
+      targetId:   'agent-self',
+      runOnce:    true,
+      enabled:    true,
+      prompt:     'wake up and check email',
+    }));
+    expect(r.cronExpression).toMatch(/^\d+ \d+ \d+ \d+ \*$/);
+  });
+
+  test('past ISO is rejected', async () => {
+    const past = new Date(Date.now() - 60_000).toISOString();
+    const r = await tool.execute({
+      action: 'schedule-self-resume', runAt: past, prompt: 'too late',
+    }, ctx({ level: 'own' }));
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/future/);
+    expect(svc.createSchedule).not.toHaveBeenCalled();
+  });
+
+  test('invalid ISO is rejected', async () => {
+    const r = await tool.execute({
+      action: 'schedule-self-resume', runAt: 'not-a-date', prompt: 'x',
+    }, ctx({ level: 'own' }));
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/valid datetime/);
+  });
+
+  test('missing prompt rejected', async () => {
+    const r = await tool.execute({
+      action: 'schedule-self-resume', runAt: new Date(Date.now() + 3600_000).toISOString(),
+    }, ctx({ level: 'own' }));
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/prompt/);
+  });
+
+  test('default name is generated when omitted', async () => {
+    const future = new Date(Date.now() + 60 * 60 * 1000).toISOString();
+    await tool.execute({
+      action: 'schedule-self-resume', runAt: future, prompt: 'go',
+    }, ctx({ level: 'own' }));
+    expect(svc.createSchedule).toHaveBeenCalledWith(expect.objectContaining({
+      name: expect.stringMatching(/^Self-resume @/),
+    }));
+  });
+
+  test('explicit name passes through', async () => {
+    const future = new Date(Date.now() + 60 * 60 * 1000).toISOString();
+    await tool.execute({
+      action: 'schedule-self-resume', runAt: future, prompt: 'go', name: 'My wake-up',
+    }, ctx({ level: 'own' }));
+    expect(svc.createSchedule).toHaveBeenCalledWith(expect.objectContaining({ name: 'My wake-up' }));
+  });
+});
+
+describe('list-presets + list-capabilities', () => {
+  test('list-presets returns the canonical set', async () => {
+    const tool = new PlatformControlTool({}, LOGGER);
+    tool.setScheduleService(makeStubService());
+    const r = await tool.execute({ action: 'list-presets' }, ctx({ level: 'own' }));
+    expect(r.success).toBe(true);
+    expect(r.presets).toEqual(expect.arrayContaining(['daily', 'every-hour', 'weekdays']));
+  });
+  test('list-capabilities reports own mode correctly', async () => {
+    const tool = new PlatformControlTool({}, LOGGER);
+    tool.setScheduleService(makeStubService());
+    const r = await tool.execute({ action: 'list-capabilities' }, ctx({ level: 'own' }));
+    expect(r.capabilities.scheduledTasks).toMatchObject({
+      level: 'own', canListOwn: true, canListAll: false, canMutateOwn: true, canMutateAll: false,
+    });
+  });
+  test('list-capabilities reports all mode correctly', async () => {
+    const tool = new PlatformControlTool({}, LOGGER);
+    tool.setScheduleService(makeStubService());
+    const r = await tool.execute({ action: 'list-capabilities' }, ctx({ level: 'all' }));
+    expect(r.capabilities.scheduledTasks).toMatchObject({
+      level: 'all', canListAll: true, canMutateAll: true,
+    });
+  });
+});
+
+describe('unknown action', () => {
+  test('returns informative error listing supported actions', async () => {
+    const tool = new PlatformControlTool({}, LOGGER);
+    tool.setScheduleService(makeStubService());
+    const r = await tool.execute({ action: 'teleport' }, ctx({ level: 'own' }));
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/Unknown action: teleport/);
+    expect(r.error).toMatch(/list-schedules/);
+  });
+});
+
+describe('getSupportedActions', () => {
+  test('includes every documented action', () => {
+    const tool = new PlatformControlTool({}, LOGGER);
+    const actions = tool.getSupportedActions();
+    expect(actions).toEqual(expect.arrayContaining([
+      'list-capabilities', 'list-schedules', 'get-schedule', 'create-schedule',
+      'update-schedule', 'delete-schedule', 'toggle-schedule', 'trigger-schedule',
+      'list-presets', 'schedule-self-resume',
+    ]));
+  });
+});