@robota-sdk/agent-command 3.0.0-beta.83 → 3.0.0-beta.85

package/src/provider/provider-command-execution.ts

@@ -1,17 +1,24 @@
 import {
+  confirmAction,
   findProviderDefinition,
   formatSupportedProviderTypes,
+  isConfirmed,
   selectAction,
 } from '@robota-sdk/agent-core';
 import { testProviderProfileCommand } from '@robota-sdk/agent-framework';
 
-import { buildProviderSwitch } from './provider-command-profile-operations.js';
+import {
+  buildProviderDuplicate,
+  buildProviderProfileDelete,
+} from './provider-command-profile-lifecycle.js';
+import { buildProviderEdit, buildProviderSwitch } from './provider-command-profile-operations.js';
 import { askProviderProfileSelection } from './provider-command-profile.js';
 import { createSetupFlow, runProviderAddSetup } from './provider-command-setup.js';
 import { formatProviderSetupChoiceLabel } from './provider-setup-flow.js';
 
 import type { IUserInteraction } from '@robota-sdk/agent-core';
 import type {
+  ICommandHostSetupState,
   ICommandHostUserInteraction,
   IProviderCommandModuleOptions,
   IProviderProfileSettings,
@@ -19,17 +26,21 @@ import type {
 import type { ICommandResult } from '@robota-sdk/agent-interface-command';
 
 export async function executeProviderCommand(
-  context: ICommandHostUserInteraction,
+  context: ICommandHostUserInteraction & ICommandHostSetupState,
   args: string,
   options: IProviderCommandModuleOptions,
 ): Promise<ICommandResult> {
   const ui = context.getUserInteraction();
+  // #3282 §3: the session's own live state, never inferred from settings — an ordinary env-default
+  // session also has no persisted `currentProvider`, and is not in setup mode either.
+  const isSetupRequired = context.isSetupRequired?.() === true;
   const settings = options.settings.readMergedSettings();
   const trimmedArgs = args.trim();
   if (trimmedArgs.length === 0) {
     return buildProviderProfilePicker(ui, settings.currentProvider, settings.providers, options);
   }
-  const [subcommand = 'current', profileArg] = trimmedArgs.split(/\s+/);
+  const argTokens = trimmedArgs.split(/\s+/);
+  const [subcommand = 'current', profileArg] = argTokens;
 
   if (subcommand === 'list') {
     return buildProviderProfilePicker(ui, settings.currentProvider, settings.providers, options);
@@ -51,12 +62,45 @@ export async function executeProviderCommand(
       options,
     );
   }
+  // #3282 §4b: direct, non-interactive forms of what the profile-action menu otherwise reaches
+  // through two asks (`askProviderProfileSelection` then `askProviderProfileAction`) — for a caller
+  // (the Settings screen, or a typed command) that already names the profile and does not want the
+  // "which profile" ask repeated. `edit`/`duplicate` still ask their own follow-up questions (the
+  // new name, the changed fields) exactly as the menu's Edit/Duplicate do.
+  if (subcommand === 'edit') {
+    if (!ui) return { message: 'Provider edit requires an interactive session.', success: false };
+    if (!profileArg) return { message: 'Usage: provider edit <profile>', success: false };
+    return buildProviderEdit(ui, profileArg, options);
+  }
+  if (subcommand === 'duplicate') {
+    if (!ui) return { message: 'Provider duplicate requires an interactive session.', success: false };
+    if (!profileArg) return { message: 'Usage: provider duplicate <profile>', success: false };
+    return buildProviderDuplicate(ui, profileArg, options);
+  }
+  if (subcommand === 'delete') {
+    // #3282 §4b: `--confirmed` is set ONLY by the Settings screen's own write (`settings-reporter.ts`)
+    // — its "Delete…" button already confirmed through its own ConfirmDialog before sending this, and
+    // a modal write has nowhere to ask a follow-up question. A plainly-typed `delete <profile>` never
+    // carries it, so it confirms here first when a human can answer (matching `/clear`'s "confirm only
+    // when interactive; with no human the explicit form proceeds") — deleting a profile also deletes
+    // its stored key, unlike `switch`, which this direct-form family otherwise mirrors.
+    if (!profileArg) return { message: 'Usage: provider delete <profile>', success: false };
+    const preConfirmed = argTokens.includes('--confirmed');
+    if (!preConfirmed && ui) {
+      const response = await ui.ask(confirmAction('provider-delete', `Delete profile "${profileArg}"?`));
+      if (!isConfirmed(response)) {
+        return { message: 'Provider delete cancelled.', success: true };
+      }
+    }
+    return buildProviderProfileDelete(settings.providers, settings.currentProvider, profileArg, options);
+  }
   if (subcommand === 'add') {
-    return buildProviderSetup(ui, profileArg, options);
+    return buildProviderSetup(ui, profileArg, options, isSetupRequired);
   }
 
   return {
-    message: 'Usage: provider [current|list|switch <profile>|add <type>|test [profile]]',
+    message:
+      'Usage: provider [current|list|switch <profile>|edit <profile>|duplicate <profile>|delete <profile>|add <type>|test [profile]]',
     success: false,
   };
 }
@@ -121,6 +165,7 @@ function buildProviderSetup(
   ui: IUserInteraction | undefined,
   type: string | undefined,
   options: IProviderCommandModuleOptions,
+  isSetupRequired: boolean,
 ): Promise<ICommandResult> | ICommandResult {
   if (type === undefined || type.length === 0) {
     if (!ui) {
@@ -129,7 +174,7 @@ function buildProviderSetup(
         success: false,
       };
     }
-    return askProviderSetupType(ui, options);
+    return askProviderSetupType(ui, options, isSetupRequired);
   }
   if (findProviderDefinition(options.providerDefinitions, type) === undefined) {
     return {
@@ -143,12 +188,13 @@ function buildProviderSetup(
       success: false,
     };
   }
-  return runProviderAddSetup(ui, createSetupFlow(type, options), options);
+  return runProviderAddSetup(ui, createSetupFlow(type, options), options, isSetupRequired);
 }
 
 async function askProviderSetupType(
   ui: IUserInteraction,
   options: IProviderCommandModuleOptions,
+  isSetupRequired: boolean,
 ): Promise<ICommandResult> {
   const typeOptions = options.providerDefinitions.map((definition) => ({
     value: definition.type,
@@ -167,5 +213,5 @@ async function askProviderSetupType(
       success: false,
     };
   }
-  return runProviderAddSetup(ui, createSetupFlow(type, options), options);
+  return runProviderAddSetup(ui, createSetupFlow(type, options), options, isSetupRequired);
 }

package/src/provider/provider-command-profile-lifecycle.ts

@@ -8,7 +8,10 @@ import {
 import { formatProviderChoiceLabel } from './provider-command-profile-operations.js';
 
 import type { IUserInteraction } from '@robota-sdk/agent-core';
-import type { IProviderCommandModuleOptions } from '@robota-sdk/agent-framework';
+import type {
+  IProviderCommandModuleOptions,
+  IProviderProfileSettings,
+} from '@robota-sdk/agent-framework';
 import type { ICommandResult } from '@robota-sdk/agent-interface-command';
 
 const MAX_DUPLICATE_PROFILE_SUFFIX = 1000;
@@ -90,6 +93,47 @@ function completeProviderDuplicate(
   };
 }
 
+/**
+ * #3282 §4b: the direct, non-interactive delete itself — no replacement ask (the interactive
+ * per-profile menu's Delete, `buildProviderDelete` below, still offers one); refuses instead when the
+ * profile is the one in use. Never asks to CONFIRM either — its caller in `provider-command-execution`
+ * does that first, when a human can answer, before reaching this function; this function itself is
+ * called only once a delete is already decided (confirmed by a human, or `--confirmed` from the
+ * Settings screen's own ConfirmDialog).
+ */
+export function buildProviderProfileDelete(
+  providers: Record<string, IProviderProfileSettings> | undefined,
+  currentProvider: string | undefined,
+  profileName: string | undefined,
+  options: IProviderCommandModuleOptions,
+): ICommandResult {
+  if (!profileName) {
+    return { message: 'Usage: /provider delete <profile>', success: false };
+  }
+  if (!providers?.[profileName]) {
+    return { message: `Provider profile "${profileName}" was not found.`, success: false };
+  }
+  if (Object.keys(providers).length <= 1) {
+    return { message: 'Cannot delete the only provider profile.', success: false };
+  }
+  if (currentProvider === profileName) {
+    return {
+      message: 'Cannot delete the profile in use. Switch to another profile first.',
+      success: false,
+    };
+  }
+  if (options.settings.readTargetSettings().providers?.[profileName] === undefined) {
+    return {
+      message: `Provider profile "${profileName}" is not stored in the active write target; edit its source settings file or override it before deleting.`,
+      success: false,
+    };
+  }
+  options.settings.writeTargetSettings(
+    deleteProviderProfile(options.settings.readTargetSettings(), profileName),
+  );
+  return { message: `Provider profile deleted: ${profileName}.`, success: true };
+}
+
 export async function buildProviderDelete(
   ui: IUserInteraction,
   profileName: string,
@@ -109,8 +153,10 @@ export async function buildProviderDelete(
       success: false,
     };
   }
+  // #3282 §2: the GUI renders this confirm on its shared ConfirmDialog (id 'provider-delete') with
+  // this exact title — kept in the quoted-name form the TUI's inline picker shows the same way.
   const response = await ui.ask(
-    confirmAction('provider-delete', `Delete provider profile ${profileName}?`),
+    confirmAction('provider-delete', `Delete profile "${profileName}"?`),
   );
   if (!isConfirmed(response)) {
     return { message: 'Provider delete cancelled.', success: true };

package/src/provider/provider-command-profile-operations.ts

@@ -4,6 +4,7 @@ import {
   isApiKeyPlaintext,
   setCurrentProvider,
   upsertProviderProfile,
+  validateProviderProfile,
 } from '@robota-sdk/agent-framework';
 
 import { runProviderSetupAsk } from './provider-command-setup.js';
@@ -51,6 +52,19 @@ export function buildProviderSwitch(
     return { message: `Already using provider "${profileName}".`, success: true };
   }
   const profile = providers[profileName];
+  // #3282: the hot-swap this returns as a `hostActions` entry builds this exact profile against
+  // these exact definitions (`resolveUserSettingsProviderSwitch` in agent-framework). Validating it
+  // HERE, before anything is written, means a switch that would fail changes nothing on disk — the
+  // previous behavior wrote `currentProvider` unconditionally and let a downstream hot-swap failure
+  // (e.g. "Unknown provider: anthropic. Currently supported: ", an empty list) stand uncorrected.
+  try {
+    validateProviderProfile(profileName, profile, { providerDefinitions: options.providerDefinitions });
+  } catch (error) {
+    return {
+      message: `Failed to switch to "${profileName}": ${error instanceof Error ? error.message : String(error)}`,
+      success: false,
+    };
+  }
   const target = options.settings.readTargetSettings();
   const merged = options.settings.readMergedSettings();
   const next =

package/src/provider/provider-command-profile.ts

@@ -23,7 +23,6 @@ const ACTION_EDIT = 'edit';
 const ACTION_TEST = 'test';
 const ACTION_DUPLICATE = 'duplicate';
 const ACTION_DELETE = 'delete';
-const ACTION_CANCEL = 'cancel';
 
 /**
  * Ask the user to pick a provider profile, then drive its action menu (CMD-004 inline ask). Replaces
@@ -58,6 +57,13 @@ async function askProviderProfileAction(
   if (!settings.providers?.[profileName]) {
     return { message: `Provider profile "${profileName}" was not found.`, success: false };
   }
+  // #3282 §2: no separate 'cancel' option here — the picker's own persistent Cancel affordance
+  // (every ask renderer offers one, e.g. `PermissionPrompt`'s ghost Cancel button in agent-ui-web)
+  // is the only Cancel a person sees. A second one, indistinguishable from Switch/Edit/Test/Duplicate
+  // in a flat list, was the audited bug (#3282 issue text): "Delete looks the same as Switch... plus
+  // a second Cancel." Order matters too — Switch first as the primary action, then Edit/Test/
+  // Duplicate, with Delete last: a client (the GUI's provider-action menu) that wants Delete
+  // separated and styled destructive can rely on it always being the final entry.
   const response = await ui.ask(
     selectAction('provider-profile-action', `Provider profile: ${profileName}`, [
       { value: ACTION_SWITCH, label: 'Switch' },
@@ -65,7 +71,6 @@ async function askProviderProfileAction(
       { value: ACTION_TEST, label: 'Test' },
       { value: ACTION_DUPLICATE, label: 'Duplicate' },
       { value: ACTION_DELETE, label: 'Delete' },
-      { value: ACTION_CANCEL, label: 'Cancel' },
     ]),
   );
   if (response.type !== 'answer' || response.values[0] === undefined) {
@@ -97,8 +102,6 @@ async function executeProviderProfileAction(
       return buildProviderDuplicate(ui, profileName, options);
     case ACTION_DELETE:
       return buildProviderDelete(ui, profileName, options);
-    case ACTION_CANCEL:
-      return { message: 'Provider profile action cancelled.', success: true };
     default:
       return { message: `Unknown provider profile action "${action}".`, success: false };
   }

package/src/provider/provider-command-setup.ts

@@ -87,11 +87,12 @@ export function runProviderAddSetup(
   ui: IUserInteraction,
   flow: IProviderSetupFlowState,
   options: IProviderCommandModuleOptions,
+  isSetupRequired: boolean,
 ): Promise<ICommandResult> {
   return runProviderSetupAsk(
     ui,
     flow,
-    (input) => completeProviderSetup(input, options),
+    (input) => completeProviderSetup(input, options, isSetupRequired),
     'Provider setup cancelled.',
   );
 }
@@ -99,12 +100,24 @@ export function runProviderAddSetup(
 function completeProviderSetup(
   input: IProviderSetupInput,
   options: IProviderCommandModuleOptions,
+  isSetupRequired: boolean,
 ): ICommandResult {
   const target = options.settings.readTargetSettings();
   const patch = buildProviderSetupPatch(input, {
     providerDefinitions: options.providerDefinitions,
   });
   options.settings.writeTargetSettings(mergeProviderPatch(target, patch));
+  // #3282 §3: the session's own live setup-mode state (never settings — an ordinary env-default
+  // session also has no persisted `currentProvider`, and restarts like any other session). Only a
+  // session that itself started with a placeholder provider hot-swaps the real one in; every other
+  // `/provider add`, even a session's first EVER persisted profile, restarts as before.
+  if (isSetupRequired) {
+    return {
+      message: `Provider ${input.profile} configured.`,
+      success: true,
+      hostActions: [{ type: 'provider-hot-swap', profileName: input.profile }],
+    };
+  }
   return {
     message: `Provider ${input.profile} configured. Restarting...`,
     success: true,

package/src/rewind/__tests__/rewind-command-module.test.ts

@@ -278,7 +278,8 @@ describe('executeRewindCommand', () => {
       const result = await session.executeCommand('rewind', 'list');
 
       expect(result?.success).toBe(false);
-      expect(result?.message).toContain('cannot prove a write stays inside the project');
+      // #3289 §3: plain words naming the feature ("Rewind"), not the internal write-containment reason.
+      expect(result?.message).toBe("Rewind isn't available on this computer yet.");
       expect(result?.message).not.toContain('trust');
     });
   });

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

@@ -10,6 +10,15 @@ afterEach(async () => {
   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';
@@ -18,6 +27,7 @@ describe('/loop command in a real interactive session', () => {
       turns: [{ text: 'first' }, { text: 'second' }],
       commandModules: [createScheduleCommandModule({ defaultPrompt: 'fallback', resolveDefaultPrompt })],
       resolveDefaultLoopPrompt: resolveDefaultPrompt,
+      askHandler: confirmDefaultStart,
       backgroundTasks: true,
       persistence: true,
     });
@@ -51,6 +61,7 @@ describe('/loop command in a real interactive session', () => {
       turns: [{ text: 'first' }, { text: 'second' }],
       commandModules: [createScheduleCommandModule({ defaultPrompt: 'fallback', resolveDefaultPrompt })],
       resolveDefaultLoopPrompt: resolveDefaultPrompt,
+      askHandler: confirmDefaultStart,
       backgroundTasks: true,
       persistence: true,
     });
@@ -109,6 +120,7 @@ describe('/loop command in a real interactive session', () => {
       turns: [{ text: 'done' }],
       commandModules: [createScheduleCommandModule({ defaultPrompt: 'fallback', resolveDefaultPrompt })],
       resolveDefaultLoopPrompt: resolveDefaultPrompt,
+      askHandler: confirmDefaultStart,
       backgroundTasks: true,
       persistence: true,
     });
@@ -297,6 +309,7 @@ describe('/loop command in a real interactive session', () => {
     harness = scriptedSession({
       turns: [{ text: 'unused' }],
       commandModules: [createScheduleCommandModule({ defaultPrompt: maintenancePrompt })],
+      askHandler: confirmDefaultStart,
       backgroundTasks: true,
       persistence: true,
     });

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

@@ -2,15 +2,27 @@ import { describe, expect, it, vi } from 'vitest';
 
 import { executeLoopCommand } from '../loop-command.js';
 
+import type { ILoopInvocationContext } from '../loop-command.js';
 import { createTestAgentJobHost } from '@robota-sdk/agent-framework/testing';
 
+/**
+ * #3288 §1: every default-prompt form (bare or interval-only) is gated on confirmation — an
+ * interactive invocation with an ask port that answers Start, for a test whose OWN point is
+ * something else (default-prompt resolution, cadence, etc.), not the confirmation gate itself.
+ */
+function interactiveStart(): ILoopInvocationContext {
+  return { ui: { ask: vi.fn().mockResolvedValue({ type: 'answer', values: ['start'] }) }, source: 'user' };
+}
+
 describe('fixed in-session loop', () => {
   it('uses the host maintenance prompt for interval-only forms', async () => {
     const spawnScheduledWake = vi.fn().mockResolvedValue({ id: 'loop_default' });
     const host = createTestAgentJobHost({ spawnScheduledWake });
     const options = { defaultPrompt: 'Tend only the current task and its PR.' };
 
-    expect((await executeLoopCommand(host, vi.fn(), '5m', options)).success).toBe(true);
+    expect(
+      (await executeLoopCommand(host, vi.fn(), '5m', options, interactiveStart())).success,
+    ).toBe(true);
     expect(spawnScheduledWake).toHaveBeenLastCalledWith(
       expect.objectContaining({
         cronExpression: expect.any(String),
@@ -27,7 +39,10 @@ describe('fixed in-session loop', () => {
     const host = createTestAgentJobHost({ spawnScheduledWake, createSelfPacedLoop });
     const options = { defaultPrompt: 'Tend the current task.' };
 
-    expect((await executeLoopCommand(host, vi.fn(), '', options)).success).toBe(true);
+    expect(
+      (await executeLoopCommand(host, vi.fn(), '', options, interactiveStart())).success,
+    ).toBe(true);
+    // An explicit prompt is never gated — no invocation (headless) needed to succeed.
     expect((await executeLoopCommand(host, vi.fn(), 'check the build')).success).toBe(true);
     expect(createSelfPacedLoop.mock.calls.map(([prompt]) => prompt)).toEqual([
       options.defaultPrompt,
@@ -45,9 +60,13 @@ describe('fixed in-session loop', () => {
     const resolveDefaultPrompt = vi.fn().mockReturnValue('current file prompt');
     const options = { defaultPrompt: 'built-in prompt', resolveDefaultPrompt };
 
-    expect((await executeLoopCommand(host, vi.fn(), '', options)).success).toBe(true);
+    expect(
+      (await executeLoopCommand(host, vi.fn(), '', options, interactiveStart())).success,
+    ).toBe(true);
     expect(createSelfPacedLoop).toHaveBeenCalledWith('current file prompt', { useDefaultPrompt: true });
-    expect((await executeLoopCommand(host, vi.fn(), '5m', options)).success).toBe(true);
+    expect(
+      (await executeLoopCommand(host, vi.fn(), '5m', options, interactiveStart())).success,
+    ).toBe(true);
     expect(spawnScheduledWake).toHaveBeenCalledWith(expect.objectContaining({
       agentInstruction: 'current file prompt', sessionLoopDefaultPrompt: true,
     }));
@@ -358,3 +377,218 @@ describe('fixed in-session loop', () => {
     },
   );
 });
+
+/**
+ * #3288 §1: every form that falls back to the host's default maintenance prompt — bare `/loop` or
+ * an interval-only `/loop <N><s|m|h|d>` (self-paced or fixed cadence) — keeps working on its own for
+ * up to 7 days: a standing commitment the operator never typed, gated the same way regardless of
+ * which form reached it. An explicit prompt is the operator's own instruction and is never gated.
+ * A model-invoked call is always refused outright; an interactive one (an ask port attached) asks;
+ * a headless one (no ask port — print mode, a scheduled run) is refused too, the same reason as the
+ * model: nobody is there to say yes to a loop that can run for a week.
+ */
+describe('/loop asks before starting on its own (#3288 §1)', () => {
+  function askResolving(value: 'start' | 'cancel'): ReturnType<typeof vi.fn> {
+    return vi.fn().mockResolvedValue({ type: 'answer', values: [value] });
+  }
+
+  it('asks before creating a bare self-paced loop, and creates it on Start', async () => {
+    const createSelfPacedLoop = vi.fn().mockResolvedValue({
+      loopId: 'loop_default',
+      expiresAt: '2030-01-01T00:00:00.000Z',
+    });
+    const host = createTestAgentJobHost({ createSelfPacedLoop });
+    const ask = askResolving('start');
+    const options = { defaultPrompt: 'Tend the current task.\nCheck CI when it finishes.' };
+
+    const result = await executeLoopCommand(host, vi.fn(), '', options, { ui: { ask }, source: 'user' });
+
+    expect(ask).toHaveBeenCalledTimes(1);
+    const request = ask.mock.calls[0]![0] as { title: string; options: Array<{ value: string }> };
+    expect(request.title).toContain('Start a loop that keeps working on its own for up to 7 days');
+    expect(request.title).toContain('Tend the current task.');
+    expect(request.title).not.toContain('Check CI when it finishes.');
+    expect(request.options.map((option) => option.value)).toEqual(['start', 'cancel']);
+    expect(createSelfPacedLoop).toHaveBeenCalledWith('Tend the current task.\nCheck CI when it finishes.', {
+      useDefaultPrompt: true,
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('does not create the loop when the user cancels', async () => {
+    const createSelfPacedLoop = vi.fn();
+    const host = createTestAgentJobHost({ createSelfPacedLoop });
+    const ask = askResolving('cancel');
+    const options = { defaultPrompt: 'Tend the current task.' };
+
+    const result = await executeLoopCommand(host, vi.fn(), '', options, { ui: { ask }, source: 'user' });
+
+    expect(createSelfPacedLoop).not.toHaveBeenCalled();
+    expect(result).toMatchObject({ success: true, message: 'Loop not started.' });
+  });
+
+  it('treats a dismissed (cancelled) ask the same as Cancel', async () => {
+    const createSelfPacedLoop = vi.fn();
+    const host = createTestAgentJobHost({ createSelfPacedLoop });
+    const ask = vi.fn().mockResolvedValue({ type: 'cancelled' });
+    const options = { defaultPrompt: 'Tend the current task.' };
+
+    const result = await executeLoopCommand(host, vi.fn(), '', options, { ui: { ask }, source: 'user' });
+
+    expect(createSelfPacedLoop).not.toHaveBeenCalled();
+    expect(result.success).toBe(true);
+    expect(result.message).toBe('Loop not started.');
+  });
+
+  it('lists other active loops in the confirmation', async () => {
+    const createSelfPacedLoop = vi.fn().mockResolvedValue({
+      loopId: 'loop_new',
+      expiresAt: '2030-01-01T00:00:00.000Z',
+    });
+    const host = createTestAgentJobHost({
+      createSelfPacedLoop,
+      listSelfPacedLoops: () => [
+        {
+          loopId: 'loop_existing',
+          instruction: 'watch CI',
+          phase: 'waiting',
+          createdAt: '2026-09-24T00:00:00.000Z',
+          expiresAt: '2026-10-01T00:00:00.000Z',
+          revision: 1,
+          generation: 1,
+          fallbackUsed: false,
+        },
+      ],
+    });
+    const ask = askResolving('start');
+
+    await executeLoopCommand(host, vi.fn(), '', { defaultPrompt: 'Tend.' }, { ui: { ask }, source: 'user' });
+
+    const request = ask.mock.calls[0]![0] as { description?: string };
+    expect(request.description).toContain('loop_existing');
+  });
+
+  it('refuses a model-invoked bare loop outright, without asking', async () => {
+    const createSelfPacedLoop = vi.fn();
+    const host = createTestAgentJobHost({ createSelfPacedLoop });
+    const ask = vi.fn();
+    const options = { defaultPrompt: 'Tend the current task.' };
+
+    const result = await executeLoopCommand(host, vi.fn(), '', options, { ui: { ask }, source: 'model' });
+
+    expect(ask).not.toHaveBeenCalled();
+    expect(createSelfPacedLoop).not.toHaveBeenCalled();
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('/loop');
+  });
+
+  it('refuses a model-invoked bare loop even with no interactive renderer attached', async () => {
+    const createSelfPacedLoop = vi.fn();
+    const host = createTestAgentJobHost({ createSelfPacedLoop });
+    const options = { defaultPrompt: 'Tend the current task.' };
+
+    const result = await executeLoopCommand(host, vi.fn(), '', options, { ui: undefined, source: 'model' });
+
+    expect(createSelfPacedLoop).not.toHaveBeenCalled();
+    expect(result.success).toBe(false);
+  });
+
+  it('refuses a bare loop headless (no ask port attached) — never proceeds unconfirmed', async () => {
+    const createSelfPacedLoop = vi.fn();
+    const host = createTestAgentJobHost({ createSelfPacedLoop });
+    const options = { defaultPrompt: 'Tend the current task.' };
+
+    const result = await executeLoopCommand(host, vi.fn(), '', options, { ui: undefined, source: 'user' });
+
+    expect(createSelfPacedLoop).not.toHaveBeenCalled();
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('needs someone to confirm it');
+    expect(result.message).toContain('/loop <prompt>');
+  });
+
+  it('refuses an interval-only default-prompt loop headless too, the same as bare', async () => {
+    const spawnScheduledWake = vi.fn();
+    const host = createTestAgentJobHost({ spawnScheduledWake });
+    const options = { defaultPrompt: 'Tend the current task.' };
+
+    const result = await executeLoopCommand(host, vi.fn(), '1h', options, { ui: undefined, source: 'user' });
+
+    expect(spawnScheduledWake).not.toHaveBeenCalled();
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('needs someone to confirm it');
+  });
+
+  it('refuses a model-invoked interval-only default-prompt loop outright, without asking', async () => {
+    const spawnScheduledWake = vi.fn();
+    const host = createTestAgentJobHost({ spawnScheduledWake });
+    const ask = vi.fn();
+    const options = { defaultPrompt: 'Tend the current task.' };
+
+    const result = await executeLoopCommand(host, vi.fn(), '1h', options, { ui: { ask }, source: 'model' });
+
+    expect(ask).not.toHaveBeenCalled();
+    expect(spawnScheduledWake).not.toHaveBeenCalled();
+    expect(result.success).toBe(false);
+  });
+
+  it('asks for an interactive interval-only default-prompt loop, and creates it on Start', async () => {
+    const spawnScheduledWake = vi.fn().mockResolvedValue({ id: 'loop_task_interval' });
+    const host = createTestAgentJobHost({ spawnScheduledWake });
+    const ask = askResolving('start');
+    const options = { defaultPrompt: 'Tend the current task.' };
+
+    const result = await executeLoopCommand(host, vi.fn(), '1h', options, { ui: { ask }, source: 'user' });
+
+    expect(ask).toHaveBeenCalledTimes(1);
+    const request = ask.mock.calls[0]![0] as { title: string };
+    expect(request.title).toContain('Start a loop that keeps working on its own for up to 7 days');
+    expect(spawnScheduledWake).toHaveBeenCalledWith(
+      expect.objectContaining({ agentInstruction: options.defaultPrompt }),
+    );
+    expect(result.success).toBe(true);
+  });
+
+  it('never asks for an interval WITH an explicit prompt, even headless', async () => {
+    const spawnScheduledWake = vi.fn().mockResolvedValue({ id: 'loop_task_explicit_interval' });
+    const host = createTestAgentJobHost({ spawnScheduledWake });
+
+    // No invocation at all (defaults to headless, source 'user') — an explicit prompt is unaffected.
+    const result = await executeLoopCommand(host, vi.fn(), '1h check the build', {
+      defaultPrompt: 'Tend the current task.',
+    });
+
+    expect(spawnScheduledWake).toHaveBeenCalledWith(
+      expect.objectContaining({ agentInstruction: 'check the build' }),
+    );
+    expect(result.success).toBe(true);
+  });
+
+  it('never asks for an explicit prompt, even with a person attached', async () => {
+    const createSelfPacedLoop = vi.fn().mockResolvedValue({
+      loopId: 'loop_explicit',
+      expiresAt: '2030-01-01T00:00:00.000Z',
+    });
+    const host = createTestAgentJobHost({ createSelfPacedLoop });
+    const ask = vi.fn();
+
+    const result = await executeLoopCommand(host, vi.fn(), 'check the build', {}, { ui: { ask }, source: 'user' });
+
+    expect(ask).not.toHaveBeenCalled();
+    expect(createSelfPacedLoop).toHaveBeenCalledWith('check the build');
+    expect(result.success).toBe(true);
+  });
+
+  it('never asks for a fixed-cadence loop with an explicit prompt', async () => {
+    const spawnScheduledWake = vi.fn().mockResolvedValue({ id: 'loop_task_fixed' });
+    const host = createTestAgentJobHost({ spawnScheduledWake });
+    const ask = vi.fn();
+
+    const result = await executeLoopCommand(host, vi.fn(), '5m check the build', {}, {
+      ui: { ask },
+      source: 'user',
+    });
+
+    expect(ask).not.toHaveBeenCalled();
+    expect(result.success).toBe(true);
+  });
+});