@robota-sdk/agent-command 3.0.0-beta.100

package/src/sandbox/__tests__/sandbox-command.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { executeSandboxCommand } from '../sandbox-command.js';
+
+import type {
+  ICommandSandboxAdapter,
+  ICommandSandboxStatus,
+  TSandboxCommandMode,
+} from '@robota-sdk/agent-framework';
+
+/** Issue #3082 — `/sandbox` shows and changes how shell commands are confined. */
+function contextWith(
+  status: Partial<ICommandSandboxStatus>,
+  answer?: string,
+): { context: Parameters<typeof executeSandboxCommand>[0]; setMode: ReturnType<typeof vi.fn> } {
+  let current: ICommandSandboxStatus = {
+    mode: 'off',
+    backend: 'bubblewrap',
+    network: false,
+    excludedCommands: [],
+    ...status,
+  };
+  const setMode = vi.fn((mode: TSandboxCommandMode) => {
+    current = { ...current, mode };
+  });
+  const adapter: ICommandSandboxAdapter = { status: () => current, setMode };
+  const ui =
+    answer === undefined
+      ? undefined
+      : { ask: vi.fn().mockResolvedValue({ type: 'answer', values: [answer] }) };
+  return {
+    context: {
+      getCommandHostAdapters: () => ({ sandbox: adapter }),
+      getUserInteraction: () => ui,
+    } as never,
+    setMode,
+  };
+}
+
+describe('/sandbox', () => {
+  it('shows the current state when no mode is given and nobody is asked', async () => {
+    const { context } = contextWith({ mode: 'auto-allow', excludedCommands: ['docker'] });
+    const result = await executeSandboxCommand(context, '');
+    expect(result.message).toContain('Sandbox: auto-allow (bubblewrap)');
+    expect(result.message).toContain('Network: blocked.');
+    expect(result.message).toContain('Run unconfined: docker.');
+  });
+
+  it('sets a mode named on the command line', async () => {
+    const { context, setMode } = contextWith({});
+    const result = await executeSandboxCommand(context, 'regular');
+    expect(setMode).toHaveBeenCalledWith('regular');
+    expect(result.message).toContain('Sandbox mode set to: regular');
+  });
+
+  it('asks for a mode through the picker', async () => {
+    const { context, setMode } = contextWith({}, 'auto-allow');
+    await executeSandboxCommand(context, '');
+    expect(setMode).toHaveBeenCalledWith('auto-allow');
+  });
+
+  it('says what is missing when the backend cannot run', async () => {
+    const { context } = contextWith({ mode: 'auto-allow', unavailable: 'missing bubblewrap' });
+    const result = await executeSandboxCommand(context, '');
+    expect(result.message).toContain(
+      'Cannot run here: missing bubblewrap. Commands run unconfined.',
+    );
+  });
+
+  it('refuses an unknown mode and a host without a sandbox', async () => {
+    const { context, setMode } = contextWith({});
+    expect((await executeSandboxCommand(context, 'loose')).success).toBe(false);
+    expect(setMode).not.toHaveBeenCalled();
+    const bare = {
+      getCommandHostAdapters: () => ({}),
+      getUserInteraction: () => undefined,
+    } as never;
+    expect((await executeSandboxCommand(bare, '')).message).toBe('This host has no OS sandbox.');
+  });
+});

package/src/sandbox/index.ts

@@ -0,0 +1,2 @@
+export { createSandboxCommandModule, SandboxCommandSource } from './sandbox-command-module.js';
+export { executeSandboxCommand, formatSandboxStatus, SANDBOX_MODES } from './sandbox-command.js';

package/src/sandbox/sandbox-command-module.ts

