idea-manager 0.4.0 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "idea-manager",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "AI 기반 브레인스토밍 → 구조화 → 프롬프트 생성 도구. MCP Server 내장.",
   "keywords": [
     "brainstorm",

package/src/app/projects/[id]/page.tsx

@@ -334,10 +334,6 @@ function WorkspaceInner({ id }: { id: string }) {
             <div style={{ width: leftWidth }} className="border-r border-border flex flex-col flex-shrink-0">
               <Editor
                 projectId={id}
-                onContentChange={() => {}}
-                onSendMessage={() => {}}
-                memos={[]}
-                chatLoading={false}
                 onCollapse={() => setShowBrainstorm(false)}
               />
             </div>

package/src/cli.ts

@@ -38,6 +38,23 @@ program
     await startMcpServer(ctx);
   });
 
+program
+  .command('watch')
+  .description('Watch for submitted tasks and auto-execute via Claude CLI')
+  .option('--project <id>', 'Watch a specific project (default: all)')
+  .option('--interval <seconds>', 'Polling interval in seconds', '10')
+  .option('--timeout <minutes>', 'Per-task timeout in minutes', '10')
+  .option('--dry-run', 'Show what would be executed without running')
+  .action(async (opts) => {
+    const { startWatcher } = await import('@/lib/watcher');
+    await startWatcher({
+      projectId: opts.project,
+      intervalMs: parseInt(opts.interval) * 1000,
+      timeoutMs: parseInt(opts.timeout) * 60000,
+      dryRun: !!opts.dryRun,
+    });
+  });
+
 program
   .command('start')
   .description('Start the web UI (Next.js dev server on port 3456)')

package/src/components/brainstorm/Editor.tsx

@@ -1,39 +1,18 @@
 'use client';
 
 import { useState, useEffect, useRef, useCallback } from 'react';
-import MemoPin from './MemoPin';
-
-interface Memo {
-  id: string;
-  anchor_text: string;
-  question: string;
-  is_resolved: boolean;
-}
 
 interface EditorProps {
   projectId: string;
-  onContentChange: (content: string) => void;
-  onSendMessage: (message: string) => void;
-  memos?: Memo[];
-  chatLoading?: boolean;
   onCollapse?: () => void;
 }
 
