feat(loop): add nested slash commands, day unit, and natural language interval

- Nested slash commands: loop iterations now submit as string (not
  Part[]) so `/loop 5m /review` executes /review on each iteration.
  First iteration also goes through the callback+state drain path
  instead of submit_prompt, ensuring consistent behavior.
- Day interval unit: parseInterval/formatInterval now support `d`
  (e.g., `/loop 1d check status`). MAX_INTERVAL_MS already covers 24h.
- Natural language interval: `/loop check deploy every 5m` extracts
  the interval from the prompt tail (regex: `every <interval>$`).
- Changed pendingLoopPrompt from ref to React state to trigger
  re-renders when the timer callback queues a prompt during Idle.
- Added tests for day parsing/formatting (27 total).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: wenshao

packages/cli/src/ui/AppContainer.tsx

@@ -945,15 +945,14 @@ export const AppContainer = (props: AppContainerProps) => {
   historyManagerRef.current = historyManager;
   const submitQueryRef = useRef(submitQuery);
   submitQueryRef.current = submitQuery;
-  const streamingStateRef = useRef(streamingState);
-  streamingStateRef.current = streamingState;
 
-  // Pending loop prompt waiting for Idle before submission (set when timer
-  // fires during active streaming).
-  const loopSubmitRef = useRef<Array<{ text: string }> | null>(null);
+  // Pending loop prompt (string) waiting for Idle before submission.
+  // Using state (not ref) so that setting it triggers a re-render and the
+  // drain effect fires — even when streamingState is already Idle.
+  const [pendingLoopPrompt, setPendingLoopPrompt] = useState<string | null>(
+    null,
+  );
   // Whether the current streaming response was initiated by the loop.
-  // Set true when a loop prompt is submitted; cleared by handleFinalSubmit
-  // (user-initiated) or when the completion effect processes the response.
   const loopInitiatedStreamRef = useRef(false);
 
   useEffect(() => {
@@ -978,17 +977,10 @@ export const AppContainer = (props: AppContainerProps) => {
         },
         Date.now(),
       );
-      // Submit as Part[] to bypass slash-command parsing (consistent with
-      // the first-iteration submit_prompt path in loopCommand.ts).
-      const parts: Array<{ text: string }> = [{ text: prompt }];
-      if (streamingStateRef.current === StreamingState.Idle) {
-        // Common path: timer fires while idle — submit immediately.
-        loopInitiatedStreamRef.current = true;
-        void submitQueryRef.current(parts);
-      } else {
-        // Edge case: timer fires during active streaming — queue for later.
-        loopSubmitRef.current = parts;
-      }
+      // Queue the prompt as a string.  Submitting as string (not Part[])
+      // allows nested slash commands (e.g. /loop 5m /review) to be parsed
+      // and executed on each iteration via isSlashCommand().
+      setPendingLoopPrompt(prompt);
     });
     return () => {
       const lm = getLoopManager();
@@ -1012,13 +1004,9 @@ export const AppContainer = (props: AppContainerProps) => {
       return;
     }
     // loopInitiatedStreamRef is true for iterations submitted via the
-    // callback (2nd+).  For the FIRST iteration, submitted via the
-    // slash-command's submit_prompt return value, the ref is never set —
-    // but waitingForResponse is already true from manager.start(), so we
-    // accept it as a loop response when no queued prompt is pending.
-    if (!loopInitiatedStreamRef.current && loopSubmitRef.current !== null) {
-      // A queued prompt exists but hasn't been submitted yet — the stream
-      // that just finished is NOT from the loop (e.g. user's message).
+    // drain effect.  When false but a pending prompt exists, the stream
+    // that just finished is NOT from the loop (e.g. user's message).
+    if (!loopInitiatedStreamRef.current && pendingLoopPrompt !== null) {
       return;
     }
     loopInitiatedStreamRef.current = false;
@@ -1092,21 +1080,21 @@ export const AppContainer = (props: AppContainerProps) => {
     // eslint-disable-next-line react-hooks/exhaustive-deps -- only run on streamingState transitions
   }, [streamingState]);
 
-  // Drain queued loop prompt when streaming becomes Idle.
-  // This only fires for the edge case where the timer fired during streaming.
+  // Drain pending loop prompt when streaming is Idle.
+  // Submits as string so nested slash commands (e.g. /review) are parsed.
   useEffect(() => {
-    if (streamingState !== StreamingState.Idle || !loopSubmitRef.current) {
+    if (streamingState !== StreamingState.Idle || pendingLoopPrompt === null) {
       return;
     }
-    const parts = loopSubmitRef.current;
-    loopSubmitRef.current = null;
+    const prompt = pendingLoopPrompt;
+    setPendingLoopPrompt(null);
     // If the loop was stopped while the prompt was queued, discard it.
     if (!getLoopManager().isActive()) {
       return;
     }
     loopInitiatedStreamRef.current = true;
-    void submitQueryRef.current(parts);
-  }, [streamingState]);
+    void submitQueryRef.current(prompt);
+  }, [streamingState, pendingLoopPrompt]);
 
   const [idePromptAnswered, setIdePromptAnswered] = useState(false);
   const [currentIDE, setCurrentIDE] = useState<IdeInfo | null>(null);