@@ -0,0 +1,56 @@
+import { executeSandboxCommand, SANDBOX_MODES } from './sandbox-command.js';
+
+import type { ICommandModule, ISystemCommand } from '@robota-sdk/agent-framework';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-command';
+
+const DESCRIPTION = 'Show or change how shell commands are confined';
+const ARGUMENT_HINT = SANDBOX_MODES.map((entry) => entry.mode).join(' | ');
+
+export function createSandboxCommandEntry(): ICommand {
+  return {
+    name: 'sandbox',
+    displayName: 'Sandbox',
+    description: DESCRIPTION,
+    source: 'sandbox',
+    argumentHint: ARGUMENT_HINT,
+    subcommands: SANDBOX_MODES.map(({ mode, description }) => ({
+      name: mode,
+      description,
+      source: 'sandbox',
+    })),
+    // User-only: changes the sandbox boundary; permission widening is the user's.
+    modelInvocable: false,
+  };
+}
+
+function createSandboxSystemCommand(): ISystemCommand {
+  const entry = createSandboxCommandEntry();
+  return {
+    name: entry.name,
+    displayName: entry.displayName,
+    description: entry.description,
+    requiresPermission: false,
+    userInvocable: true,
+    modelInvocable: false,
+    argumentHint: entry.argumentHint,
+    subcommands: entry.subcommands,
+    lifecycle: 'inline',
+    execute: executeSandboxCommand,
+  };
+}
+
+export class SandboxCommandSource implements ICommandSource {
+  readonly name = 'sandbox';
+
+  getCommands(): ICommand[] {
+    return [createSandboxCommandEntry()];
+  }
+}
+
+export function createSandboxCommandModule(): ICommandModule {
+  return {
+    name: 'agent-command-sandbox',
+    commandSources: [new SandboxCommandSource()],
+    systemCommands: [createSandboxSystemCommand()],
+  };
+}

package/src/sandbox/sandbox-command.ts

@@ -0,0 +1,94 @@
+/**
+ * `/sandbox`: see how shell commands are confined and change it (issue #3082).
+ *
+ * The OS sandbox is live — the choice applies to the next command — and is saved in the user
+ * settings so the next session starts the same way.
+ */
+import { selectAction } from '@robota-sdk/agent-core';
+
+import type {
+  ICommandHostAdapterAccess,
+  ICommandHostUserInteraction,
+  ICommandSandboxStatus,
+  TSandboxCommandMode,
+} from '@robota-sdk/agent-framework';
+import type { ICommandResult } from '@robota-sdk/agent-interface-command';
+
+export const SANDBOX_MODES: readonly {
+  readonly mode: TSandboxCommandMode;
+  readonly description: string;
+}[] = [
+  { mode: 'auto-allow', description: 'Confine shell commands; confined ones run without a prompt' },
+  { mode: 'regular', description: 'Confine shell commands; prompts work as usual' },
+  { mode: 'off', description: 'Run shell commands on this machine, unconfined' },
+];
+
+function isSandboxMode(value: string): value is TSandboxCommandMode {
+  return SANDBOX_MODES.some((entry) => entry.mode === value);
+}
+
+export function formatSandboxStatus(status: ICommandSandboxStatus): string {
+  const lines = [
+    `Sandbox: ${status.mode}${status.backend !== undefined ? ` (${status.backend})` : ''}`,
+  ];
+  if (status.unavailable !== undefined) {
+    lines.push(
+      status.mode === 'off'
+        ? `Not available here: ${status.unavailable}.`
+        : `Cannot run here: ${status.unavailable}. Commands run unconfined.`,
+    );
+  }
+  if (status.mode !== 'off' && status.unavailable === undefined) {
+    lines.push(
+      'Writes are limited to the workspace and temp directories; settings and git hooks stay read-only.',
+      `Network: ${status.network ? 'allowed' : 'blocked'}.`,
+    );
+    if (status.excludedCommands.length > 0) {
+      lines.push(`Run unconfined: ${status.excludedCommands.join(', ')}.`);
+    }
+  }
+  return lines.join('\n');
+}
+
+async function askForMode(
+  context: ICommandHostUserInteraction,
+  current: TSandboxCommandMode,
+): Promise<string | undefined> {
+  const ui = context.getUserInteraction();
+  if (!ui) return undefined;
+  const options = SANDBOX_MODES.map(({ mode, description }) => ({
+    value: mode,
+    label: mode === current ? `${mode} (current)` : mode,
+    description,
+  }));
+  const response = await ui.ask(selectAction('sandbox', 'Sandbox mode', options));
+  return response.type === 'answer' ? response.values[0] : undefined;
+}
+
+export async function executeSandboxCommand(
+  context: ICommandHostAdapterAccess & ICommandHostUserInteraction,
+  args: string,
+): Promise<ICommandResult> {
+  const adapter = context.getCommandHostAdapters?.().sandbox;
+  if (adapter === undefined) {
+    return { message: 'This host has no OS sandbox.', success: false };
+  }
+  const before = adapter.status();
+  const requested = args.trim().split(/\s+/)[0] || (await askForMode(context, before.mode));
+  if (requested === undefined || requested === '') {
+    return { message: formatSandboxStatus(before), success: true, data: { ...before } };
+  }
+  if (!isSandboxMode(requested)) {
+    return {
+      message: `Unknown sandbox mode "${requested}". Valid: ${SANDBOX_MODES.map((entry) => entry.mode).join(' | ')}`,
+      success: false,
+    };
+  }
+  adapter.setMode(requested);
+  const after = adapter.status();
+  return {
+    message: `Sandbox mode set to: ${requested}\n${formatSandboxStatus(after)}`,
+    success: true,
+    data: { ...after },
+  };
+}