-interface PinPosition {
-  memo: Memo;
-  top: number;
-  left: number;
-}
-
-export default function Editor({ projectId, onContentChange, onSendMessage, memos = [], chatLoading, onCollapse }: EditorProps) {
+export default function Editor({ projectId, onCollapse }: EditorProps) {
   const [content, setContent] = useState('');
   const [saving, setSaving] = useState(false);
   const [loaded, setLoaded] = useState(false);
-  const [pinPositions, setPinPositions] = useState<PinPosition[]>([]);
   const saveTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
-  const structureTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const textareaRef = useRef<HTMLTextAreaElement>(null);
-  const overlayRef = useRef<HTMLDivElement>(null);
 
   // Load brainstorm content
   useEffect(() => {
@@ -46,37 +25,6 @@ export default function Editor({ projectId, onContentChange, onSendMessage, memo
     load();
   }, [projectId]);
 
-  // Calculate pin positions when memos or content change
-  useEffect(() => {
-    if (!textareaRef.current || !content) {
-      setPinPositions([]);
-      return;
-    }
-
-    const textarea = textareaRef.current;
-    const unresolvedMemos = memos.filter(m => !m.is_resolved);
-    const positions: PinPosition[] = [];
-
-    for (const memo of unresolvedMemos) {
-      const idx = content.indexOf(memo.anchor_text);
-      if (idx === -1) continue;
-
-      // Calculate approximate position based on character index
-      const textBefore = content.substring(0, idx);
-      const lines = textBefore.split('\n');
-      const lineNumber = lines.length - 1;
-      const lineHeight = parseFloat(getComputedStyle(textarea).lineHeight) || 22;
-      const paddingTop = parseFloat(getComputedStyle(textarea).paddingTop) || 16;
-
-      const top = paddingTop + lineNumber * lineHeight;
-      const left = textarea.clientWidth - 28;
-
-      positions.push({ memo, top, left });
-    }
-
-    setPinPositions(positions);
-  }, [memos, content]);
-
   const saveContent = useCallback(async (text: string) => {
     setSaving(true);
     await fetch(`/api/projects/${projectId}/brainstorm`, {
@@ -96,21 +44,6 @@ export default function Editor({ projectId, onContentChange, onSendMessage, memo
     saveTimerRef.current = setTimeout(() => {
       saveContent(newContent);
     }, 1000);
-
-    // Trigger AI structuring with 3s debounce
-    if (structureTimerRef.current) clearTimeout(structureTimerRef.current);
-    if (newContent.trim()) {
-      structureTimerRef.current = setTimeout(() => {
-        onContentChange(newContent);
-      }, 3000);
-    }
-  };
-
-  // Sync scroll between textarea and overlay
-  const handleScroll = () => {
-    if (textareaRef.current && overlayRef.current) {
-      overlayRef.current.scrollTop = textareaRef.current.scrollTop;
-    }
   };
 
   if (!loaded) {
@@ -145,7 +78,6 @@ export default function Editor({ projectId, onContentChange, onSendMessage, memo
           ref={textareaRef}
           value={content}
           onChange={handleChange}
-          onScroll={handleScroll}
           placeholder={`자유롭게 아이디어를 적어보세요...
 
 예시:
@@ -158,21 +90,6 @@ export default function Editor({ projectId, onContentChange, onSendMessage, memo
                      placeholder:text-muted-foreground/40 font-mono text-sm leading-relaxed"
           spellCheck={false}
         />
-        {pinPositions.length > 0 && (
-          <div ref={overlayRef} className="memo-overlay">
-            {pinPositions.map((pin) => (
-              <MemoPin
-                key={pin.memo.id}
-                question={pin.memo.question}
-                anchorText={pin.memo.anchor_text}
-                top={pin.top}
-                left={pin.left}
-                loading={chatLoading}
-                onSendMessage={onSendMessage}
-              />
-            ))}
-          </div>
-        )}
       </div>
     </div>
   );

package/src/lib/ai/client.ts

@@ -1,14 +1,4 @@
 import { spawn } from 'node:child_process';
-import type { IStructureWithQuestions } from '@/types';
-
-export interface IStructuredItem {
-  title: string;
-  description: string;
-  item_type: 'feature' | 'task' | 'bug' | 'idea' | 'note';
-  priority: 'high' | 'medium' | 'low';
-  status?: 'pending' | 'in_progress' | 'done';
-  children?: IStructuredItem[];
-}
 
 const CLI_PATH = 'claude';
 const DEFAULT_ARGS = ['--dangerously-skip-permissions'];
@@ -18,11 +8,16 @@ const MAX_TURNS = 80;
 export type OnTextChunk = (text: string) => void;
 export type OnRawEvent = (event: Record<string, unknown>) => void;
 
+export interface RunClaudeOptions {
+  cwd?: string;
+  timeoutMs?: number;
+}
+
 /**
  * Spawn Claude Code CLI and collect the result text.
  * Optional onText callback receives streaming text chunks as they arrive.
  */
-export function runClaude(prompt: string, onText?: OnTextChunk, onRawEvent?: OnRawEvent): Promise<string> {
+export function runClaude(prompt: string, onText?: OnTextChunk, onRawEvent?: OnRawEvent, options?: RunClaudeOptions): Promise<string> {
   return new Promise((resolve, reject) => {
     const useStreamJson = !!(onText || onRawEvent);
     const args = [
@@ -45,11 +40,21 @@ export function runClaude(prompt: string, onText?: OnTextChunk, onRawEvent?: OnR
     }
 
     const proc = spawn(CLI_PATH, args, {
-      cwd: process.cwd(),
+      cwd: options?.cwd || process.cwd(),
       stdio: ['pipe', 'pipe', 'pipe'],
       env: { ...cleanEnv, FORCE_COLOR: '0' },
     });
 
+    // Timeout handling
+    let timeoutTimer: ReturnType<typeof setTimeout> | null = null;
+    let timedOut = false;
+    if (options?.timeoutMs) {
+      timeoutTimer = setTimeout(() => {
+        timedOut = true;
+        proc.kill('SIGTERM');
+      }, options.timeoutMs);
+    }
+
     // Write prompt to stdin and close it
     proc.stdin?.write(prompt);
     proc.stdin?.end();
@@ -109,10 +114,15 @@ export function runClaude(prompt: string, onText?: OnTextChunk, onRawEvent?: OnR
     });
 
     proc.on('exit', (code, signal) => {
+      if (timeoutTimer) clearTimeout(timeoutTimer);
       // Clean up known CLI noise from text output
       if (!useStreamJson) {
         resultText = resultText.replace(/Error: Reached max turns \(\d+\)\s*/g, '').trim();
       }
+      if (timedOut) {
+        reject(new Error(`Claude CLI timed out after ${Math.round((options?.timeoutMs || 0) / 1000)}s`));
+        return;
+      }
       if (code !== 0 && !resultText) {
         const detail = stderrText.slice(0, 500) || (signal ? `killed by signal ${signal}` : 'no output');
         reject(new Error(`Claude CLI exited with code ${code}: ${detail}`));
@@ -122,116 +132,3 @@ export function runClaude(prompt: string, onText?: OnTextChunk, onRawEvent?: OnR
     });
   });
 }
-
-/**
- * Run Claude for free-form markdown analysis (not JSON).
- * Used for building the hub document in multi-agent analysis.
- */
-export function runAnalysis(prompt: string, onText?: OnTextChunk, onRawEvent?: OnRawEvent): Promise<string> {
-  return runClaude(prompt, onText, onRawEvent);
-}
-
-export function extractJson(text: string, type: 'array' | 'object'): string {
-  // Strip markdown fences
-  text = text.replace(/```(?:json)?\s*/g, '').replace(/```\s*/g, '').trim();
-  const pattern = type === 'array' ? /\[[\s\S]*\]/ : /\{[\s\S]*\}/;
-  const match = text.match(pattern);
-  if (!match) {
-    throw new Error(`AI did not return valid JSON ${type}`);
-  }
-  return match[0];
-}
-
-export async function runStructure(brainstormContent: string, projectContext?: string, onText?: OnTextChunk, onRawEvent?: OnRawEvent): Promise<IStructuredItem[]> {
-  const systemPrompt = `You are a JSON-only structuring machine. You NEVER respond with text, explanations, or conversation.
-You ALWAYS output ONLY a raw JSON array, nothing else.
-
-Your job: convert ANY input text into a structured JSON array of items.
-Even if the input seems like a greeting or conversation, extract the implicit intent and structure it.
-
-Schema per item:
-{ "title": string, "description": string, "item_type": "feature"|"task"|"bug"|"idea"|"note", "priority": "high"|"medium"|"low", "status": "pending"|"in_progress"|"done", "children": [same schema] }
-
-Rules:
-- Output MUST start with [ and end with ]
-- No markdown fences, no explanation, no text before or after the JSON
-- Keep titles concise (under 50 chars)
-- Group related ideas under parent items
-- If input is vague, interpret it as best you can and create at least 1 item
-- IMPORTANT: When project source code context is provided, judge the status based on the actual code:
-  - "done": feature/task is fully implemented in the source code
-  - "in_progress": partially implemented or has TODOs
-  - "pending": not yet started or only planned
-- If no source code context is provided, default status to "pending"`;
-
-  const ctxBlock = projectContext ? `\n\n프로젝트 문서 컨텍스트:\n${projectContext}` : '';
-  const prompt = `${systemPrompt}\n\nAnalyze this brainstorming content and structure it into a JSON tree:\n\n${brainstormContent}${ctxBlock}`;
-
-  const resultText = await runClaude(prompt, onText, onRawEvent);
-  const json = extractJson(resultText, 'array');
-  return JSON.parse(json) as IStructuredItem[];
-}
-
-export async function runStructureWithQuestions(
-  brainstormContent: string,
-  conversationHistory: { role: 'assistant' | 'user'; content: string }[],
-  projectContext?: string,
-  onText?: OnTextChunk,
-  onRawEvent?: OnRawEvent,
-  existingStructure?: string,
-): Promise<IStructureWithQuestions> {
-  const systemPrompt = `You are an AI assistant that structures brainstorming content AND identifies ambiguous areas.
-You ALWAYS output ONLY a raw JSON object (not an array), nothing else.
-
-Your job:
-1. Convert the brainstorming text into a structured JSON tree of items
-2. Identify 0-5 areas where the brainstorming is ambiguous or could benefit from clarification
-3. Consider the conversation history to avoid repeating questions already answered
-4. If existing structured items are provided, UPDATE them rather than creating duplicates
-
-Output schema:
-{
-  "items": [{ "title": string, "description": string, "item_type": "feature"|"task"|"bug"|"idea"|"note", "priority": "high"|"medium"|"low", "status": "pending"|"in_progress"|"done", "children": [same] }],
-  "questions": [{ "anchor_text": string, "question": string }]
-}
-
-Rules:
-- Output MUST be a JSON object with "items" and "questions" keys
-- No markdown fences, no explanation, no text before or after the JSON
-- Keep titles concise (under 50 chars)
-- Group related ideas under parent items
-- NEVER create duplicate items. If the existing structure already has an item for a concept, update it instead of adding a new one
-- Merge similar items together. The output should be a clean, deduplicated structure
-- Preserve the status of existing items unless the brainstorming text explicitly changes them
-- questions[].anchor_text MUST be an exact substring from the brainstorming content (5-20 chars)
-- questions[].question should be a helpful Korean question asking for clarification
-- Generate 0-5 questions. Skip questions already answered in conversation history.
-- If the brainstorming is clear enough, return an empty questions array
-- All questions MUST be in Korean
-- If project documentation context is provided, use it to make more informed structuring decisions (e.g., matching tech stack, conventions, existing patterns)
-- IMPORTANT: When project source code context is provided, judge the status based on the actual code:
-  - "done": feature/task is fully implemented in the source code
-  - "in_progress": partially implemented or has TODOs
-  - "pending": not yet started or only planned
-- If no source code context is provided, default status to "pending"`;
-
-  let historyContext = '';
-  if (conversationHistory.length > 0) {
-    historyContext = '\n\n이전 대화:\n' + conversationHistory
-      .map(m => `${m.role === 'user' ? '사용자' : 'AI'}: ${m.content}`)
-      .join('\n');
-  }
-
-  const ctxBlock = projectContext ? `\n\n프로젝트 문서 컨텍스트:\n${projectContext}` : '';
-  const existingBlock = existingStructure ? `\n\n현재 구조화된 항목 (중복 생성하지 말고 업데이트하세요):\n${existingStructure}` : '';
-  const prompt = `${systemPrompt}\n\n다음 브레인스토밍 내용을 분석하고 구조화하세요:\n\n${brainstormContent}${historyContext}${existingBlock}${ctxBlock}`;
-
-  const resultText = await runClaude(prompt, onText, onRawEvent);
-  const json = extractJson(resultText, 'object');
-  const parsed = JSON.parse(json);
-
-  return {
-    items: parsed.items || [],
-    questions: parsed.questions || [],
-  } as IStructureWithQuestions;
-}

package/src/lib/db/schema.ts

@@ -21,78 +21,8 @@ export function initSchema(db: Database.Database): void {
       FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
     );
 
-    CREATE TABLE IF NOT EXISTS items (
-      id TEXT PRIMARY KEY,
-      project_id TEXT NOT NULL,
-      brainstorm_id TEXT,
-      parent_id TEXT,
-      title TEXT NOT NULL,
-      description TEXT NOT NULL DEFAULT '',
-      item_type TEXT NOT NULL DEFAULT 'feature',
-      priority TEXT NOT NULL DEFAULT 'medium',
-      status TEXT NOT NULL DEFAULT 'pending',
-      is_locked INTEGER NOT NULL DEFAULT 1,
-      is_pinned INTEGER NOT NULL DEFAULT 1,
-      sort_order INTEGER NOT NULL DEFAULT 0,
-      metadata TEXT,
-      created_at TEXT NOT NULL DEFAULT (datetime('now')),
-      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
-      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
-      FOREIGN KEY (brainstorm_id) REFERENCES brainstorms(id),
-      FOREIGN KEY (parent_id) REFERENCES items(id)
-    );
-
-    CREATE TABLE IF NOT EXISTS conversations (
-      id TEXT PRIMARY KEY,
-      project_id TEXT NOT NULL,
-      role TEXT NOT NULL CHECK(role IN ('assistant', 'user')),
-      content TEXT NOT NULL,
-      metadata TEXT,
-      created_at TEXT NOT NULL DEFAULT (datetime('now')),
-      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
-    );
-
-    CREATE TABLE IF NOT EXISTS memos (
-      id TEXT PRIMARY KEY,
-      project_id TEXT NOT NULL,
-      conversation_id TEXT,
-      anchor_text TEXT NOT NULL,
-      question TEXT NOT NULL,
-      is_resolved INTEGER NOT NULL DEFAULT 0,
-      created_at TEXT NOT NULL DEFAULT (datetime('now')),
-      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
-      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
-      FOREIGN KEY (conversation_id) REFERENCES conversations(id) ON DELETE SET NULL
-    );
-
-    CREATE TABLE IF NOT EXISTS prompts (
-      id TEXT PRIMARY KEY,
-      project_id TEXT NOT NULL,
-      item_id TEXT NOT NULL,
-      content TEXT NOT NULL,
-      prompt_type TEXT NOT NULL DEFAULT 'auto',
-      version INTEGER NOT NULL DEFAULT 1,
-      created_at TEXT NOT NULL DEFAULT (datetime('now')),
-      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
-      FOREIGN KEY (item_id) REFERENCES items(id) ON DELETE CASCADE
-    );
-
-    CREATE TABLE IF NOT EXISTS project_context (
-      id TEXT PRIMARY KEY,
-      project_id TEXT NOT NULL,
-      file_path TEXT NOT NULL,
-      content TEXT NOT NULL,
-      scanned_at TEXT NOT NULL DEFAULT (datetime('now')),
-      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
-    );
   `);
 
-  // Migrations for existing DBs
-  const itemCols = db.prepare("PRAGMA table_info(items)").all() as { name: string }[];
-  if (!itemCols.some(c => c.name === 'is_pinned')) {
-    db.exec("ALTER TABLE items ADD COLUMN is_pinned INTEGER NOT NULL DEFAULT 1");
-  }
-
   const projCols = db.prepare("PRAGMA table_info(projects)").all() as { name: string }[];
   if (!projCols.some(c => c.name === 'project_path')) {
     db.exec("ALTER TABLE projects ADD COLUMN project_path TEXT");

package/src/lib/watcher.ts

@@ -0,0 +1,190 @@
+import fs from 'fs';
+import { runClaude } from './ai/client';
+import { listProjects, getProject } from './db/queries/projects';
+import { getSubProject } from './db/queries/sub-projects';
+import { getTasksByProject, getTask, updateTask } from './db/queries/tasks';
+import { getTaskPrompt } from './db/queries/task-prompts';
+import { addTaskConversation } from './db/queries/task-conversations';
+import type { ITask, IProject } from '@/types';
+
+export interface WatcherOptions {
+  projectId?: string;
+  intervalMs: number;
+  timeoutMs: number;
+  dryRun: boolean;
+}
+
+function timestamp(): string {
+  return new Date().toLocaleTimeString('ko-KR', { hour12: false });
+}
+
+function log(msg: string) {
+  console.log(`[IM Watch] ${msg}`);
+}
+
+function logTask(msg: string) {
+  console.log(`  ${msg}`);
+}
+
+function formatDuration(ms: number): string {
+  const s = Math.floor(ms / 1000);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  const rem = s % 60;
+  return `${m}m ${rem}s`;
+}
+
+function resolveCwd(task: ITask, project: IProject): string | null {
+  // 1. sub_project.folder_path
+  const subProject = getSubProject(task.sub_project_id);
+  if (subProject?.folder_path && fs.existsSync(subProject.folder_path)) {
+    return subProject.folder_path;
+  }
+  // 2. project.project_path
+  if (project.project_path && fs.existsSync(project.project_path)) {
+    return project.project_path;
+  }
+  return null;
+}
+
+async function executeTask(task: ITask, project: IProject, options: WatcherOptions): Promise<void> {
+  const cwd = resolveCwd(task, project);
+  if (!cwd) {
+    logTask(`⚠ Skip "${task.title}" — no folder_path or project_path set`);
+    return;
+  }
+
+  const prompt = getTaskPrompt(task.id);
+  if (!prompt?.content?.trim()) {
+    logTask(`⚠ Skip "${task.title}" — no prompt content`);
+    return;
+  }
+
+  // Re-check status (another watcher might have grabbed it)
+  const fresh = getTask(task.id);
+  if (!fresh || fresh.status !== 'submitted') {
+    logTask(`⚠ Skip "${task.title}" — status already changed`);
+    return;
+  }
+
+  const subProject = getSubProject(task.sub_project_id);
+  const subName = subProject?.name || 'unknown';
+
+  console.log(`[${timestamp()}] ▶ "${task.title}" (sub: ${subName}, cwd: ${cwd})`);
+
+  if (options.dryRun) {
+    logTask(`[DRY RUN] Would execute prompt (${prompt.content.length} chars)`);
+    return;
+  }
+
+  // Transition: submitted → testing
+  updateTask(task.id, { status: 'testing' });
+  logTask(`submitted → testing`);
+  addTaskConversation(task.id, 'user', `[watch] Execution started`);
+
+  const startTime = Date.now();
+
+  // Build prompt with AI policy context
+  let fullPrompt = prompt.content;
+  if (project.ai_context) {
+    fullPrompt = `Project AI Policy:\n${project.ai_context}\n\n---\n\n${fullPrompt}`;
+  }
+
+  try {
+    const result = await runClaude(fullPrompt, undefined, undefined, {
+      cwd,
+      timeoutMs: options.timeoutMs,
+    });
+
+    const duration = Date.now() - startTime;
+    updateTask(task.id, { status: 'done' });
+    addTaskConversation(task.id, 'assistant', result || '(no output)');
+    console.log(`[${timestamp()}]   ✓ Done (${formatDuration(duration)})`);
+  } catch (err) {
+    const duration = Date.now() - startTime;
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    updateTask(task.id, { status: 'problem' });
+    addTaskConversation(task.id, 'assistant', `[error] ${errorMsg}`);
+    console.log(`[${timestamp()}]   ✗ Failed (${formatDuration(duration)}): ${errorMsg}`);
+  }
+}
+
+export async function startWatcher(options: WatcherOptions): Promise<void> {
+  // Validate project if specified
+  if (options.projectId) {
+    const project = getProject(options.projectId);
+    if (!project) {
+      console.error(`Error: Project "${options.projectId}" not found.`);
+      process.exit(1);
+    }
+    log(`Watching project: "${project.name}" (${project.id})`);
+  } else {
+    const projects = listProjects();
+    log(`Watching all projects (${projects.length})`);
+  }
+
+  log(`Polling every ${options.intervalMs / 1000}s | Timeout: ${options.timeoutMs / 60000}m${options.dryRun ? ' | DRY RUN' : ''}`);
+  log('─'.repeat(50));
+  log('Press Ctrl+C to stop\n');
+
+  let isProcessing = false;
+  let shuttingDown = false;
+
+  const poll = async () => {
+    if (isProcessing || shuttingDown) return;
+    isProcessing = true;
+
+    try {
+      // Collect submitted tasks
+      const projectIds = options.projectId
+        ? [options.projectId]
+        : listProjects().map(p => p.id);
+
+      const submittedTasks: { task: ITask; project: IProject }[] = [];
+
+      for (const pid of projectIds) {
+        const project = getProject(pid);
+        if (!project) continue;
+        const tasks = getTasksByProject(pid).filter(t => t.status === 'submitted');
+        for (const task of tasks) {
+          submittedTasks.push({ task, project });
+        }
+      }
+
+      if (submittedTasks.length > 0) {
+        console.log(`[${timestamp()}] Found ${submittedTasks.length} submitted task(s)`);
+        for (const { task, project } of submittedTasks) {
+          if (shuttingDown) break;
+          await executeTask(task, project, options);
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`[${timestamp()}] Poll error: ${msg}`);
+    } finally {
+      isProcessing = false;
+    }
+  };
+
+  // Graceful shutdown
+  const shutdown = () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    console.log(`\n[IM Watch] Shutting down...${isProcessing ? ' (waiting for current task)' : ''}`);
+    if (!isProcessing) process.exit(0);
+    // If processing, the poll loop will exit after the current task
+    const checkDone = setInterval(() => {
+      if (!isProcessing) {
+        clearInterval(checkDone);
+        process.exit(0);
+      }
+    }, 500);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  // Initial poll + recurring
+  await poll();
+  setInterval(poll, options.intervalMs);
+}