commandmate 0.3.1 → 0.3.3

package/dist/server/src/lib/db.js

@@ -32,6 +32,8 @@ exports.markPendingPromptsAsAnswered = markPendingPromptsAsAnswered;
 exports.updateFavorite = updateFavorite;
 exports.updateStatus = updateStatus;
 exports.updateCliToolId = updateCliToolId;
+exports.updateSelectedAgents = updateSelectedAgents;
+exports.updateVibeLocalModel = updateVibeLocalModel;
 exports.getMemosByWorktreeId = getMemosByWorktreeId;
 exports.getMemoById = getMemoById;
 exports.createMemo = createMemo;
@@ -44,6 +46,7 @@ exports.getWorktreeIdsByRepository = getWorktreeIdsByRepository;
 exports.deleteRepositoryWorktrees = deleteRepositoryWorktrees;
 exports.deleteWorktreesByIds = deleteWorktreesByIds;
 const crypto_1 = require("crypto");
+const selected_agents_validator_1 = require("../lib/selected-agents-validator");
 function mapChatMessage(row) {
     return {
         id: row.id,
@@ -129,6 +132,16 @@ function initDatabase(db) {
  * Get latest user message per CLI tool for multiple worktrees (batch query)
  * Optimized to avoid N+1 query problem
  */
+/**
+ * Get latest user message per CLI tool for multiple worktrees (batch query)
+ * Optimized to avoid N+1 query problem
+ *
+ * R4-001: SQL IN clause for cli_tool_id removed to eliminate SQLインジェクション risk.
+ * All cli_tool_id values are fetched; filtering happens at application layer.
+ * Tool count is at most 4-5, so the performance impact is negligible.
+ *
+ * R2-002: Return type changed to Partial<Record<CLIToolType, string>>
+ */
 function getLastMessagesByCliBatch(db, worktreeIds) {
     if (worktreeIds.length === 0) {
         return new Map();
@@ -149,7 +162,6 @@ function getLastMessagesByCliBatch(db, worktreeIds) {
       FROM chat_messages
       WHERE worktree_id IN (${placeholders})
         AND role = 'user'
-        AND cli_tool_id IN ('claude', 'codex', 'gemini')
     )
     SELECT worktree_id, cli_tool_id, content
     FROM ranked_messages
@@ -181,6 +193,7 @@ function getWorktrees(db, repositoryPath) {
       w.id, w.name, w.path, w.repository_path, w.repository_name, w.description,
       w.last_user_message, w.last_user_message_at, w.last_message_summary,
       w.updated_at, w.favorite, w.status, w.link, w.cli_tool_id, w.last_viewed_at,
+      w.selected_agents, w.vibe_local_model,
       (SELECT MAX(timestamp) FROM chat_messages
        WHERE worktree_id = w.id AND role = 'assistant') as last_assistant_message_at
     FROM worktrees w
@@ -216,6 +229,8 @@ function getWorktrees(db, repositoryPath) {
             status: row.status || null,
             link: row.link || undefined,
             cliToolId: row.cli_tool_id ?? 'claude',
+            selectedAgents: (0, selected_agents_validator_1.parseSelectedAgents)(row.selected_agents),
+            vibeLocalModel: row.vibe_local_model ?? null,
         };
     });
 }
@@ -250,6 +265,7 @@ function getWorktreeById(db, id) {
       w.id, w.name, w.path, w.repository_path, w.repository_name, w.description,
       w.last_user_message, w.last_user_message_at, w.last_message_summary,
       w.updated_at, w.favorite, w.status, w.link, w.cli_tool_id, w.last_viewed_at,
+      w.selected_agents, w.vibe_local_model,
       (SELECT MAX(timestamp) FROM chat_messages
        WHERE worktree_id = w.id AND role = 'assistant') as last_assistant_message_at
     FROM worktrees w
@@ -276,6 +292,8 @@ function getWorktreeById(db, id) {
         status: row.status || null,
         link: row.link || undefined,
         cliToolId: row.cli_tool_id ?? 'claude',
+        selectedAgents: (0, selected_agents_validator_1.parseSelectedAgents)(row.selected_agents),
+        vibeLocalModel: row.vibe_local_model ?? null,
     };
 }
 /**
@@ -678,6 +696,38 @@ function updateCliToolId(db, id, cliToolId) {
   `);
     stmt.run(cliToolId, id);
 }
+/**
+ * Update selected_agents for a worktree
+ * Issue #368: Persists the user's choice of 2 display agents
+ *
+ * @param db - Database instance
+ * @param id - Worktree ID
+ * @param selectedAgents - Tuple of 2 CLIToolType values
+ */
+function updateSelectedAgents(db, id, selectedAgents) {
+    const stmt = db.prepare(`
+    UPDATE worktrees
+    SET selected_agents = ?
+    WHERE id = ?
+  `);
+    stmt.run(JSON.stringify(selectedAgents), id);
+}
+/**
+ * Update vibe_local_model for a worktree
+ * Issue #368: Persists the user's Ollama model selection for vibe-local
+ *
+ * @param db - Database instance
+ * @param id - Worktree ID
+ * @param model - Model name or null for default
+ */
+function updateVibeLocalModel(db, id, model) {
+    const stmt = db.prepare(`
+    UPDATE worktrees
+    SET vibe_local_model = ?
+    WHERE id = ?
+  `);
+    stmt.run(model, id);
+}
 /**
  * Map database row to WorktreeMemo model
  */

package/dist/server/src/lib/env-sanitizer.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Environment Variable Sanitizer
+ * Issue #294: Sanitizes environment variables for child processes
+ *
+ * Removes sensitive environment variables (auth tokens, certificates, database paths)
+ * before spawning child processes like `claude -p`.
+ *
+ * [S1-001/S4-001] Centralized sensitive key management
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SENSITIVE_ENV_KEYS = void 0;
+exports.sanitizeEnvForChildProcess = sanitizeEnvForChildProcess;
+/**
+ * List of environment variable keys that must be removed before
+ * passing environment to child processes.
+ *
+ * These include authentication tokens, TLS certificates, IP restriction
+ * settings, and database paths that should not be inherited by spawned
+ * CLI tool processes.
+ */
+exports.SENSITIVE_ENV_KEYS = [
+    'CLAUDECODE',
+    'CM_AUTH_TOKEN_HASH',
+    'CM_AUTH_EXPIRE',
+    'CM_HTTPS_KEY',
+    'CM_HTTPS_CERT',
+    'CM_ALLOWED_IPS',
+    'CM_TRUST_PROXY',
+    'CM_DB_PATH',
+];
+/**
+ * Create a sanitized copy of process.env suitable for child processes.
+ *
+ * Removes all keys listed in SENSITIVE_ENV_KEYS from the environment.
+ * Non-sensitive variables (PATH, HOME, NODE_ENV, etc.) are preserved.
+ *
+ * @returns A shallow copy of process.env with sensitive keys removed
+ *
+ * @example
+ * ```typescript
+ * import { execFile } from 'child_process';
+ * import { sanitizeEnvForChildProcess } from './env-sanitizer';
+ *
+ * execFile('claude', ['-p', message], {
+ *   env: sanitizeEnvForChildProcess(),
+ *   cwd: worktreePath,
+ * });
+ * ```
+ */
+function sanitizeEnvForChildProcess() {
+    const env = { ...process.env };
+    for (const key of exports.SENSITIVE_ENV_KEYS) {
+        delete env[key];
+    }
+    return env;
+}

package/dist/server/src/lib/prompt-detector.js

@@ -166,11 +166,12 @@ const TEXT_INPUT_PATTERNS = [
     /differently/i,
 ];
 /**
- * Pattern for ❯ (U+276F) indicator lines used by Claude CLI to mark the default selection.
+ * Pattern for ❯ (U+276F) / ● (U+25CF) indicator lines used by CLI tools to mark the default selection.
+ * Claude CLI uses ❯, Gemini CLI uses ●.
  * Used in Pass 1 (existence check) and Pass 2 (option collection) of the 2-pass detection.
  * Anchored at both ends -- ReDoS safe (S4-001).
  */
-const DEFAULT_OPTION_PATTERN = /^\s*\u276F\s*(\d+)\.\s*(.+)$/;
+const DEFAULT_OPTION_PATTERN = /^\s*[\u276F\u25CF]\s*(\d+)\.\s*(.+)$/;
 /**
  * Pattern for normal option lines (no ❯ indicator, just leading whitespace + number).
  * Only applied in Pass 2 when ❯ indicator existence is confirmed by Pass 1.
@@ -567,7 +568,7 @@ function detectMultipleChoicePrompt(output, options) {
         // user input prompt (e.g., "❯ 1", "❯ /command") or idle prompt ("❯").
         // Anything above this line in the scrollback is historical conversation text,
         // not an active prompt. Stop scanning to prevent false positives.
-        if (collectedOptions.length === 0 && line.startsWith('\u276F')) {
+        if (collectedOptions.length === 0 && (line.startsWith('\u276F') || line.startsWith('\u25CF'))) {
             return noPromptResult(output);
         }
         // Non-option line handling

package/dist/server/src/lib/response-poller.js

@@ -131,7 +131,7 @@ function getPollerKey(worktreeId, cliToolId) {
  */
 function detectPromptWithOptions(output, cliToolId) {
     const promptOptions = (0, cli_patterns_1.buildDetectPromptOptions)(cliToolId);
-    return (0, prompt_detector_1.detectPrompt)((0, cli_patterns_1.stripAnsi)(output), promptOptions);
+    return (0, prompt_detector_1.detectPrompt)((0, cli_patterns_1.stripBoxDrawing)((0, cli_patterns_1.stripAnsi)(output)), promptOptions);
 }
 /**
  * Clean up Claude response by removing shell setup commands, environment exports, ANSI codes, and banner
@@ -372,11 +372,12 @@ function extractResponse(output, lastCapturedLine, cliToolId) {
     const hasPrompt = promptPattern.test(cleanOutputToCheck);
     const hasSeparator = separatorPattern.test(cleanOutputToCheck);
     const isThinking = thinkingPattern.test(cleanOutputToCheck);
-    // Codex/Gemini completion logic: prompt detected and not thinking (separator optional)
+    // Codex/Gemini/Vibe-Local completion logic: prompt detected and not thinking (separator optional)
     // - Codex: Interactive TUI, detects › prompt
-    // - Gemini: Non-interactive one-shot, detects shell prompt (%, $)
+    // - Gemini: Interactive REPL, detects > / ❯ prompt
+    // - Vibe-Local: Interactive REPL, detects > prompt
     // Claude: require both prompt and separator
-    const isCodexOrGeminiComplete = (cliToolId === 'codex' || cliToolId === 'gemini') && hasPrompt && !isThinking;
+    const isCodexOrGeminiComplete = (cliToolId === 'codex' || cliToolId === 'gemini' || cliToolId === 'vibe-local') && hasPrompt && !isThinking;
     const isClaudeComplete = cliToolId === 'claude' && hasPrompt && hasSeparator && !isThinking;
     if (isCodexOrGeminiComplete || isClaudeComplete) {
         // CLI tool has completed response
@@ -667,10 +668,15 @@ function startPolling(worktreeId, cliToolId) {
     stopPolling(worktreeId, cliToolId);
     // Record start time
     pollingStartTimes.set(pollerKey, Date.now());
-    // Start polling
-    const interval = setInterval(async () => {
-        const startTime = pollingStartTimes.get(pollerKey);
+    // Start polling with setTimeout chain to prevent race conditions
+    scheduleNextResponsePoll(worktreeId, cliToolId);
+}
+/** Schedule next checkForResponse() after current one completes (setTimeout chain) */
+function scheduleNextResponsePoll(worktreeId, cliToolId) {
+    const pollerKey = getPollerKey(worktreeId, cliToolId);
+    const timerId = setTimeout(async () => {
         // Check if max duration exceeded
+        const startTime = pollingStartTimes.get(pollerKey);
         if (startTime && Date.now() - startTime > MAX_POLLING_DURATION) {
             stopPolling(worktreeId, cliToolId);
             return;
@@ -682,8 +688,13 @@ function startPolling(worktreeId, cliToolId) {
         catch (error) {
             console.error(`[Poller] Error:`, error);
         }
+        // Schedule next poll ONLY after current one completes
+        // Guard: only if poller is still active (not stopped during checkForResponse)
+        if (activePollers.has(pollerKey)) {
+            scheduleNextResponsePoll(worktreeId, cliToolId);
+        }
     }, POLLING_INTERVAL);
-    activePollers.set(pollerKey, interval);
+    activePollers.set(pollerKey, timerId);
 }
 /**
  * Stop polling for a worktree and CLI tool combination
@@ -698,9 +709,9 @@ function startPolling(worktreeId, cliToolId) {
  */
 function stopPolling(worktreeId, cliToolId) {
     const pollerKey = getPollerKey(worktreeId, cliToolId);
-    const interval = activePollers.get(pollerKey);
-    if (interval) {
-        clearInterval(interval);
+    const timerId = activePollers.get(pollerKey);
+    if (timerId) {
+        clearTimeout(timerId);
         activePollers.delete(pollerKey);
         pollingStartTimes.delete(pollerKey);
     }

package/dist/server/src/lib/schedule-manager.js

@@ -0,0 +1,401 @@
+"use strict";
+/**
+ * Schedule Manager
+ * Issue #294: Manages scheduled execution of claude -p commands
+ *
+ * Uses a single timer to periodically scan all worktrees for CMATE.md changes
+ * and execute scheduled tasks via croner cron expressions.
+ *
+ * Patterns:
+ * - globalThis for hot reload persistence (same as auto-yes-manager.ts)
+ * - Single timer for all worktrees (60 second polling interval)
+ * - SIGKILL fire-and-forget for stopAllSchedules (< 1ms, within 3s graceful shutdown)
+ *
+ * [S3-001] stopAllSchedules() uses synchronous process.kill for immediate cleanup
+ * [S3-010] initScheduleManager() is called after initializeWorktrees()
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_CONCURRENT_SCHEDULES = exports.POLL_INTERVAL_MS = void 0;
+exports.initScheduleManager = initScheduleManager;
+exports.stopAllSchedules = stopAllSchedules;
+exports.getActiveScheduleCount = getActiveScheduleCount;
+exports.isScheduleManagerInitialized = isScheduleManagerInitialized;
+const crypto_1 = require("crypto");
+const croner_1 = require("croner");
+const cmate_parser_1 = require("./cmate-parser");
+const claude_executor_1 = require("./claude-executor");
+// =============================================================================
+// Constants
+// =============================================================================
+/** Polling interval for CMATE.md changes (60 seconds) */
+exports.POLL_INTERVAL_MS = 60 * 1000;
+/** Maximum number of concurrent schedules across all worktrees */
+exports.MAX_CONCURRENT_SCHEDULES = 100;
+/**
+ * Get or initialize the global manager state.
+ */
+function getManagerState() {
+    if (!globalThis.__scheduleManagerStates) {
+        globalThis.__scheduleManagerStates = {
+            timerId: null,
+            schedules: new Map(),
+            initialized: false,
+        };
+    }
+    return globalThis.__scheduleManagerStates;
+}
+// =============================================================================
+// Lazy DB Accessor
+// =============================================================================
+/**
+ * Lazy-load the DB instance to avoid circular import issues.
+ * The db-instance module is loaded at runtime via require() because
+ * schedule-manager.ts is imported early in the server lifecycle.
+ *
+ * @returns The SQLite database instance
+ */
+function getLazyDbInstance() {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { getDbInstance } = require('./db-instance');
+    return getDbInstance();
+}
+// =============================================================================
+// DB Operations
+// =============================================================================
+/**
+ * Get all worktrees from the database.
+ *
+ * @returns Array of worktree rows with id and path
+ */
+function getAllWorktrees() {
+    try {
+        const db = getLazyDbInstance();
+        return db.prepare('SELECT id, path FROM worktrees').all();
+    }
+    catch (error) {
+        console.error('[schedule-manager] Failed to get worktrees:', error);
+        return [];
+    }
+}
+/**
+ * Upsert a schedule entry into the database.
+ * If a schedule with the same worktree_id and name exists, it is updated.
+ * Otherwise, a new schedule is created.
+ *
+ * @param worktreeId - The worktree ID to associate the schedule with
+ * @param entry - The schedule entry from CMATE.md
+ * @returns The schedule ID (existing or newly created)
+ */
+function upsertSchedule(worktreeId, entry) {
+    const db = getLazyDbInstance();
+    const now = Date.now();
+    // Check if schedule already exists
+    const existing = db.prepare('SELECT id FROM scheduled_executions WHERE worktree_id = ? AND name = ?').get(worktreeId, entry.name);
+    if (existing) {
+        db.prepare(`
+      UPDATE scheduled_executions
+      SET message = ?, cron_expression = ?, cli_tool_id = ?, enabled = ?, updated_at = ?
+      WHERE id = ?
+    `).run(entry.message, entry.cronExpression, entry.cliToolId, entry.enabled ? 1 : 0, now, existing.id);
+        return existing.id;
+    }
+    const id = (0, crypto_1.randomUUID)();
+    db.prepare(`
+    INSERT INTO scheduled_executions (id, worktree_id, name, message, cron_expression, cli_tool_id, enabled, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, worktreeId, entry.name, entry.message, entry.cronExpression, entry.cliToolId, entry.enabled ? 1 : 0, now, now);
+    return id;
+}
+/**
+ * Create an execution log entry in 'running' status.
+ *
+ * @param scheduleId - The parent schedule ID
+ * @param worktreeId - The worktree ID
+ * @param message - The execution message/prompt
+ * @returns The new execution log ID
+ */
+function createExecutionLog(scheduleId, worktreeId, message) {
+    const db = getLazyDbInstance();
+    const now = Date.now();
+    const id = (0, crypto_1.randomUUID)();
+    db.prepare(`
+    INSERT INTO execution_logs (id, schedule_id, worktree_id, message, status, started_at, created_at)
+    VALUES (?, ?, ?, ?, 'running', ?, ?)
+  `).run(id, scheduleId, worktreeId, message, now, now);
+    return id;
+}
+/**
+ * Update an execution log entry with results.
+ *
+ * @param logId - The execution log ID to update
+ * @param status - The final execution status
+ * @param result - The execution output or error message
+ * @param exitCode - The process exit code, or null if unknown
+ */
+function updateExecutionLog(logId, status, result, exitCode) {
+    const db = getLazyDbInstance();
+    const now = Date.now();
+    db.prepare(`
+    UPDATE execution_logs SET status = ?, result = ?, exit_code = ?, completed_at = ? WHERE id = ?
+  `).run(status, result, exitCode, now, logId);
+}
+/**
+ * Update the last_executed_at timestamp for a schedule.
+ *
+ * @param scheduleId - The schedule ID to update
+ */
+function updateScheduleLastExecuted(scheduleId) {
+    const db = getLazyDbInstance();
+    const now = Date.now();
+    db.prepare('UPDATE scheduled_executions SET last_executed_at = ?, updated_at = ? WHERE id = ?')
+        .run(now, now, scheduleId);
+}
+/**
+ * Recovery: mark all 'running' execution logs as 'failed' on startup.
+ * This handles the case where the server was killed while executions
+ * were still in progress.
+ */
+function recoverRunningLogs() {
+    try {
+        const db = getLazyDbInstance();
+        const now = Date.now();
+        const result = db.prepare("UPDATE execution_logs SET status = 'failed', completed_at = ? WHERE status = 'running'").run(now);
+        if (result.changes > 0) {
+            console.warn(`[schedule-manager] Recovered ${result.changes} stale running execution(s) to failed status`);
+        }
+    }
+    catch (error) {
+        console.error('[schedule-manager] Failed to recover running logs:', error);
+    }
+}
+/**
+ * Disable DB schedules that are no longer present in CMATE.md.
+ * Sets enabled = 0 for schedules belonging to the given worktrees
+ * that are not in the activeScheduleIds set.
+ * Skips records already disabled to avoid unnecessary DB writes.
+ *
+ * @param activeScheduleIds - Set of schedule IDs currently active from CMATE.md
+ * @param worktreeIds - Array of worktree IDs that were scanned
+ */
+function disableStaleSchedules(activeScheduleIds, worktreeIds) {
+    if (worktreeIds.length === 0)
+        return;
+    try {
+        const db = getLazyDbInstance();
+        const now = Date.now();
+        const placeholders = worktreeIds.map(() => '?').join(',');
+        // Get enabled schedules for the scanned worktrees
+        const rows = db.prepare(`SELECT id FROM scheduled_executions WHERE worktree_id IN (${placeholders}) AND enabled = 1`).all(...worktreeIds);
+        let disabledCount = 0;
+        const updateStmt = db.prepare('UPDATE scheduled_executions SET enabled = 0, updated_at = ? WHERE id = ?');
+        for (const row of rows) {
+            if (!activeScheduleIds.has(row.id)) {
+                updateStmt.run(now, row.id);
+                disabledCount++;
+            }
+        }
+        if (disabledCount > 0) {
+            console.log(`[schedule-manager] Disabled ${disabledCount} stale DB schedule(s)`);
+        }
+    }
+    catch (error) {
+        console.error('[schedule-manager] Failed to disable stale schedules:', error);
+    }
+}
+// =============================================================================
+// Schedule Execution
+// =============================================================================
+/**
+ * Execute a scheduled task.
+ * Guards against concurrent execution of the same schedule.
+ *
+ * @param state - The schedule state to execute
+ */
+async function executeSchedule(state) {
+    if (state.isExecuting) {
+        console.warn(`[schedule-manager] Skipping concurrent execution for schedule ${state.entry.name}`);
+        return;
+    }
+    state.isExecuting = true;
+    const logId = createExecutionLog(state.scheduleId, state.worktreeId, state.entry.message);
+    try {
+        const db = getLazyDbInstance();
+        const worktree = db.prepare('SELECT path, vibe_local_model FROM worktrees WHERE id = ?').get(state.worktreeId);
+        if (!worktree) {
+            updateExecutionLog(logId, 'failed', 'Worktree not found', null);
+            return;
+        }
+        // Build options for vibe-local model
+        const options = state.entry.cliToolId === 'vibe-local' && worktree.vibe_local_model
+            ? { model: worktree.vibe_local_model }
+            : undefined;
+        const result = await (0, claude_executor_1.executeClaudeCommand)(state.entry.message, worktree.path, state.entry.cliToolId, state.entry.permission, options);
+        updateExecutionLog(logId, result.status, result.output, result.exitCode);
+        updateScheduleLastExecuted(state.scheduleId);
+        console.log(`[schedule-manager] Executed ${state.entry.name}: ${result.status}`);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        updateExecutionLog(logId, 'failed', errorMessage, null);
+        console.error(`[schedule-manager] Execution error for ${state.entry.name}:`, errorMessage);
+    }
+    finally {
+        state.isExecuting = false;
+    }
+}
+// =============================================================================
+// CMATE.md Sync
+// =============================================================================
+/**
+ * Sync schedules from CMATE.md files for all worktrees.
+ * Reads CMATE.md from each worktree, upserts schedules to DB,
+ * creates/updates cron jobs, and removes stale schedules.
+ */
+function syncSchedules() {
+    const manager = getManagerState();
+    const worktrees = getAllWorktrees();
+    // Track which scheduleIds are still valid
+    const activeScheduleIds = new Set();
+    for (const worktree of worktrees) {
+        try {
+            const config = (0, cmate_parser_1.readCmateFile)(worktree.path);
+            if (!config)
+                continue;
+            const scheduleRows = config.get('Schedules');
+            if (!scheduleRows)
+                continue;
+            const entries = (0, cmate_parser_1.parseSchedulesSection)(scheduleRows);
+            for (const entry of entries) {
+                if (manager.schedules.size >= exports.MAX_CONCURRENT_SCHEDULES) {
+                    console.warn(`[schedule-manager] MAX_CONCURRENT_SCHEDULES (${exports.MAX_CONCURRENT_SCHEDULES}) reached`);
+                    return;
+                }
+                const scheduleId = upsertSchedule(worktree.id, entry);
+                activeScheduleIds.add(scheduleId);
+                // Check if this schedule already has a running cron job
+                const existingState = manager.schedules.get(scheduleId);
+                if (existingState) {
+                    // Update entry if changed
+                    existingState.entry = entry;
+                    continue;
+                }
+                if (!entry.enabled || !entry.cronExpression)
+                    continue;
+                // Create new cron job
+                try {
+                    const cronJob = new croner_1.Cron(entry.cronExpression, {
+                        paused: false,
+                        protect: true, // Prevent overlapping
+                    });
+                    const state = {
+                        scheduleId,
+                        worktreeId: worktree.id,
+                        cronJob,
+                        isExecuting: false,
+                        entry,
+                    };
+                    // Schedule execution
+                    cronJob.schedule(() => {
+                        void executeSchedule(state);
+                    });
+                    manager.schedules.set(scheduleId, state);
+                    console.log(`[schedule-manager] Scheduled ${entry.name} (${entry.cronExpression})`);
+                }
+                catch (cronError) {
+                    console.warn(`[schedule-manager] Invalid cron for ${entry.name}:`, cronError);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`[schedule-manager] Error syncing schedules for worktree ${worktree.id}:`, error);
+        }
+    }
+    // Clean up schedules that no longer exist in CMATE.md
+    for (const [scheduleId, state] of manager.schedules) {
+        if (!activeScheduleIds.has(scheduleId)) {
+            state.cronJob.stop();
+            manager.schedules.delete(scheduleId);
+            console.log(`[schedule-manager] Removed stale schedule ${state.entry.name}`);
+        }
+    }
+    // Disable DB records for schedules no longer in CMATE.md
+    const worktreeIds = worktrees.map(w => w.id);
+    disableStaleSchedules(activeScheduleIds, worktreeIds);
+}
+// =============================================================================
+// Manager Lifecycle
+// =============================================================================
+/**
+ * Initialize the schedule manager.
+ * Must be called after initializeWorktrees() completes.
+ *
+ * [S3-010] Called after await initializeWorktrees() in server.ts
+ */
+function initScheduleManager() {
+    const manager = getManagerState();
+    if (manager.initialized) {
+        console.log('[schedule-manager] Already initialized, skipping');
+        return;
+    }
+    console.log('[schedule-manager] Initializing...');
+    // Recovery: mark stale running logs as failed
+    recoverRunningLogs();
+    // Initial sync
+    syncSchedules();
+    // Start periodic sync timer
+    manager.timerId = setInterval(() => {
+        syncSchedules();
+    }, exports.POLL_INTERVAL_MS);
+    manager.initialized = true;
+    console.log(`[schedule-manager] Initialized with ${manager.schedules.size} schedule(s)`);
+}
+/**
+ * Stop all schedules and clean up resources.
+ * Uses synchronous SIGKILL fire-and-forget for immediate cleanup.
+ *
+ * [S3-001] Designed to complete within gracefulShutdown's 3-second timeout
+ */
+function stopAllSchedules() {
+    const manager = getManagerState();
+    // Stop the polling timer
+    if (manager.timerId !== null) {
+        clearInterval(manager.timerId);
+        manager.timerId = null;
+    }
+    // Stop all cron jobs
+    for (const [, state] of manager.schedules) {
+        try {
+            state.cronJob.stop();
+        }
+        catch {
+            // Ignore errors during cleanup
+        }
+    }
+    manager.schedules.clear();
+    // Kill all active child processes (fire-and-forget SIGKILL)
+    const activeProcesses = (0, claude_executor_1.getActiveProcesses)();
+    for (const [pid] of activeProcesses) {
+        try {
+            process.kill(pid, 'SIGKILL');
+        }
+        catch {
+            // Process may have already exited - ignore
+        }
+    }
+    activeProcesses.clear();
+    manager.initialized = false;
+    console.log('[schedule-manager] All schedules stopped');
+}
+/**
+ * Get the current number of active schedules.
+ * Useful for monitoring and testing.
+ */
+function getActiveScheduleCount() {
+    return getManagerState().schedules.size;
+}
+/**
+ * Check if the schedule manager is initialized.
+ */
+function isScheduleManagerInitialized() {
+    return getManagerState().initialized;
+}