package/src/schedule/__tests__/loop-command-functional.test.ts

@@ -0,0 +1,399 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { scriptedSession, type ScriptedSessionHarness } from '@robota-sdk/agent-framework/testing';
+
+import { createScheduleCommandModule } from '../schedule-command-module.js';
+
+let harness: ScriptedSessionHarness | undefined;
+afterEach(async () => {
+  await harness?.dispose();
+  harness = undefined;
+});
+
+/**
+ * #3288 §1: a bare/interval-only loop now asks before it falls back to the default prompt, even in
+ * this harness's "typed the command" (`source: 'user'`) path — subscribing an `askHandler` gives
+ * `getUserInteraction()` a live port (REMOTE-007 D4a), so these functional tests stay interactive
+ * rather than hitting the new headless refusal. Always answers "Start".
+ */
+const confirmDefaultStart = async (): Promise<{ type: 'answer'; values: readonly string[] }> =>
+  ({ type: 'answer', values: ['start'] });
+
+describe('/loop command in a real interactive session', () => {
+  it('re-reads an omitted self-paced prompt before each iteration without changing explicit prompts', async () => {
+    let prompt = 'project first';
+    const resolveDefaultPrompt = () => prompt;
+    harness = scriptedSession({
+      turns: [{ text: 'first' }, { text: 'second' }],
+      commandModules: [createScheduleCommandModule({ defaultPrompt: 'fallback', resolveDefaultPrompt })],
+      resolveDefaultLoopPrompt: resolveDefaultPrompt,
+      askHandler: confirmDefaultStart,
+      backgroundTasks: true,
+      persistence: true,
+    });
+    const created = await harness.command('loop', '');
+    expect(created?.success).toBe(true);
+    const loopId = (created?.data as { loopId: string }).loopId;
+    await vi.waitFor(() => expect(harness?.session.listSelfPacedLoops()[0]?.phase).toBe('waiting'));
+    expect(JSON.stringify(harness.requests[0])).toContain('project first');
+
+    prompt = 'project second';
+    const timer = harness.session.listSchedules().find((task) => task.metadata?.['sessionLoopId'] === loopId)!;
+    const nextAllowedAt = harness.session.listSelfPacedLoops()[0]!.nextAllowedAt!;
+    const clock = vi.spyOn(Date, 'now').mockReturnValue(Date.parse(nextAllowedAt) + 1);
+    try {
+      expect(await harness.wake('project first', timer.id)).not.toBeNull();
+    } finally {
+      clock.mockRestore();
+    }
+    expect(harness.requests[1]?.filter((message) => message.role === 'user').at(-1)?.content)
+      .toBe('project second');
+    expect(harness.session.getFullHistory().filter((entry) => entry.type === 'user').at(-1))
+      .toMatchObject({ data: { content: 'project second' } });
+    expect(harness.session.listSelfPacedLoops().find((loop) => loop.loopId === loopId)?.phase)
+      .toBe('stopped');
+  });
+
+  it('re-reads an interval-only fixed-loop prompt before each wake', async () => {
+    let prompt = 'user first';
+    const resolveDefaultPrompt = () => prompt;
+    harness = scriptedSession({
+      turns: [{ text: 'first' }, { text: 'second' }],
+      commandModules: [createScheduleCommandModule({ defaultPrompt: 'fallback', resolveDefaultPrompt })],
+      resolveDefaultLoopPrompt: resolveDefaultPrompt,
+      askHandler: confirmDefaultStart,
+      backgroundTasks: true,
+      persistence: true,
+    });
+    const created = await harness.command('loop', '5m');
+    expect(created?.success).toBe(true);
+    const { loopId, taskId, firstAllowedAt } = created?.data as {
+      loopId: string; taskId: string; firstAllowedAt: string;
+    };
+    const eligibleClock = vi.spyOn(Date, 'now').mockReturnValue(Date.parse(firstAllowedAt) + 1);
+    try {
+      expect(await harness.wake('user first', taskId)).not.toBeNull();
+      prompt = 'user second';
+      expect(await harness.wake('user first', taskId)).not.toBeNull();
+    } finally {
+      eligibleClock.mockRestore();
+    }
+    expect(JSON.stringify(harness.requests[0])).toContain('user first');
+    expect(harness.requests[1]?.filter((message) => message.role === 'user').at(-1)?.content)
+      .toBe('user second');
+    expect(harness.session.getFullHistory().filter((entry) => entry.type === 'user').at(-1))
+      .toMatchObject({ data: { content: 'user second' } });
+    expect((await harness.command('loop', `stop ${loopId}`))?.success).toBe(true);
+  });
+
+  it('does not consult the default resolver for an explicit fixed-loop prompt', async () => {
+    harness = scriptedSession({
+      turns: [{ text: 'done' }],
+      commandModules: [createScheduleCommandModule({
+        defaultPrompt: 'fallback',
+        resolveDefaultPrompt: () => { throw new Error('must not read default'); },
+      })],
+      resolveDefaultLoopPrompt: () => { throw new Error('must not read default'); },
+      backgroundTasks: true,
+      persistence: true,
+    });
+    const created = await harness.command('loop', '5m explicit check');
+    expect(created?.success).toBe(true);
+    const { loopId, taskId, firstAllowedAt } = created?.data as {
+      loopId: string; taskId: string; firstAllowedAt: string;
+    };
+    const eligibleClock = vi.spyOn(Date, 'now').mockReturnValue(Date.parse(firstAllowedAt) + 1);
+    try {
+      expect(await harness.wake('explicit check', taskId)).not.toBeNull();
+    } finally {
+      eligibleClock.mockRestore();
+    }
+    expect(harness.requests[0]?.filter((message) => message.role === 'user').at(-1)?.content)
+      .toBe('explicit check');
+    expect((await harness.command('loop', `stop ${loopId}`))?.success).toBe(true);
+  });
+
+  it('honors an explicit schedule edit to a fixed loop that originally used the default', async () => {
+    let prompt = 'default first';
+    const resolveDefaultPrompt = () => prompt;
+    harness = scriptedSession({
+      turns: [{ text: 'done' }],
+      commandModules: [createScheduleCommandModule({ defaultPrompt: 'fallback', resolveDefaultPrompt })],
+      resolveDefaultLoopPrompt: resolveDefaultPrompt,
+      askHandler: confirmDefaultStart,
+      backgroundTasks: true,
+      persistence: true,
+    });
+    const created = await harness.command('loop', '5m');
+    expect(created?.success).toBe(true);
+    const { loopId, taskId, firstAllowedAt } = created?.data as {
+      loopId: string; taskId: string; firstAllowedAt: string;
+    };
+    expect((await harness.command('schedule', `edit ${taskId} cron "*/5 * * * *" explicit edit`))?.success)
+      .toBe(true);
+    prompt = 'default changed';
+    const eligibleClock = vi.spyOn(Date, 'now').mockReturnValue(Date.parse(firstAllowedAt) + 1);
+    try {
+      expect(await harness.wake('explicit edit', taskId)).not.toBeNull();
+    } finally {
+      eligibleClock.mockRestore();
+    }
+    expect(harness.requests[0]?.filter((message) => message.role === 'user').at(-1)?.content)
+      .toBe('explicit edit');
+    expect((await harness.command('loop', `stop ${loopId}`))?.success).toBe(true);
+  });
+
+  it('runs a prompt-only iteration, records the model delay, and stops its one-shot timer', async () => {
+    harness = scriptedSession({
+      turns: [
+        { toolCalls: [{ name: 'report_loop_decision', args: {
+          action: 'continue', delaySeconds: 60, reason: 'Recheck after the build settles',
+        } }] },
+        { text: 'Build still running.' },
+      ],
+      commandModules: [createScheduleCommandModule()],
+      backgroundTasks: true,
+      persistence: true,
+    });
+    let phaseAtComplete: string | undefined;
+    let historyAtComplete = '';
+    harness.session.on('complete', () => {
+      phaseAtComplete = harness?.session.listSelfPacedLoops()[0]?.phase;
+      historyAtComplete = JSON.stringify(harness?.session.getFullHistory());
+    });
+    const created = await harness.command('loop', 'check the build');
+    expect(created?.success).toBe(true);
+    const loopId = (created?.data as { loopId: string }).loopId;
+    await vi.waitFor(() =>
+      expect(harness?.session.listSelfPacedLoops().find((loop) => loop.loopId === loopId))
+        .toMatchObject({ phase: 'waiting', generation: 1, delaySeconds: 60, fallbackUsed: false }),
+    );
+    const timer = harness.session.listSchedules().find(
+      (task) => task.metadata?.['sessionLoopId'] === loopId && task.metadata?.['sessionLoopSelfPaced'],
+    );
+    expect(timer?.kind === 'scheduled' ? timer.schedule?.cronExpression : undefined).toBe(
+      harness.session.listSelfPacedLoops().find((loop) => loop.loopId === loopId)?.nextAllowedAt,
+    );
+    const listed = await harness.command('loop', 'list');
+    expect(listed?.message).toContain(loopId);
+    expect(listed?.message).toContain('60s');
+    expect(listed?.message).toContain('Recheck after the build settles');
+    expect(JSON.stringify(harness.session.getFullHistory()))
+      .toContain('Recheck after the build settles');
+    expect(phaseAtComplete).toBe('waiting');
+    expect(historyAtComplete).toContain('Recheck after the build settles');
+    expect((await harness.command('loop', `stop ${loopId}`))?.success).toBe(true);
+    expect(harness.session.listSelfPacedLoops().find((loop) => loop.loopId === loopId)?.phase).toBe('stopped');
+    expect((await harness.command('loop', 'list'))?.message).toBe('No active loops.');
+  });
+
+  it('restores one future self-paced wake with a new timer id, without replaying the turn', async () => {
+    harness = scriptedSession({
+      turns: [{ text: 'Still waiting.' }],
+      commandModules: [createScheduleCommandModule()],
+      backgroundTasks: true,
+      persistence: true,
+    });
+    const created = await harness.command('loop', 'check the build');
+    const loopId = (created?.data as { loopId: string }).loopId;
+    await vi.waitFor(() =>
+      expect(harness?.session.listSelfPacedLoops().find((loop) => loop.loopId === loopId)?.phase)
+        .toBe('waiting'),
+    );
+    const firstTimer = harness.session.listSchedules().find(
+      (task) => task.metadata?.['sessionLoopId'] === loopId,
+    )!;
+    const sessionId = harness.session.getSession().getSessionId();
+    await harness.session.shutdown({ reason: 'other' });
+
+    const resumed = scriptedSession({
+      turns: [],
+      cwd: harness.cwd,
+      resumeSessionId: sessionId,
+      backgroundTasks: true,
+      persistence: true,
+    });
+    try {
+      await vi.waitFor(() =>
+        expect(resumed.session.listSchedules().some(
+          (task) => task.metadata?.['sessionLoopId'] === loopId && task.id !== firstTimer.id,
+        )).toBe(true),
+      );
+      expect(resumed.requests).toHaveLength(0);
+      expect(resumed.session.listSelfPacedLoops().find((loop) => loop.loopId === loopId)?.phase)
+        .toBe('waiting');
+    } finally {
+      await resumed.dispose();
+    }
+  });
+
+  it('does not honor a denied model reschedule call', async () => {
+    harness = scriptedSession({
+      turns: [
+        { toolCalls: [{ name: 'report_loop_decision', args: {
+          action: 'continue', delaySeconds: 60, reason: 'Model asked, host denied',
+        } }] },
+        { text: 'done' },
+      ],
+      commandModules: [createScheduleCommandModule()],
+      backgroundTasks: true,
+      persistence: true,
+      deniedTools: ['report_loop_decision'],
+      permissionMode: 'default',
+    });
+    const created = await harness.command('loop', 'check');
+    expect(created?.success).toBe(true);
+    await vi.waitFor(() =>
+      expect(harness?.session.listSelfPacedLoops()[0]?.phase).toBe('waiting'),
+    );
+    expect(harness.session.listSelfPacedLoops()[0]).toMatchObject({
+      delaySeconds: 1200,
+      fallbackUsed: true,
+    });
+  });
+
+  it('runs only one fallback wake after omitted decisions, then stops', async () => {
+    harness = scriptedSession({
+      turns: [{ text: 'First check.' }, { text: 'Second check.' }],
+      commandModules: [createScheduleCommandModule()],
+      backgroundTasks: true,
+      persistence: true,
+    });
+    const created = await harness.command('loop', 'check');
+    const loopId = (created?.data as { loopId: string }).loopId;
+    await vi.waitFor(() =>
+      expect(harness?.session.listSelfPacedLoops()[0]).toMatchObject({
+        phase: 'waiting', generation: 1, fallbackUsed: true,
+      }),
+    );
+    const timer = harness.session.listSchedules().find(
+      (task) => task.metadata?.['sessionLoopId'] === loopId,
+    )!;
+    const nextAllowedAt = harness.session.listSelfPacedLoops()[0]!.nextAllowedAt!;
+    const clock = vi.spyOn(Date, 'now').mockReturnValue(Date.parse(nextAllowedAt) + 1);
+    try {
+      expect(await harness.wake('check', timer.id)).not.toBeNull();
+    } finally {
+      clock.mockRestore();
+    }
+    await vi.waitFor(() =>
+      expect(harness?.session.listSelfPacedLoops()[0]).toMatchObject({
+        phase: 'stopped', terminalReason: 'missing-reschedule-decision',
+      }),
+    );
+    expect(harness.requests).toHaveLength(2);
+  });
+
+  it('allows the model to stop its own loop without arming a timer', async () => {
+    harness = scriptedSession({
+      turns: [
+        { toolCalls: [{ name: 'report_loop_decision', args: { action: 'stop' } }] },
+        { text: 'Done checking.' },
+      ],
+      commandModules: [createScheduleCommandModule()],
+      backgroundTasks: true,
+      persistence: true,
+    });
+    await harness.command('loop', 'check');
+    await vi.waitFor(() =>
+      expect(harness?.session.listSelfPacedLoops()[0]).toMatchObject({
+        phase: 'stopped', terminalReason: 'model-stopped',
+      }),
+    );
+    expect(harness.session.listSchedules().filter((task) => task.metadata?.['sessionLoopSelfPaced']))
+      .toHaveLength(0);
+  });
+
+  it('uses the host maintenance prompt, persists expiry, and refuses a wake after expiry', async () => {
+    const maintenancePrompt = 'Check the current work only.';
+    harness = scriptedSession({
+      turns: [{ text: 'unused' }],
+      commandModules: [createScheduleCommandModule({ defaultPrompt: maintenancePrompt })],
+      askHandler: confirmDefaultStart,
+      backgroundTasks: true,
+      persistence: true,
+    });
+
+    const created = await harness.command('loop', '5m');
+    expect(created?.success).toBe(true);
+    const { taskId, expiresAt, firstAllowedAt } = created?.data as {
+      taskId: string;
+      expiresAt: string;
+      firstAllowedAt: string;
+    };
+    const scheduled = harness.session.listSchedules().find((task) => task.id === taskId);
+    expect(scheduled?.kind === 'scheduled' ? scheduled.schedule?.agentInstruction : undefined).toBe(
+      maintenancePrompt,
+    );
+    expect(scheduled?.metadata?.['sessionLoopExpiresAt']).toBe(expiresAt);
+    expect(scheduled?.metadata?.['sessionLoopFirstAllowedAt']).toBe(firstAllowedAt);
+
+    const earlyClock = vi.spyOn(Date, 'now').mockReturnValue(Date.parse(firstAllowedAt) - 1);
+    try {
+      expect(await harness.wake(maintenancePrompt, taskId)).toBeNull();
+      expect(harness.requests).toHaveLength(0);
+    } finally {
+      earlyClock.mockRestore();
+    }
+
+    const clock = vi.spyOn(Date, 'now').mockReturnValue(Date.parse(expiresAt) + 1);
+    try {
+      expect(await harness.wake(maintenancePrompt, taskId)).toBeNull();
+      await vi.waitFor(() =>
+        expect(harness?.session.listSchedules().find((task) => task.id === taskId)?.status).toBe(
+          'cancelled',
+        ),
+      );
+      expect(harness.requests).toHaveLength(0);
+    } finally {
+      clock.mockRestore();
+    }
+  });
+
+  it('creates, lists, and stops one scheduled wake without cancelling another schedule', async () => {
+    harness = scriptedSession({
+      turns: [{ text: 'unused' }],
+      commandModules: [createScheduleCommandModule()],
+      backgroundTasks: true,
+      persistence: true,
+    });
+
+    const other = await harness.command('schedule', 'cron "0 0 * * *" unrelated check');
+    expect(other?.success).toBe(true);
+
+    const created = await harness.command('loop', '1h check the build');
+    expect(created?.success).toBe(true);
+    const { loopId, taskId, firstAllowedAt } = created?.data as {
+      loopId: string;
+      taskId: string;
+      firstAllowedAt: string;
+    };
+    expect(loopId).not.toBe(taskId);
+    expect(created?.message).toContain(`Stop with /loop stop ${loopId}`);
+
+    const listed = await harness.command('loop', 'list');
+    expect(listed?.message).toContain(loopId);
+    expect(listed?.message).not.toContain('unrelated check');
+
+    const eligibleClock = vi.spyOn(Date, 'now').mockReturnValue(Date.parse(firstAllowedAt) + 1);
+    const fired = await harness
+      .wake('check the build', taskId)
+      .finally(() => eligibleClock.mockRestore());
+    expect(fired).not.toBeNull();
+    expect(harness.requests.length).toBe(1);
+    await new Promise<void>((resolve) => setImmediate(resolve));
+
+    const edited = await harness.command(
+      'schedule',
+      `edit ${taskId} cron "0 0 * * *" renamed check`,
+    );
+    expect(edited?.success).toBe(true);
+    expect((await harness.command('loop', 'list'))?.message).toContain(loopId);
+
+    const stopped = await harness.command('loop', `stop ${loopId}`);
+    expect(stopped?.message).toContain('Loop stopped:');
+    expect(await harness.wake('check the build', taskId)).toBeNull();
+    expect((await harness.command('loop', 'list'))?.message).toBe('No active loops.');
+    expect((await harness.command('schedule', 'list'))?.message).toContain('unrelated check');
+  }, 20_000);
+});