packages/cli/src/ui/commands/loopCommand.ts

@@ -84,7 +84,19 @@ function parseLoopArgs(args: string): {
     }
   }
 
-  const prompt = tokens.slice(startIndex).join(' ');
+  let prompt = tokens.slice(startIndex).join(' ');
+
+  // Support natural language interval at the end: "check deploy every 5m"
+  if (intervalMs === DEFAULT_INTERVAL_MS) {
+    const everyMatch = prompt.match(/\s+every\s+(\d+(?:\.\d+)?[smhd])\s*$/i);
+    if (everyMatch) {
+      const parsed2 = parseInterval(everyMatch[1]);
+      if (parsed2 !== null) {
+        intervalMs = parsed2;
+        prompt = prompt.slice(0, everyMatch.index).trim();
+      }
+    }
+  }
 
   return { intervalMs, maxIterations, prompt };
 }
@@ -239,27 +251,21 @@ export const loopCommand: SlashCommand = {
       Date.now(),
     );
 
-    // Start the loop — skipFirstIteration because we return submit_prompt below
-    manager.start(
-      {
-        prompt: parsed.prompt,
-        intervalMs: parsed.intervalMs,
-        maxIterations: parsed.maxIterations,
-      },
-      true,
-    );
-
-    // Submit the first iteration via the command system
-    return {
-      type: 'submit_prompt' as const,
-      content: [{ text: parsed.prompt }],
-    };
+    // Start the loop — the iteration callback (registered in AppContainer)
+    // will queue the first prompt via setPendingLoopPrompt, which triggers
+    // a React state update → drain effect submits it as a string so that
+    // nested slash commands (e.g. /loop 5m /review) are properly parsed.
+    manager.start({
+      prompt: parsed.prompt,
+      intervalMs: parsed.intervalMs,
+      maxIterations: parsed.maxIterations,
+    });
   },
 
   completion: async (_context, partialArg) => {
     const trimmed = partialArg.trim();
     if (!trimmed) {
-      return ['status', 'stop', '5m ', '10m ', '30m ', '1h '];
+      return ['status', 'stop', '5m ', '10m ', '30m ', '1h ', '1d '];
     }
     if ('status'.startsWith(trimmed)) {
       return ['status'];

packages/core/src/loop/loopManager.test.ts

@@ -29,6 +29,11 @@ describe('parseInterval', () => {
     expect(parseInterval('2h')).toBe(7_200_000);
   });
 
+  it('parses days', () => {
+    expect(parseInterval('1d')).toBe(86_400_000);
+    expect(parseInterval('2d')).toBe(172_800_000);
+  });
+
   it('returns null for invalid input', () => {
     expect(parseInterval('')).toBeNull();
     expect(parseInterval('abc')).toBeNull();
@@ -42,10 +47,16 @@ describe('parseInterval', () => {
     expect(parseInterval('5M')).toBe(300_000);
     expect(parseInterval('1H')).toBe(3_600_000);
     expect(parseInterval('30S')).toBe(30_000);
+    expect(parseInterval('1D')).toBe(86_400_000);
   });
 });
 
 describe('formatInterval', () => {
+  it('formats days', () => {
+    expect(formatInterval(86_400_000)).toBe('1d');
+    expect(formatInterval(172_800_000)).toBe('2d');
+  });
+
   it('formats hours', () => {
     expect(formatInterval(3_600_000)).toBe('1h');
     expect(formatInterval(7_200_000)).toBe('2h');

packages/core/src/loop/loopManager.ts

@@ -67,7 +67,7 @@ export type LoopIterationCallback = (prompt: string, iteration: number) => void;
  * Returns null if the string is not a valid interval.
  */
 export function parseInterval(input: string): number | null {
-  const match = input.match(/^(\d+(?:\.\d+)?)(s|m|h)$/i);
+  const match = input.match(/^(\d+(?:\.\d+)?)(s|m|h|d)$/i);
   if (!match) return null;
 
   const value = parseFloat(match[1]);
@@ -81,6 +81,8 @@ export function parseInterval(input: string): number | null {
       return Math.round(value * 60 * 1000);
     case 'h':
       return Math.round(value * 60 * 60 * 1000);
+    case 'd':
+      return Math.round(value * 24 * 60 * 60 * 1000);
     default:
       return null;
   }
@@ -91,6 +93,9 @@ export function parseInterval(input: string): number | null {
  * Prefers the largest unit that gives a clean representation.
  */
 export function formatInterval(ms: number): string {
+  if (ms >= 86_400_000 && ms % 86_400_000 === 0) {
+    return `${ms / 86_400_000}d`;
+  }
   if (ms >= 3600_000 && ms % 3600_000 === 0) {
     return `${ms / 3600_000}h`;
   }