@probelabs/visor 0.1.147-ee → 0.1.148

package/dist/sdk/{chunk-EWGX7LI7.mjs → chunk-H4AYMOAT.mjs}

@@ -34,17 +34,6 @@ import {
   config_exports,
   init_config
 } from "./chunk-XNTBSV6M.mjs";
-import {
-  ScheduleStore,
-  buildScheduleToolContext,
-  getScheduleToolDefinition,
-  handleScheduleAction,
-  init_schedule_parser,
-  init_schedule_store,
-  init_schedule_tool,
-  init_store,
-  isScheduleTool
-} from "./chunk-XKCER23W.mjs";
 import {
   ExecutionJournal,
   checkLoopBudget,
@@ -53,11 +42,11 @@ import {
   init_routing,
   init_snapshot_store,
   snapshot_store_exports
-} from "./chunk-FBJ7MC7R.mjs";
+} from "./chunk-CISJ6DJW.mjs";
 import {
   FailureConditionEvaluator,
   init_failure_condition_evaluator
-} from "./chunk-V2QW6ECX.mjs";
+} from "./chunk-RJLJUTSU.mjs";
 import {
   addEvent,
   emitNdjsonFallback,
@@ -68,7 +57,7 @@ import {
   setSpanAttributes,
   trace_helpers_exports,
   withActiveSpan
-} from "./chunk-4F5UVWAN.mjs";
+} from "./chunk-62TNF5PJ.mjs";
 import {
   addDiagramBlock,
   init_metrics
@@ -133,7 +122,7 @@ async function processDiffWithOutline(diffContent) {
   }
   try {
     const originalProbePath = process.env.PROBE_PATH;
-    const fs10 = __require("fs");
+    const fs12 = __require("fs");
     const possiblePaths = [
       // Relative to current working directory (most common in production)
       path.join(process.cwd(), "node_modules/@probelabs/probe/bin/probe-binary"),
@@ -144,7 +133,7 @@ async function processDiffWithOutline(diffContent) {
     ];
     let probeBinaryPath;
     for (const candidatePath of possiblePaths) {
-      if (fs10.existsSync(candidatePath)) {
+      if (fs12.existsSync(candidatePath)) {
         probeBinaryPath = candidatePath;
         break;
       }
@@ -1228,8 +1217,8 @@ ${schemaString}`);
           }
           if (process.env.VISOR_DEBUG_AI_SESSIONS === "true") {
             try {
-              const fs10 = __require("fs");
-              const path13 = __require("path");
+              const fs12 = __require("fs");
+              const path15 = __require("path");
               const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
               const provider = this.config.provider || "auto";
               const model = this.config.model || "default";
@@ -1343,20 +1332,20 @@ ${"=".repeat(60)}
 `;
               readableVersion += `${"=".repeat(60)}
 `;
-              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path13.join(process.cwd(), "debug-artifacts");
-              if (!fs10.existsSync(debugArtifactsDir)) {
-                fs10.mkdirSync(debugArtifactsDir, { recursive: true });
+              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path15.join(process.cwd(), "debug-artifacts");
+              if (!fs12.existsSync(debugArtifactsDir)) {
+                fs12.mkdirSync(debugArtifactsDir, { recursive: true });
               }
-              const debugFile = path13.join(
+              const debugFile = path15.join(
                 debugArtifactsDir,
                 `prompt-${_checkName || "unknown"}-${timestamp}.json`
               );
-              fs10.writeFileSync(debugFile, debugJson, "utf-8");
-              const readableFile = path13.join(
+              fs12.writeFileSync(debugFile, debugJson, "utf-8");
+              const readableFile = path15.join(
                 debugArtifactsDir,
                 `prompt-${_checkName || "unknown"}-${timestamp}.txt`
               );
-              fs10.writeFileSync(readableFile, readableVersion, "utf-8");
+              fs12.writeFileSync(readableFile, readableVersion, "utf-8");
               log(`
 \u{1F4BE} Full debug info saved to:`);
               log(`   JSON: ${debugFile}`);
@@ -1389,8 +1378,8 @@ ${"=".repeat(60)}
           log(`\u{1F4E4} Response length: ${response.length} characters`);
           if (process.env.VISOR_DEBUG_AI_SESSIONS === "true") {
             try {
-              const fs10 = __require("fs");
-              const path13 = __require("path");
+              const fs12 = __require("fs");
+              const path15 = __require("path");
               const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
               const agentAny2 = agent;
               let fullHistory = [];
@@ -1401,8 +1390,8 @@ ${"=".repeat(60)}
               } else if (agentAny2._messages) {
                 fullHistory = agentAny2._messages;
               }
-              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path13.join(process.cwd(), "debug-artifacts");
-              const sessionBase = path13.join(
+              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path15.join(process.cwd(), "debug-artifacts");
+              const sessionBase = path15.join(
                 debugArtifactsDir,
                 `session-${_checkName || "unknown"}-${timestamp}`
               );
@@ -1414,7 +1403,7 @@ ${"=".repeat(60)}
                 schema: effectiveSchema,
                 totalMessages: fullHistory.length
               };
-              fs10.writeFileSync(sessionBase + ".json", JSON.stringify(sessionData, null, 2), "utf-8");
+              fs12.writeFileSync(sessionBase + ".json", JSON.stringify(sessionData, null, 2), "utf-8");
               let readable = `=============================================================
 `;
               readable += `COMPLETE AI SESSION HISTORY (AFTER RESPONSE)
@@ -1441,7 +1430,7 @@ ${"=".repeat(60)}
 `;
                 readable += content + "\n";
               });
-              fs10.writeFileSync(sessionBase + ".summary.txt", readable, "utf-8");
+              fs12.writeFileSync(sessionBase + ".summary.txt", readable, "utf-8");
               log(`\u{1F4BE} Complete session history saved:`);
               log(`   - Contains ALL ${fullHistory.length} messages (prompts + responses)`);
             } catch (error) {
@@ -1450,11 +1439,11 @@ ${"=".repeat(60)}
           }
           if (process.env.VISOR_DEBUG_AI_SESSIONS === "true") {
             try {
-              const fs10 = __require("fs");
-              const path13 = __require("path");
+              const fs12 = __require("fs");
+              const path15 = __require("path");
               const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path13.join(process.cwd(), "debug-artifacts");
-              const responseFile = path13.join(
+              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path15.join(process.cwd(), "debug-artifacts");
+              const responseFile = path15.join(
                 debugArtifactsDir,
                 `response-${_checkName || "unknown"}-${timestamp}.txt`
               );
@@ -1487,7 +1476,7 @@ ${"=".repeat(60)}
 `;
               responseContent += `${"=".repeat(60)}
 `;
-              fs10.writeFileSync(responseFile, responseContent, "utf-8");
+              fs12.writeFileSync(responseFile, responseContent, "utf-8");
               log(`\u{1F4BE} Response saved to: ${responseFile}`);
             } catch (error) {
               log(`\u26A0\uFE0F Could not save response file: ${error}`);
@@ -1503,9 +1492,9 @@ ${"=".repeat(60)}
                 await agentAny._telemetryConfig.shutdown();
                 log(`\u{1F4CA} OpenTelemetry trace saved to: ${agentAny._traceFilePath}`);
                 if (process.env.GITHUB_ACTIONS) {
-                  const fs10 = __require("fs");
-                  if (fs10.existsSync(agentAny._traceFilePath)) {
-                    const stats = fs10.statSync(agentAny._traceFilePath);
+                  const fs12 = __require("fs");
+                  if (fs12.existsSync(agentAny._traceFilePath)) {
+                    const stats = fs12.statSync(agentAny._traceFilePath);
                     console.log(
                       `::notice title=AI Trace Saved::${agentAny._traceFilePath} (${stats.size} bytes)`
                     );
@@ -1712,8 +1701,8 @@ ${schemaString}`);
           const model = this.config.model || "default";
           if (process.env.VISOR_DEBUG_AI_SESSIONS === "true") {
             try {
-              const fs10 = __require("fs");
-              const path13 = __require("path");
+              const fs12 = __require("fs");
+              const path15 = __require("path");
               const os = __require("os");
               const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
               const debugData = {
@@ -1787,18 +1776,18 @@ ${"=".repeat(60)}
               readableVersion += `${"=".repeat(60)}
 `;
               const tempDir = os.tmpdir();
-              const promptFile = path13.join(tempDir, `visor-prompt-${timestamp}.txt`);
-              fs10.writeFileSync(promptFile, prompt, "utf-8");
+              const promptFile = path15.join(tempDir, `visor-prompt-${timestamp}.txt`);
+              fs12.writeFileSync(promptFile, prompt, "utf-8");
               log(`
 \u{1F4BE} Prompt saved to: ${promptFile}`);
-              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path13.join(process.cwd(), "debug-artifacts");
+              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path15.join(process.cwd(), "debug-artifacts");
               try {
-                const base = path13.join(
+                const base = path15.join(
                   debugArtifactsDir,
                   `prompt-${_checkName || "unknown"}-${timestamp}`
                 );
-                fs10.writeFileSync(base + ".json", debugJson, "utf-8");
-                fs10.writeFileSync(base + ".summary.txt", readableVersion, "utf-8");
+                fs12.writeFileSync(base + ".json", debugJson, "utf-8");
+                fs12.writeFileSync(base + ".summary.txt", readableVersion, "utf-8");
                 log(`
 \u{1F4BE} Full debug info saved to directory: ${debugArtifactsDir}`);
               } catch {
@@ -1843,8 +1832,8 @@ $ ${cliCommand}
           log(`\u{1F4E4} Response length: ${response.length} characters`);
           if (process.env.VISOR_DEBUG_AI_SESSIONS === "true") {
             try {
-              const fs10 = __require("fs");
-              const path13 = __require("path");
+              const fs12 = __require("fs");
+              const path15 = __require("path");
               const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
               const agentAny = agent;
               let fullHistory = [];
@@ -1855,8 +1844,8 @@ $ ${cliCommand}
               } else if (agentAny._messages) {
                 fullHistory = agentAny._messages;
               }
-              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path13.join(process.cwd(), "debug-artifacts");
-              const sessionBase = path13.join(
+              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path15.join(process.cwd(), "debug-artifacts");
+              const sessionBase = path15.join(
                 debugArtifactsDir,
                 `session-${_checkName || "unknown"}-${timestamp}`
               );
@@ -1868,7 +1857,7 @@ $ ${cliCommand}
                 schema: effectiveSchema,
                 totalMessages: fullHistory.length
               };
-              fs10.writeFileSync(sessionBase + ".json", JSON.stringify(sessionData, null, 2), "utf-8");
+              fs12.writeFileSync(sessionBase + ".json", JSON.stringify(sessionData, null, 2), "utf-8");
               let readable = `=============================================================
 `;
               readable += `COMPLETE AI SESSION HISTORY (AFTER RESPONSE)
@@ -1895,7 +1884,7 @@ ${"=".repeat(60)}
 `;
                 readable += content + "\n";
               });
-              fs10.writeFileSync(sessionBase + ".summary.txt", readable, "utf-8");
+              fs12.writeFileSync(sessionBase + ".summary.txt", readable, "utf-8");
               log(`\u{1F4BE} Complete session history saved:`);
               log(`   - Contains ALL ${fullHistory.length} messages (prompts + responses)`);
             } catch (error) {
@@ -1904,11 +1893,11 @@ ${"=".repeat(60)}
           }
           if (process.env.VISOR_DEBUG_AI_SESSIONS === "true") {
             try {
-              const fs10 = __require("fs");
-              const path13 = __require("path");
+              const fs12 = __require("fs");
+              const path15 = __require("path");
               const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path13.join(process.cwd(), "debug-artifacts");
-              const responseFile = path13.join(
+              const debugArtifactsDir = process.env.VISOR_DEBUG_ARTIFACTS || path15.join(process.cwd(), "debug-artifacts");
+              const responseFile = path15.join(
                 debugArtifactsDir,
                 `response-${_checkName || "unknown"}-${timestamp}.txt`
               );
@@ -1941,7 +1930,7 @@ ${"=".repeat(60)}
 `;
               responseContent += `${"=".repeat(60)}
 `;
-              fs10.writeFileSync(responseFile, responseContent, "utf-8");
+              fs12.writeFileSync(responseFile, responseContent, "utf-8");
               log(`\u{1F4BE} Response saved to: ${responseFile}`);
             } catch (error) {
               log(`\u26A0\uFE0F Could not save response file: ${error}`);
@@ -1959,9 +1948,9 @@ ${"=".repeat(60)}
                 await telemetry.shutdown();
                 log(`\u{1F4CA} OpenTelemetry trace saved to: ${traceFilePath}`);
                 if (process.env.GITHUB_ACTIONS) {
-                  const fs10 = __require("fs");
-                  if (fs10.existsSync(traceFilePath)) {
-                    const stats = fs10.statSync(traceFilePath);
+                  const fs12 = __require("fs");
+                  if (fs12.existsSync(traceFilePath)) {
+                    const stats = fs12.statSync(traceFilePath);
                     console.log(
                       `::notice title=AI Trace Saved::OpenTelemetry trace file size: ${stats.size} bytes`
                     );
@@ -1999,8 +1988,8 @@ ${"=".repeat(60)}
        * Load schema content from schema files or inline definitions
        */
       async loadSchemaContent(schema) {
-        const fs10 = __require("fs").promises;
-        const path13 = __require("path");
+        const fs12 = __require("fs").promises;
+        const path15 = __require("path");
         if (typeof schema === "object" && schema !== null) {
           log("\u{1F4CB} Using inline schema object from configuration");
           return JSON.stringify(schema);
@@ -2013,14 +2002,14 @@ ${"=".repeat(60)}
           }
         } catch {
         }
-        if ((schema.startsWith("./") || schema.includes(".json")) && !path13.isAbsolute(schema)) {
+        if ((schema.startsWith("./") || schema.includes(".json")) && !path15.isAbsolute(schema)) {
           if (schema.includes("..") || schema.includes("\0")) {
             throw new Error("Invalid schema path: path traversal not allowed");
           }
           try {
-            const schemaPath = path13.resolve(process.cwd(), schema);
+            const schemaPath = path15.resolve(process.cwd(), schema);
             log(`\u{1F4CB} Loading custom schema from file: ${schemaPath}`);
-            const schemaContent = await fs10.readFile(schemaPath, "utf-8");
+            const schemaContent = await fs12.readFile(schemaPath, "utf-8");
             return schemaContent.trim();
           } catch (error) {
             throw new Error(
@@ -2034,22 +2023,22 @@ ${"=".repeat(60)}
         }
         const candidatePaths = [
           // GitHub Action bundle location
-          path13.join(__dirname, "output", sanitizedSchemaName, "schema.json"),
+          path15.join(__dirname, "output", sanitizedSchemaName, "schema.json"),
           // Historical fallback when src/output was inadvertently bundled as output1/
-          path13.join(__dirname, "output1", sanitizedSchemaName, "schema.json"),
+          path15.join(__dirname, "output1", sanitizedSchemaName, "schema.json"),
           // Local dev (repo root)
-          path13.join(process.cwd(), "output", sanitizedSchemaName, "schema.json")
+          path15.join(process.cwd(), "output", sanitizedSchemaName, "schema.json")
         ];
         for (const schemaPath of candidatePaths) {
           try {
-            const schemaContent = await fs10.readFile(schemaPath, "utf-8");
+            const schemaContent = await fs12.readFile(schemaPath, "utf-8");
             return schemaContent.trim();
           } catch {
           }
         }
-        const distPath = path13.join(__dirname, "output", sanitizedSchemaName, "schema.json");
-        const distAltPath = path13.join(__dirname, "output1", sanitizedSchemaName, "schema.json");
-        const cwdPath = path13.join(process.cwd(), "output", sanitizedSchemaName, "schema.json");
+        const distPath = path15.join(__dirname, "output", sanitizedSchemaName, "schema.json");
+        const distAltPath = path15.join(__dirname, "output1", sanitizedSchemaName, "schema.json");
+        const cwdPath = path15.join(process.cwd(), "output", sanitizedSchemaName, "schema.json");
         throw new Error(
           `Failed to load schema '${sanitizedSchemaName}'. Tried: ${distPath}, ${distAltPath}, and ${cwdPath}. Ensure build copies 'output/' into dist (build:cli), or provide a custom schema file/path.`
         );
@@ -3953,7 +3942,7 @@ async function executeWorkflowAsTool(workflowId, args, context2, argsOverrides)
     ...args,
     ...argsOverrides
   };
-  const { WorkflowCheckProvider: WorkflowCheckProvider2 } = await import("./workflow-check-provider-5453TW65.mjs");
+  const { WorkflowCheckProvider: WorkflowCheckProvider2 } = await import("./workflow-check-provider-DYSO3PML.mjs");
   const provider = new WorkflowCheckProvider2();
   const checkConfig = {
     type: "workflow",
@@ -4021,6 +4010,816 @@ var init_workflow_tool_executor = __esm({
   }
 });
 
+// src/scheduler/store/sqlite-store.ts
+import path4 from "path";
+import fs3 from "fs";
+import { v4 as uuidv4 } from "uuid";
+function toDbRow(schedule) {
+  return {
+    id: schedule.id,
+    creator_id: schedule.creatorId,
+    creator_context: schedule.creatorContext ?? null,
+    creator_name: schedule.creatorName ?? null,
+    timezone: schedule.timezone,
+    schedule_expr: schedule.schedule,
+    run_at: schedule.runAt ?? null,
+    is_recurring: schedule.isRecurring ? 1 : 0,
+    original_expression: schedule.originalExpression,
+    workflow: schedule.workflow ?? null,
+    workflow_inputs: schedule.workflowInputs ? JSON.stringify(schedule.workflowInputs) : null,
+    output_context: schedule.outputContext ? JSON.stringify(schedule.outputContext) : null,
+    status: schedule.status,
+    created_at: schedule.createdAt,
+    last_run_at: schedule.lastRunAt ?? null,
+    next_run_at: schedule.nextRunAt ?? null,
+    run_count: schedule.runCount,
+    failure_count: schedule.failureCount,
+    last_error: schedule.lastError ?? null,
+    previous_response: schedule.previousResponse ?? null
+  };
+}
+function safeJsonParse(value) {
+  if (!value) return void 0;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function fromDbRow(row) {
+  return {
+    id: row.id,
+    creatorId: row.creator_id,
+    creatorContext: row.creator_context ?? void 0,
+    creatorName: row.creator_name ?? void 0,
+    timezone: row.timezone,
+    schedule: row.schedule_expr,
+    runAt: row.run_at ?? void 0,
+    isRecurring: row.is_recurring === 1,
+    originalExpression: row.original_expression,
+    workflow: row.workflow ?? void 0,
+    workflowInputs: safeJsonParse(row.workflow_inputs),
+    outputContext: safeJsonParse(row.output_context),
+    status: row.status,
+    createdAt: row.created_at,
+    lastRunAt: row.last_run_at ?? void 0,
+    nextRunAt: row.next_run_at ?? void 0,
+    runCount: row.run_count,
+    failureCount: row.failure_count,
+    lastError: row.last_error ?? void 0,
+    previousResponse: row.previous_response ?? void 0
+  };
+}
+var SqliteStoreBackend;
+var init_sqlite_store = __esm({
+  "src/scheduler/store/sqlite-store.ts"() {
+    "use strict";
+    init_logger();
+    SqliteStoreBackend = class {
+      db = null;
+      dbPath;
+      // In-memory locks (single-node only; SQLite doesn't support distributed locking)
+      locks = /* @__PURE__ */ new Map();
+      constructor(filename) {
+        this.dbPath = filename || ".visor/schedules.db";
+      }
+      async initialize() {
+        const resolvedPath = path4.resolve(process.cwd(), this.dbPath);
+        const dir = path4.dirname(resolvedPath);
+        fs3.mkdirSync(dir, { recursive: true });
+        const { createRequire } = __require("module");
+        const runtimeRequire = createRequire(__filename);
+        let Database;
+        try {
+          Database = runtimeRequire("better-sqlite3");
+        } catch (err) {
+          const code = err?.code;
+          if (code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND") {
+            throw new Error(
+              "better-sqlite3 is required for SQLite schedule storage. Install it with: npm install better-sqlite3"
+            );
+          }
+          throw err;
+        }
+        this.db = new Database(resolvedPath);
+        this.db.pragma("journal_mode = WAL");
+        this.migrateSchema();
+        logger.info(`[SqliteStore] Initialized at ${this.dbPath}`);
+      }
+      async shutdown() {
+        if (this.db) {
+          this.db.close();
+          this.db = null;
+        }
+        this.locks.clear();
+      }
+      // --- Schema Migration ---
+      migrateSchema() {
+        const db = this.getDb();
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS schedules (
+        id              VARCHAR(36)  PRIMARY KEY,
+        creator_id      VARCHAR(255) NOT NULL,
+        creator_context VARCHAR(255),
+        creator_name    VARCHAR(255),
+        timezone        VARCHAR(64)  NOT NULL DEFAULT 'UTC',
+        schedule_expr   VARCHAR(255),
+        run_at          BIGINT,
+        is_recurring    BOOLEAN      NOT NULL,
+        original_expression TEXT,
+        workflow        VARCHAR(255),
+        workflow_inputs TEXT,
+        output_context  TEXT,
+        status          VARCHAR(20)  NOT NULL,
+        created_at      BIGINT       NOT NULL,
+        last_run_at     BIGINT,
+        next_run_at     BIGINT,
+        run_count       INTEGER      NOT NULL DEFAULT 0,
+        failure_count   INTEGER      NOT NULL DEFAULT 0,
+        last_error      TEXT,
+        previous_response TEXT,
+        claimed_by      VARCHAR(255),
+        claimed_at      BIGINT,
+        lock_token      VARCHAR(36)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_schedules_creator_id
+        ON schedules(creator_id);
+
+      CREATE INDEX IF NOT EXISTS idx_schedules_status
+        ON schedules(status);
+
+      CREATE INDEX IF NOT EXISTS idx_schedules_status_next_run
+        ON schedules(status, next_run_at);
+
+      CREATE TABLE IF NOT EXISTS scheduler_locks (
+        lock_id     VARCHAR(255) PRIMARY KEY,
+        node_id     VARCHAR(255) NOT NULL,
+        lock_token  VARCHAR(36)  NOT NULL,
+        acquired_at BIGINT       NOT NULL,
+        expires_at  BIGINT       NOT NULL
+      );
+    `);
+      }
+      // --- Helpers ---
+      getDb() {
+        if (!this.db) {
+          throw new Error("[SqliteStore] Database not initialized. Call initialize() first.");
+        }
+        return this.db;
+      }
+      // --- CRUD ---
+      async create(schedule) {
+        const db = this.getDb();
+        const newSchedule = {
+          ...schedule,
+          id: uuidv4(),
+          createdAt: Date.now(),
+          runCount: 0,
+          failureCount: 0,
+          status: "active"
+        };
+        const row = toDbRow(newSchedule);
+        db.prepare(
+          `
+      INSERT INTO schedules (
+        id, creator_id, creator_context, creator_name, timezone,
+        schedule_expr, run_at, is_recurring, original_expression,
+        workflow, workflow_inputs, output_context,
+        status, created_at, last_run_at, next_run_at,
+        run_count, failure_count, last_error, previous_response
+      ) VALUES (
+        ?, ?, ?, ?, ?,
+        ?, ?, ?, ?,
+        ?, ?, ?,
+        ?, ?, ?, ?,
+        ?, ?, ?, ?
+      )
+    `
+        ).run(
+          row.id,
+          row.creator_id,
+          row.creator_context,
+          row.creator_name,
+          row.timezone,
+          row.schedule_expr,
+          row.run_at,
+          row.is_recurring,
+          row.original_expression,
+          row.workflow,
+          row.workflow_inputs,
+          row.output_context,
+          row.status,
+          row.created_at,
+          row.last_run_at,
+          row.next_run_at,
+          row.run_count,
+          row.failure_count,
+          row.last_error,
+          row.previous_response
+        );
+        logger.info(
+          `[SqliteStore] Created schedule ${newSchedule.id} for user ${newSchedule.creatorId}`
+        );
+        return newSchedule;
+      }
+      async importSchedule(schedule) {
+        const db = this.getDb();
+        const row = toDbRow(schedule);
+        db.prepare(
+          `
+      INSERT OR IGNORE INTO schedules (
+        id, creator_id, creator_context, creator_name, timezone,
+        schedule_expr, run_at, is_recurring, original_expression,
+        workflow, workflow_inputs, output_context,
+        status, created_at, last_run_at, next_run_at,
+        run_count, failure_count, last_error, previous_response
+      ) VALUES (
+        ?, ?, ?, ?, ?,
+        ?, ?, ?, ?,
+        ?, ?, ?,
+        ?, ?, ?, ?,
+        ?, ?, ?, ?
+      )
+    `
+        ).run(
+          row.id,
+          row.creator_id,
+          row.creator_context,
+          row.creator_name,
+          row.timezone,
+          row.schedule_expr,
+          row.run_at,
+          row.is_recurring,
+          row.original_expression,
+          row.workflow,
+          row.workflow_inputs,
+          row.output_context,
+          row.status,
+          row.created_at,
+          row.last_run_at,
+          row.next_run_at,
+          row.run_count,
+          row.failure_count,
+          row.last_error,
+          row.previous_response
+        );
+      }
+      async get(id) {
+        const db = this.getDb();
+        const row = db.prepare("SELECT * FROM schedules WHERE id = ?").get(id);
+        return row ? fromDbRow(row) : void 0;
+      }
+      async update(id, patch) {
+        const db = this.getDb();
+        const existing = db.prepare("SELECT * FROM schedules WHERE id = ?").get(id);
+        if (!existing) return void 0;
+        const current = fromDbRow(existing);
+        const updated = { ...current, ...patch, id: current.id };
+        const row = toDbRow(updated);
+        db.prepare(
+          `
+      UPDATE schedules SET
+        creator_id = ?, creator_context = ?, creator_name = ?, timezone = ?,
+        schedule_expr = ?, run_at = ?, is_recurring = ?, original_expression = ?,
+        workflow = ?, workflow_inputs = ?, output_context = ?,
+        status = ?, last_run_at = ?, next_run_at = ?,
+        run_count = ?, failure_count = ?, last_error = ?, previous_response = ?
+      WHERE id = ?
+    `
+        ).run(
+          row.creator_id,
+          row.creator_context,
+          row.creator_name,
+          row.timezone,
+          row.schedule_expr,
+          row.run_at,
+          row.is_recurring,
+          row.original_expression,
+          row.workflow,
+          row.workflow_inputs,
+          row.output_context,
+          row.status,
+          row.last_run_at,
+          row.next_run_at,
+          row.run_count,
+          row.failure_count,
+          row.last_error,
+          row.previous_response,
+          row.id
+        );
+        return updated;
+      }
+      async delete(id) {
+        const db = this.getDb();
+        const result = db.prepare("DELETE FROM schedules WHERE id = ?").run(id);
+        if (result.changes > 0) {
+          logger.info(`[SqliteStore] Deleted schedule ${id}`);
+          return true;
+        }
+        return false;
+      }
+      // --- Queries ---
+      async getByCreator(creatorId) {
+        const db = this.getDb();
+        const rows = db.prepare("SELECT * FROM schedules WHERE creator_id = ?").all(creatorId);
+        return rows.map(fromDbRow);
+      }
+      async getActiveSchedules() {
+        const db = this.getDb();
+        const rows = db.prepare("SELECT * FROM schedules WHERE status = 'active'").all();
+        return rows.map(fromDbRow);
+      }
+      async getDueSchedules(now) {
+        const ts = now ?? Date.now();
+        const db = this.getDb();
+        const rows = db.prepare(
+          `SELECT * FROM schedules
+         WHERE status = 'active'
+         AND (
+           (is_recurring = 0 AND run_at IS NOT NULL AND run_at <= ?)
+           OR
+           (is_recurring = 1 AND next_run_at IS NOT NULL AND next_run_at <= ?)
+         )`
+        ).all(ts, ts);
+        return rows.map(fromDbRow);
+      }
+      async findByWorkflow(creatorId, workflowName) {
+        const db = this.getDb();
+        const escaped = workflowName.toLowerCase().replace(/[%_\\]/g, "\\$&");
+        const pattern = `%${escaped}%`;
+        const rows = db.prepare(
+          `SELECT * FROM schedules
+         WHERE creator_id = ? AND status = 'active'
+         AND LOWER(workflow) LIKE ? ESCAPE '\\'`
+        ).all(creatorId, pattern);
+        return rows.map(fromDbRow);
+      }
+      async getAll() {
+        const db = this.getDb();
+        const rows = db.prepare("SELECT * FROM schedules").all();
+        return rows.map(fromDbRow);
+      }
+      async getStats() {
+        const db = this.getDb();
+        const row = db.prepare(
+          `SELECT
+          COUNT(*) as total,
+          SUM(CASE WHEN status = 'active' THEN 1 ELSE 0 END) as active,
+          SUM(CASE WHEN status = 'paused' THEN 1 ELSE 0 END) as paused,
+          SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed,
+          SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed,
+          SUM(CASE WHEN is_recurring = 1 THEN 1 ELSE 0 END) as recurring,
+          SUM(CASE WHEN is_recurring = 0 THEN 1 ELSE 0 END) as one_time
+        FROM schedules`
+        ).get();
+        return {
+          total: row.total,
+          active: row.active,
+          paused: row.paused,
+          completed: row.completed,
+          failed: row.failed,
+          recurring: row.recurring,
+          oneTime: row.one_time
+        };
+      }
+      async validateLimits(creatorId, isRecurring, limits) {
+        const db = this.getDb();
+        if (limits.maxGlobal) {
+          const row = db.prepare("SELECT COUNT(*) as cnt FROM schedules").get();
+          if (row.cnt >= limits.maxGlobal) {
+            throw new Error(`Global schedule limit reached (${limits.maxGlobal})`);
+          }
+        }
+        if (limits.maxPerUser) {
+          const row = db.prepare("SELECT COUNT(*) as cnt FROM schedules WHERE creator_id = ?").get(creatorId);
+          if (row.cnt >= limits.maxPerUser) {
+            throw new Error(`You have reached the maximum number of schedules (${limits.maxPerUser})`);
+          }
+        }
+        if (isRecurring && limits.maxRecurringPerUser) {
+          const row = db.prepare("SELECT COUNT(*) as cnt FROM schedules WHERE creator_id = ? AND is_recurring = 1").get(creatorId);
+          if (row.cnt >= limits.maxRecurringPerUser) {
+            throw new Error(
+              `You have reached the maximum number of recurring schedules (${limits.maxRecurringPerUser})`
+            );
+          }
+        }
+      }
+      // --- HA Locking (in-memory for SQLite — single-node only) ---
+      async tryAcquireLock(scheduleId, nodeId, ttlSeconds) {
+        const now = Date.now();
+        const existing = this.locks.get(scheduleId);
+        if (existing && existing.expiresAt > now) {
+          if (existing.nodeId === nodeId) {
+            return existing.token;
+          }
+          return null;
+        }
+        const token = uuidv4();
+        this.locks.set(scheduleId, {
+          nodeId,
+          token,
+          expiresAt: now + ttlSeconds * 1e3
+        });
+        return token;
+      }
+      async releaseLock(scheduleId, lockToken) {
+        const existing = this.locks.get(scheduleId);
+        if (existing && existing.token === lockToken) {
+          this.locks.delete(scheduleId);
+        }
+      }
+      async renewLock(scheduleId, lockToken, ttlSeconds) {
+        const existing = this.locks.get(scheduleId);
+        if (!existing || existing.token !== lockToken) {
+          return false;
+        }
+        existing.expiresAt = Date.now() + ttlSeconds * 1e3;
+        return true;
+      }
+      async flush() {
+      }
+    };
+  }
+});
+
+// src/scheduler/store/index.ts
+async function createStoreBackend(storageConfig, haConfig) {
+  const driver = storageConfig?.driver || "sqlite";
+  switch (driver) {
+    case "sqlite": {
+      const conn = storageConfig?.connection;
+      return new SqliteStoreBackend(conn?.filename);
+    }
+    case "postgresql":
+    case "mysql":
+    case "mssql": {
+      try {
+        const loaderPath = "../../enterprise/loader";
+        const { loadEnterpriseStoreBackend } = await import(loaderPath);
+        return await loadEnterpriseStoreBackend(driver, storageConfig, haConfig);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.error(`[StoreFactory] Failed to load enterprise ${driver} backend: ${msg}`);
+        throw new Error(
+          `The ${driver} schedule storage driver requires a Visor Enterprise license. Install the enterprise package or use driver: 'sqlite' (default). Original error: ${msg}`
+        );
+      }
+    }
+    default:
+      throw new Error(`Unknown schedule storage driver: ${driver}`);
+  }
+}
+var init_store = __esm({
+  "src/scheduler/store/index.ts"() {
+    "use strict";
+    init_logger();
+    init_sqlite_store();
+  }
+});
+
+// src/scheduler/store/json-migrator.ts
+import fs4 from "fs/promises";
+import path5 from "path";
+async function migrateJsonToBackend(jsonPath, backend) {
+  const resolvedPath = path5.resolve(process.cwd(), jsonPath);
+  let content;
+  try {
+    content = await fs4.readFile(resolvedPath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return 0;
+    }
+    throw err;
+  }
+  let data;
+  try {
+    data = JSON.parse(content);
+  } catch {
+    logger.warn(`[JsonMigrator] Failed to parse ${jsonPath}, skipping migration`);
+    return 0;
+  }
+  const schedules = data.schedules;
+  if (!Array.isArray(schedules) || schedules.length === 0) {
+    logger.debug("[JsonMigrator] No schedules to migrate");
+    await renameToMigrated(resolvedPath);
+    return 0;
+  }
+  let migrated = 0;
+  for (const schedule of schedules) {
+    if (!schedule.id) {
+      logger.warn("[JsonMigrator] Skipping schedule without ID");
+      continue;
+    }
+    const existing = await backend.get(schedule.id);
+    if (existing) {
+      logger.debug(`[JsonMigrator] Schedule ${schedule.id} already exists, skipping`);
+      continue;
+    }
+    try {
+      await backend.importSchedule(schedule);
+      migrated++;
+    } catch (err) {
+      logger.warn(
+        `[JsonMigrator] Failed to migrate schedule ${schedule.id}: ${err instanceof Error ? err.message : err}`
+      );
+    }
+  }
+  await renameToMigrated(resolvedPath);
+  logger.info(`[JsonMigrator] Migrated ${migrated}/${schedules.length} schedules from ${jsonPath}`);
+  return migrated;
+}
+async function renameToMigrated(resolvedPath) {
+  const migratedPath = `${resolvedPath}.migrated`;
+  try {
+    await fs4.rename(resolvedPath, migratedPath);
+    logger.info(`[JsonMigrator] Backed up ${resolvedPath} \u2192 ${migratedPath}`);
+  } catch (err) {
+    logger.warn(
+      `[JsonMigrator] Failed to rename ${resolvedPath}: ${err instanceof Error ? err.message : err}`
+    );
+  }
+}
+var init_json_migrator = __esm({
+  "src/scheduler/store/json-migrator.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// src/scheduler/schedule-store.ts
+var ScheduleStore;
+var init_schedule_store = __esm({
+  "src/scheduler/schedule-store.ts"() {
+    "use strict";
+    init_logger();
+    init_store();
+    init_json_migrator();
+    ScheduleStore = class _ScheduleStore {
+      static instance;
+      backend = null;
+      initialized = false;
+      limits;
+      config;
+      externalBackend = null;
+      constructor(config, limits, backend) {
+        this.config = config || {};
+        this.limits = {
+          maxPerUser: limits?.maxPerUser ?? 25,
+          maxRecurringPerUser: limits?.maxRecurringPerUser ?? 10,
+          maxGlobal: limits?.maxGlobal ?? 1e3
+        };
+        if (backend) {
+          this.externalBackend = backend;
+        }
+      }
+      /**
+       * Get singleton instance
+       *
+       * Note: Config and limits are only applied on first call. Subsequent calls
+       * with different parameters will log a warning and return the existing instance.
+       * Use createIsolated() for testing with different configurations.
+       */
+      static getInstance(config, limits) {
+        if (!_ScheduleStore.instance) {
+          _ScheduleStore.instance = new _ScheduleStore(config, limits);
+        } else if (config || limits) {
+          logger.warn(
+            "[ScheduleStore] getInstance() called with config/limits but instance already exists. Parameters ignored. Use createIsolated() for testing or resetInstance() first."
+          );
+        }
+        return _ScheduleStore.instance;
+      }
+      /**
+       * Create a new isolated instance (for testing)
+       */
+      static createIsolated(config, limits, backend) {
+        return new _ScheduleStore(config, limits, backend);
+      }
+      /**
+       * Reset singleton instance (for testing)
+       */
+      static resetInstance() {
+        if (_ScheduleStore.instance) {
+          if (_ScheduleStore.instance.backend) {
+            _ScheduleStore.instance.backend.shutdown().catch(() => {
+            });
+          }
+        }
+        _ScheduleStore.instance = void 0;
+      }
+      /**
+       * Initialize the store - creates backend and runs migrations
+       */
+      async initialize() {
+        if (this.initialized) {
+          return;
+        }
+        if (this.externalBackend) {
+          this.backend = this.externalBackend;
+        } else {
+          this.backend = await createStoreBackend(this.config.storage, this.config.ha);
+        }
+        await this.backend.initialize();
+        const jsonPath = this.config.path || ".visor/schedules.json";
+        try {
+          await migrateJsonToBackend(jsonPath, this.backend);
+        } catch (err) {
+          logger.warn(
+            `[ScheduleStore] JSON migration failed (non-fatal): ${err instanceof Error ? err.message : err}`
+          );
+        }
+        this.initialized = true;
+      }
+      /**
+       * Create a new schedule (async, persists immediately)
+       */
+      async createAsync(schedule) {
+        const backend = this.getBackend();
+        await backend.validateLimits(schedule.creatorId, schedule.isRecurring, this.limits);
+        return backend.create(schedule);
+      }
+      /**
+       * Get a schedule by ID
+       */
+      async getAsync(id) {
+        return this.getBackend().get(id);
+      }
+      /**
+       * Update a schedule
+       */
+      async updateAsync(id, patch) {
+        return this.getBackend().update(id, patch);
+      }
+      /**
+       * Delete a schedule
+       */
+      async deleteAsync(id) {
+        return this.getBackend().delete(id);
+      }
+      /**
+       * Get all schedules for a specific creator
+       */
+      async getByCreatorAsync(creatorId) {
+        return this.getBackend().getByCreator(creatorId);
+      }
+      /**
+       * Get all active schedules
+       */
+      async getActiveSchedulesAsync() {
+        return this.getBackend().getActiveSchedules();
+      }
+      /**
+       * Get all schedules due for execution
+       * @param now Current timestamp in milliseconds
+       */
+      async getDueSchedulesAsync(now = Date.now()) {
+        return this.getBackend().getDueSchedules(now);
+      }
+      /**
+       * Find schedules by workflow name
+       */
+      async findByWorkflowAsync(creatorId, workflowName) {
+        return this.getBackend().findByWorkflow(creatorId, workflowName);
+      }
+      /**
+       * Get schedule count statistics
+       */
+      async getStatsAsync() {
+        return this.getBackend().getStats();
+      }
+      /**
+       * Force immediate save (useful for shutdown)
+       */
+      async flush() {
+        if (this.backend) {
+          await this.backend.flush();
+        }
+      }
+      /**
+       * Check if initialized
+       */
+      isInitialized() {
+        return this.initialized;
+      }
+      /**
+       * Check if there are unsaved changes
+       */
+      hasPendingChanges() {
+        return false;
+      }
+      /**
+       * Get all schedules
+       */
+      async getAllAsync() {
+        return this.getBackend().getAll();
+      }
+      /**
+       * Get the underlying backend (for HA lock operations)
+       */
+      getBackend() {
+        if (!this.backend) {
+          throw new Error("[ScheduleStore] Not initialized. Call initialize() first.");
+        }
+        return this.backend;
+      }
+      /**
+       * Shut down the backend cleanly
+       */
+      async shutdown() {
+        if (this.backend) {
+          await this.backend.shutdown();
+          this.backend = null;
+        }
+        this.initialized = false;
+      }
+    };
+  }
+});
+
+// src/scheduler/schedule-parser.ts
+function getNextRunTime(cronExpression, _timezone = "UTC") {
+  const parts = cronExpression.split(" ");
+  if (parts.length !== 5) {
+    throw new Error(`Invalid cron expression: ${cronExpression}`);
+  }
+  const [minute, hour, dayOfMonth, month, dayOfWeek] = parts;
+  const now = /* @__PURE__ */ new Date();
+  const next = new Date(now);
+  next.setSeconds(0, 0);
+  next.setMinutes(next.getMinutes() + 1);
+  const maxAttempts = 365 * 24 * 60;
+  for (let i = 0; i < maxAttempts; i++) {
+    if (matchesCronPart(next.getMinutes(), minute) && matchesCronPart(next.getHours(), hour) && matchesCronPart(next.getDate(), dayOfMonth) && matchesCronPart(next.getMonth() + 1, month) && matchesCronPart(next.getDay(), dayOfWeek)) {
+      return next;
+    }
+    next.setMinutes(next.getMinutes() + 1);
+  }
+  const fallback = new Date(now);
+  fallback.setDate(fallback.getDate() + 1);
+  fallback.setHours(parseInt(hour, 10) || 9);
+  fallback.setMinutes(parseInt(minute, 10) || 0);
+  fallback.setSeconds(0, 0);
+  return fallback;
+}
+function matchesCronPart(value, cronPart) {
+  if (cronPart === "*") return true;
+  if (cronPart.startsWith("*/")) {
+    const step = parseInt(cronPart.slice(2), 10);
+    return value % step === 0;
+  }
+  if (cronPart.includes("-")) {
+    const [start, end] = cronPart.split("-").map((n) => parseInt(n, 10));
+    return value >= start && value <= end;
+  }
+  if (cronPart.includes(",")) {
+    return cronPart.split(",").map((n) => parseInt(n, 10)).includes(value);
+  }
+  return parseInt(cronPart, 10) === value;
+}
+function isValidCronExpression(expr) {
+  if (!expr || typeof expr !== "string") return false;
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5) return false;
+  const ranges = [
+    [0, 59],
+    // minute
+    [0, 23],
+    // hour
+    [1, 31],
+    // day of month
+    [1, 12],
+    // month
+    [0, 7]
+    // day of week (0 and 7 are Sunday)
+  ];
+  return parts.every((part, i) => {
+    if (part === "*") return true;
+    if (part.startsWith("*/")) {
+      const step = parseInt(part.slice(2), 10);
+      return !isNaN(step) && step > 0;
+    }
+    if (part.includes("-")) {
+      const [start, end] = part.split("-").map((n) => parseInt(n, 10));
+      return !isNaN(start) && !isNaN(end) && start >= ranges[i][0] && end <= ranges[i][1];
+    }
+    if (part.includes(",")) {
+      return part.split(",").every((n) => {
+        const val2 = parseInt(n, 10);
+        return !isNaN(val2) && val2 >= ranges[i][0] && val2 <= ranges[i][1];
+      });
+    }
+    const val = parseInt(part, 10);
+    return !isNaN(val) && val >= ranges[i][0] && val <= ranges[i][1];
+  });
+}
+var init_schedule_parser = __esm({
+  "src/scheduler/schedule-parser.ts"() {
+    "use strict";
+  }
+});
+
 // src/state-machine/states/init.ts
 async function handleInit(context2, state, transition) {
   if (context2.debug) {
@@ -4804,8 +5603,8 @@ var init_wave_planning = __esm({
 });
 
 // src/utils/mermaid-telemetry.ts
-import * as fs3 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path6 from "path";
 function emitMermaidFromMarkdown(checkName, markdown, origin) {
   if (!markdown || typeof markdown !== "string") return 0;
   let m;
@@ -4818,16 +5617,16 @@ function emitMermaidFromMarkdown(checkName, markdown, origin) {
         addEvent("diagram.block", { check: checkName, origin, code });
         addDiagramBlock(origin);
         if (process.env.VISOR_TRACE_REPORT === "true") {
-          const outDir = process.env.VISOR_TRACE_DIR || path4.join(process.cwd(), "output", "traces");
+          const outDir = process.env.VISOR_TRACE_DIR || path6.join(process.cwd(), "output", "traces");
           try {
-            if (!fs3.existsSync(outDir)) fs3.mkdirSync(outDir, { recursive: true });
+            if (!fs5.existsSync(outDir)) fs5.mkdirSync(outDir, { recursive: true });
             const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-            const jsonPath = path4.join(outDir, `${ts}.trace.json`);
-            const htmlPath = path4.join(outDir, `${ts}.report.html`);
+            const jsonPath = path6.join(outDir, `${ts}.trace.json`);
+            const htmlPath = path6.join(outDir, `${ts}.report.html`);
             let data = { spans: [] };
-            if (fs3.existsSync(jsonPath)) {
+            if (fs5.existsSync(jsonPath)) {
               try {
-                data = JSON.parse(fs3.readFileSync(jsonPath, "utf8"));
+                data = JSON.parse(fs5.readFileSync(jsonPath, "utf8"));
               } catch {
                 data = { spans: [] };
               }
@@ -4835,9 +5634,9 @@ function emitMermaidFromMarkdown(checkName, markdown, origin) {
             data.spans.push({
               events: [{ name: "diagram.block", attrs: { check: checkName, origin, code } }]
             });
-            fs3.writeFileSync(jsonPath, JSON.stringify(data, null, 2), "utf8");
-            if (!fs3.existsSync(htmlPath)) {
-              fs3.writeFileSync(
+            fs5.writeFileSync(jsonPath, JSON.stringify(data, null, 2), "utf8");
+            if (!fs5.existsSync(htmlPath)) {
+              fs5.writeFileSync(
                 htmlPath,
                 '<!doctype html><html><head><meta charset="utf-8"/><title>Visor Trace Report</title></head><body><h2>Visor Trace Report</h2></body></html>',
                 "utf8"
@@ -5494,8 +6293,8 @@ var init_dependency_gating = __esm({
 async function renderTemplateContent(checkId, checkConfig, reviewSummary) {
   try {
     const { createExtendedLiquid: createExtendedLiquid2 } = await import("./liquid-extensions-PLBOMRLI.mjs");
-    const fs10 = await import("fs/promises");
-    const path13 = await import("path");
+    const fs12 = await import("fs/promises");
+    const path15 = await import("path");
     const schemaRaw = checkConfig.schema || "plain";
     const schema = typeof schemaRaw === "string" ? schemaRaw : "code-review";
     let templateContent;
@@ -5503,24 +6302,24 @@ async function renderTemplateContent(checkId, checkConfig, reviewSummary) {
       templateContent = String(checkConfig.template.content);
     } else if (checkConfig.template && checkConfig.template.file) {
       const file = String(checkConfig.template.file);
-      const resolved = path13.resolve(process.cwd(), file);
-      templateContent = await fs10.readFile(resolved, "utf-8");
+      const resolved = path15.resolve(process.cwd(), file);
+      templateContent = await fs12.readFile(resolved, "utf-8");
     } else if (schema && schema !== "plain") {
       const sanitized = String(schema).replace(/[^a-zA-Z0-9-]/g, "");
       if (sanitized) {
         const candidatePaths = [
-          path13.join(__dirname, "output", sanitized, "template.liquid"),
+          path15.join(__dirname, "output", sanitized, "template.liquid"),
           // bundled: dist/output/
-          path13.join(__dirname, "..", "..", "output", sanitized, "template.liquid"),
+          path15.join(__dirname, "..", "..", "output", sanitized, "template.liquid"),
           // source: output/
-          path13.join(process.cwd(), "output", sanitized, "template.liquid"),
+          path15.join(process.cwd(), "output", sanitized, "template.liquid"),
           // fallback: cwd/output/
-          path13.join(process.cwd(), "dist", "output", sanitized, "template.liquid")
+          path15.join(process.cwd(), "dist", "output", sanitized, "template.liquid")
           // fallback: cwd/dist/output/
         ];
         for (const p of candidatePaths) {
           try {
-            templateContent = await fs10.readFile(p, "utf-8");
+            templateContent = await fs12.readFile(p, "utf-8");
             if (templateContent) break;
           } catch {
           }
@@ -8208,7 +9007,7 @@ async function executeCheckWithForEachItems2(checkId, forEachParent, forEachItem
           }
         }
         try {
-          const { evaluateTransitions } = await import("./routing-CZ36LVVS.mjs");
+          const { evaluateTransitions } = await import("./routing-LU5PAREW.mjs");
           const transTarget = await evaluateTransitions(
             onFinish.transitions,
             forEachParent,
@@ -8268,7 +9067,7 @@ async function executeCheckWithForEachItems2(checkId, forEachParent, forEachItem
             `[LevelDispatch] Error evaluating on_finish transitions for ${forEachParent}: ${e instanceof Error ? e.message : String(e)}`
           );
         }
-        const { evaluateGoto: evaluateGoto2 } = await import("./routing-CZ36LVVS.mjs");
+        const { evaluateGoto: evaluateGoto2 } = await import("./routing-LU5PAREW.mjs");
         if (context2.debug) {
           logger.info(
             `[LevelDispatch] Evaluating on_finish.goto_js for forEach parent: ${forEachParent}`
@@ -9521,8 +10320,8 @@ function updateStats2(results, state, isForEachIteration = false) {
 async function renderTemplateContent2(checkId, checkConfig, reviewSummary) {
   try {
     const { createExtendedLiquid: createExtendedLiquid2 } = await import("./liquid-extensions-PLBOMRLI.mjs");
-    const fs10 = await import("fs/promises");
-    const path13 = await import("path");
+    const fs12 = await import("fs/promises");
+    const path15 = await import("path");
     const schemaRaw = checkConfig.schema || "plain";
     const schema = typeof schemaRaw === "string" && !schemaRaw.includes("{{") && !schemaRaw.includes("{%") ? schemaRaw : typeof schemaRaw === "object" ? "code-review" : "plain";
     let templateContent;
@@ -9531,27 +10330,27 @@ async function renderTemplateContent2(checkId, checkConfig, reviewSummary) {
       logger.debug(`[LevelDispatch] Using inline template for ${checkId}`);
     } else if (checkConfig.template && checkConfig.template.file) {
       const file = String(checkConfig.template.file);
-      const resolved = path13.resolve(process.cwd(), file);
-      templateContent = await fs10.readFile(resolved, "utf-8");
+      const resolved = path15.resolve(process.cwd(), file);
+      templateContent = await fs12.readFile(resolved, "utf-8");
       logger.debug(`[LevelDispatch] Using template file for ${checkId}: ${resolved}`);
     } else if (schema && schema !== "plain") {
       const sanitized = String(schema).replace(/[^a-zA-Z0-9-]/g, "");
       if (sanitized) {
         const candidatePaths = [
-          path13.join(__dirname, "output", sanitized, "template.liquid"),
+          path15.join(__dirname, "output", sanitized, "template.liquid"),
           // bundled: dist/output/
-          path13.join(__dirname, "..", "..", "output", sanitized, "template.liquid"),
+          path15.join(__dirname, "..", "..", "output", sanitized, "template.liquid"),
           // source (from state-machine/states)
-          path13.join(__dirname, "..", "..", "..", "output", sanitized, "template.liquid"),
+          path15.join(__dirname, "..", "..", "..", "output", sanitized, "template.liquid"),
           // source (alternate)
-          path13.join(process.cwd(), "output", sanitized, "template.liquid"),
+          path15.join(process.cwd(), "output", sanitized, "template.liquid"),
           // fallback: cwd/output/
-          path13.join(process.cwd(), "dist", "output", sanitized, "template.liquid")
+          path15.join(process.cwd(), "dist", "output", sanitized, "template.liquid")
           // fallback: cwd/dist/output/
         ];
         for (const p of candidatePaths) {
           try {
-            templateContent = await fs10.readFile(p, "utf-8");
+            templateContent = await fs12.readFile(p, "utf-8");
             if (templateContent) {
               logger.debug(`[LevelDispatch] Using schema template for ${checkId}: ${p}`);
               break;
@@ -11075,7 +11874,7 @@ var init_sandbox_manager = __esm({
 
 // src/utils/workspace-manager.ts
 import * as fsp from "fs/promises";
-import * as path5 from "path";
+import * as path7 from "path";
 function shellEscape(str) {
   return "'" + str.replace(/'/g, "'\\''") + "'";
 }
@@ -11119,7 +11918,7 @@ var init_workspace_manager = __esm({
         };
         this.basePath = this.config.basePath;
         const workspaceDirName = sanitizePathComponent(this.config.name || this.sessionId);
-        this.workspacePath = path5.join(this.basePath, workspaceDirName);
+        this.workspacePath = path7.join(this.basePath, workspaceDirName);
       }
       /**
        * Get or create a WorkspaceManager instance for a session
@@ -11214,7 +12013,7 @@ var init_workspace_manager = __esm({
           configuredMainProjectName || this.extractProjectName(this.originalPath)
         );
         this.usedNames.add(mainProjectName);
-        const mainProjectPath = path5.join(this.workspacePath, mainProjectName);
+        const mainProjectPath = path7.join(this.workspacePath, mainProjectName);
         const isGitRepo = await this.isGitRepository(this.originalPath);
         if (isGitRepo) {
           const exists = await this.pathExists(mainProjectPath);
@@ -11232,6 +12031,8 @@ var init_workspace_manager = __esm({
               } catch {
               }
               await this.createMainProjectWorktree(mainProjectPath);
+            } else {
+              await this.refreshWorktreeToUpstream(mainProjectPath);
             }
           } else {
             await this.createMainProjectWorktree(mainProjectPath);
@@ -11276,7 +12077,7 @@ var init_workspace_manager = __esm({
         let projectName = sanitizePathComponent(description || this.extractRepoName(repository));
         projectName = this.getUniqueName(projectName);
         this.usedNames.add(projectName);
-        const workspacePath = path5.join(this.workspacePath, projectName);
+        const workspacePath = path7.join(this.workspacePath, projectName);
         await fsp.rm(workspacePath, { recursive: true, force: true });
         try {
           await fsp.symlink(worktreePath, workspacePath);
@@ -11386,7 +12187,7 @@ var init_workspace_manager = __esm({
           const now = Date.now();
           for (const entry of entries) {
             if (!entry.isDirectory()) continue;
-            const dirPath = path5.join(basePath, entry.name);
+            const dirPath = path7.join(basePath, entry.name);
             try {
               const stat2 = await fsp.stat(dirPath);
               if (now - stat2.mtimeMs > maxAgeMs) {
@@ -11394,8 +12195,8 @@ var init_workspace_manager = __esm({
                   const subdirs = await fsp.readdir(dirPath, { withFileTypes: true });
                   for (const sub of subdirs) {
                     if (!sub.isDirectory()) continue;
-                    const subPath = path5.join(dirPath, sub.name);
-                    const gitFilePath = path5.join(subPath, ".git");
+                    const subPath = path7.join(dirPath, sub.name);
+                    const gitFilePath = path7.join(subPath, ".git");
                     try {
                       const gitContent = await fsp.readFile(gitFilePath, "utf-8");
                       const match = gitContent.match(/gitdir:\s*(.+)/);
@@ -11427,33 +12228,143 @@ var init_workspace_manager = __esm({
         return cleaned;
       }
       /**
-       * Create worktree for the main project
-       *
-       * visor-disable: architecture - Not using WorktreeManager here because:
-       * 1. WorktreeManager expects remote URLs and clones to bare repos first
-       * 2. This operates on the LOCAL repo we're already in (no cloning needed)
-       * 3. Adding a "local mode" to WorktreeManager would add complexity for minimal benefit
-       * The git commands here are simpler (just rev-parse + worktree add) vs WorktreeManager's
-       * full clone/bare-repo/fetch/worktree pipeline.
+       * visor-disable: architecture - The helpers below (resolveUpstreamRef,
+       * fetchAndResolveUpstream, resetAndCleanWorktree, refreshWorktreeToUpstream)
+       * are NOT duplicates of WorktreeManager's fetchRef/getCommitShaForRef/cleanWorktree.
+       * WorktreeManager operates on BARE repo caches cloned from remote URLs, while
+       * WorkspaceManager operates on the LOCAL working repo the user already has checked out.
+       * The git commands differ (e.g. `fetch origin --prune` vs `fetch origin <ref>:<ref>`)
+       * and sharing code would require adding a "local mode" to WorktreeManager for no benefit.
        */
-      async createMainProjectWorktree(targetPath) {
-        logger.debug(`Creating main project worktree: ${targetPath}`);
+      /**
+       * Resolve the upstream default branch ref.
+       * Tries origin/HEAD (symbolic), then origin/main, then origin/master.
+       * Falls back to local HEAD if no remote is configured.
+       */
+      async resolveUpstreamRef() {
+        const esc = shellEscape(this.originalPath);
+        const symbolicResult = await commandExecutor.execute(
+          `git -C ${esc} symbolic-ref refs/remotes/origin/HEAD 2>/dev/null`,
+          { timeout: 1e4 }
+        );
+        if (symbolicResult.exitCode === 0 && symbolicResult.stdout.trim()) {
+          const ref = symbolicResult.stdout.trim().replace("refs/remotes/", "");
+          logger.debug(`[Workspace] Resolved upstream default branch via origin/HEAD: ${ref}`);
+          return ref;
+        }
+        const mainResult = await commandExecutor.execute(
+          `git -C ${esc} rev-parse --verify origin/main 2>/dev/null`,
+          { timeout: 1e4 }
+        );
+        if (mainResult.exitCode === 0) {
+          logger.debug(`[Workspace] Using origin/main as upstream ref`);
+          return "origin/main";
+        }
+        const masterResult = await commandExecutor.execute(
+          `git -C ${esc} rev-parse --verify origin/master 2>/dev/null`,
+          { timeout: 1e4 }
+        );
+        if (masterResult.exitCode === 0) {
+          logger.debug(`[Workspace] Using origin/master as upstream ref`);
+          return "origin/master";
+        }
+        logger.warn(`[Workspace] No upstream remote found, falling back to local HEAD`);
+        return "HEAD";
+      }
+      /**
+       * Fetch latest from origin, resolve the upstream default branch, and return
+       * both the ref name and the resolved commit SHA.
+       */
+      async fetchAndResolveUpstream() {
+        logger.debug(`[Workspace] Fetching latest from origin`);
+        const fetchResult = await commandExecutor.execute(
+          `git -C ${shellEscape(this.originalPath)} fetch origin --prune 2>&1`,
+          { timeout: 12e4 }
+        );
+        if (fetchResult.exitCode !== 0) {
+          logger.warn(`[Workspace] fetch origin failed (will use cached refs): ${fetchResult.stderr}`);
+        }
+        const upstreamRef = await this.resolveUpstreamRef();
+        const shaResult = await commandExecutor.execute(
+          `git -C ${shellEscape(this.originalPath)} rev-parse ${shellEscape(upstreamRef)}`,
+          { timeout: 1e4 }
+        );
+        if (shaResult.exitCode === 0) {
+          return { upstreamRef, targetSha: shaResult.stdout.trim() };
+        }
+        logger.warn(
+          `[Workspace] Could not resolve ${upstreamRef} (${shaResult.stderr.trim()}), falling back to HEAD`
+        );
         const headResult = await commandExecutor.execute(
           `git -C ${shellEscape(this.originalPath)} rev-parse HEAD`,
-          {
-            timeout: 1e4
-          }
+          { timeout: 1e4 }
         );
         if (headResult.exitCode !== 0) {
-          throw new Error(`Failed to get HEAD: ${headResult.stderr}`);
+          throw new Error(`Repository has no commits \u2014 cannot create worktree: ${headResult.stderr}`);
+        }
+        return { upstreamRef: "HEAD", targetSha: headResult.stdout.trim() };
+      }
+      /**
+       * Reset a worktree to a specific commit and clean all modifications.
+       */
+      async resetAndCleanWorktree(worktreePath, targetSha) {
+        const escapedPath = shellEscape(worktreePath);
+        const escapedSha = shellEscape(targetSha);
+        const resetResult = await commandExecutor.execute(
+          `git -C ${escapedPath} reset --hard ${escapedSha}`,
+          { timeout: 1e4 }
+        );
+        if (resetResult.exitCode !== 0) {
+          logger.warn(`[Workspace] reset --hard failed: ${resetResult.stderr}`);
+        }
+        const cleanResult = await commandExecutor.execute(`git -C ${escapedPath} clean -fdx`, {
+          timeout: 3e4
+        });
+        if (cleanResult.exitCode !== 0) {
+          logger.warn(`[Workspace] clean -fdx failed: ${cleanResult.stderr}`);
+        }
+      }
+      /**
+       * Refresh an existing worktree to the latest upstream default branch
+       * and ensure it has no modified or untracked files.
+       */
+      async refreshWorktreeToUpstream(worktreePath) {
+        logger.info(`[Workspace] Refreshing worktree to latest upstream: ${worktreePath}`);
+        try {
+          const { upstreamRef, targetSha } = await this.fetchAndResolveUpstream();
+          const checkoutResult = await commandExecutor.execute(
+            `git -C ${shellEscape(worktreePath)} checkout --detach ${shellEscape(targetSha)}`,
+            { timeout: 3e4 }
+          );
+          if (checkoutResult.exitCode !== 0) {
+            logger.warn(
+              `[Workspace] checkout --detach failed (worktree stays at current commit): ${checkoutResult.stderr}`
+            );
+            await this.resetAndCleanWorktree(worktreePath, "HEAD");
+            return;
+          }
+          await this.resetAndCleanWorktree(worktreePath, targetSha);
+          logger.info(`[Workspace] Worktree updated to ${upstreamRef} (${targetSha.slice(0, 8)})`);
+        } catch (error) {
+          logger.warn(`[Workspace] Failed to refresh worktree (continuing with stale state): ${error}`);
         }
-        const headRef = headResult.stdout.trim();
-        const createCmd = `git -C ${shellEscape(this.originalPath)} worktree add --detach ${shellEscape(targetPath)} ${shellEscape(headRef)}`;
+      }
+      /**
+       * Create worktree for the main project.
+       * See visor-disable comment above resolveUpstreamRef for why this doesn't use WorktreeManager.
+       */
+      async createMainProjectWorktree(targetPath) {
+        logger.debug(`Creating main project worktree: ${targetPath}`);
+        const { upstreamRef, targetSha } = await this.fetchAndResolveUpstream();
+        const createCmd = `git -C ${shellEscape(this.originalPath)} worktree add --detach ${shellEscape(targetPath)} ${shellEscape(targetSha)}`;
         const result = await commandExecutor.execute(createCmd, { timeout: 6e4 });
         if (result.exitCode !== 0) {
           throw new Error(`Failed to create main project worktree: ${result.stderr}`);
         }
-        logger.debug(`Created main project worktree at ${targetPath}`);
+        await this.resetAndCleanWorktree(targetPath, targetSha);
+        logger.info(
+          `Created main project worktree at ${targetPath} (${upstreamRef} -> ${targetSha.slice(0, 8)})`
+        );
       }
       /**
        * Remove main project worktree
@@ -11486,7 +12397,7 @@ var init_workspace_manager = __esm({
        * Extract project name from path
        */
       extractProjectName(dirPath) {
-        return path5.basename(dirPath);
+        return path7.basename(dirPath);
       }
       /**
        * Extract repository name from owner/repo format
@@ -11641,6 +12552,9 @@ async function initializeWorkspace(context2) {
       process.env.VISOR_WORKSPACE_MAIN_PROJECT = info.mainProjectPath;
       process.env.VISOR_WORKSPACE_MAIN_PROJECT_NAME = info.mainProjectName;
       process.env.VISOR_ORIGINAL_WORKDIR = originalPath;
+      const basePath = workspaceConfig?.base_path || process.env.VISOR_WORKSPACE_PATH || "/tmp/visor-workspaces";
+      const existing = process.env.GIT_CEILING_DIRECTORIES;
+      process.env.GIT_CEILING_DIRECTORIES = existing ? `${existing}:${basePath}` : basePath;
     } catch {
     }
     logger.info(`[Workspace] Initialized workspace: ${info.workspacePath}`);
@@ -11717,8 +12631,8 @@ var init_summary = __esm({
 });
 
 // src/state-machine-execution-engine.ts
-import * as path6 from "path";
-import * as fs4 from "fs";
+import * as path8 from "path";
+import * as fs6 from "fs";
 function serializeRunState(state) {
   return {
     ...state,
@@ -11815,7 +12729,7 @@ var init_state_machine_execution_engine = __esm({
           try {
             const map = options?.webhookContext?.webhookData;
             if (map) {
-              const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-SCPM6DIT.mjs");
+              const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-DVQDGTOE.mjs");
               const reg = CheckProviderRegistry2.getInstance();
               const p = reg.getProvider("http_input");
               if (p && typeof p.setWebhookContext === "function") p.setWebhookContext(map);
@@ -11938,7 +12852,7 @@ var init_state_machine_execution_engine = __esm({
           tag_filter: tagFilter
         } : config;
         try {
-          const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-SCPM6DIT.mjs");
+          const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-DVQDGTOE.mjs");
           const registry = CheckProviderRegistry2.getInstance();
           registry.setCustomTools(configWithTagFilter.tools || {});
         } catch (error) {
@@ -12002,7 +12916,7 @@ var init_state_machine_execution_engine = __esm({
           try {
             const webhookData = this.executionContext?.webhookContext?.webhookData;
             if (webhookData instanceof Map) {
-              const { extractSlackContext: extractSlackContext2 } = await import("./schedule-tool-handler-KFYNV7HL.mjs");
+              const { extractSlackContext: extractSlackContext2 } = await import("./schedule-tool-handler-YUC6CAXX.mjs");
               const slackCtx = extractSlackContext2(webhookData);
               if (slackCtx) {
                 const payload = Array.from(webhookData.values())[0];
@@ -12031,7 +12945,7 @@ var init_state_machine_execution_engine = __esm({
         if (Array.isArray(configWithTagFilter.frontends) && configWithTagFilter.frontends.length > 0) {
           try {
             const { EventBus } = await import("./event-bus-5K3Y2FCS.mjs");
-            const { FrontendsHost } = await import("./host-GVR4UGZ3.mjs");
+            const { FrontendsHost } = await import("./host-H7IX4GBK.mjs");
             const bus = new EventBus();
             context2.eventBus = bus;
             frontendsHost = new FrontendsHost(bus, logger);
@@ -12132,9 +13046,9 @@ var init_state_machine_execution_engine = __esm({
                   }
                   const checkId = String(ev?.checkId || "unknown");
                   const threadKey = ev?.threadKey || (channel && threadTs ? `${channel}:${threadTs}` : "session");
-                  const baseDir = process.env.VISOR_SNAPSHOT_DIR || path6.resolve(process.cwd(), ".visor", "snapshots");
-                  fs4.mkdirSync(baseDir, { recursive: true });
-                  const filePath = path6.join(baseDir, `${threadKey}-${checkId}.json`);
+                  const baseDir = process.env.VISOR_SNAPSHOT_DIR || path8.resolve(process.cwd(), ".visor", "snapshots");
+                  fs6.mkdirSync(baseDir, { recursive: true });
+                  const filePath = path8.join(baseDir, `${threadKey}-${checkId}.json`);
                   await this.saveSnapshotToFile(filePath);
                   logger.info(`[Snapshot] Saved run snapshot: ${filePath}`);
                   try {
@@ -12275,7 +13189,7 @@ var init_state_machine_execution_engine = __esm({
        * Does not include secrets. Intended for debugging and future resume support.
        */
       async saveSnapshotToFile(filePath) {
-        const fs10 = await import("fs/promises");
+        const fs12 = await import("fs/promises");
         const ctx = this._lastContext;
         const runner = this._lastRunner;
         if (!ctx || !runner) {
@@ -12295,14 +13209,14 @@ var init_state_machine_execution_engine = __esm({
           journal: entries,
           requestedChecks: ctx.requestedChecks || []
         };
-        await fs10.writeFile(filePath, JSON.stringify(payload, null, 2), "utf8");
+        await fs12.writeFile(filePath, JSON.stringify(payload, null, 2), "utf8");
       }
       /**
        * Load a snapshot JSON from file and return it. Resume support can build on this.
        */
       async loadSnapshotFromFile(filePath) {
-        const fs10 = await import("fs/promises");
-        const raw = await fs10.readFile(filePath, "utf8");
+        const fs12 = await import("fs/promises");
+        const raw = await fs12.readFile(filePath, "utf8");
         return JSON.parse(raw);
       }
       /**
@@ -12381,9 +13295,9 @@ var init_state_machine_execution_engine = __esm({
        * @returns Array of failure condition evaluation results
        */
       async evaluateFailureConditions(checkName, reviewSummary, config, previousOutputs, authorAssociation) {
-        const { FailureConditionEvaluator: FailureConditionEvaluator2 } = await import("./failure-condition-evaluator-FHNZL2US.mjs");
+        const { FailureConditionEvaluator: FailureConditionEvaluator2 } = await import("./failure-condition-evaluator-IVCTD4BZ.mjs");
         const evaluator = new FailureConditionEvaluator2();
-        const { addEvent: addEvent3 } = await import("./trace-helpers-EHDZ42HH.mjs");
+        const { addEvent: addEvent3 } = await import("./trace-helpers-6ROJR7N3.mjs");
         const { addFailIfTriggered } = await import("./metrics-I6A7IHG4.mjs");
         const checkConfig = config.checks?.[checkName];
         if (!checkConfig) {
@@ -12609,6 +13523,13 @@ var init_state_machine_execution_engine = __esm({
 
 // src/scheduler/scheduler.ts
 import cron from "node-cron";
+function getScheduler(visorConfig, config) {
+  if (!schedulerInstance && visorConfig) {
+    schedulerInstance = new Scheduler(visorConfig, config);
+  }
+  return schedulerInstance;
+}
+var Scheduler, schedulerInstance;
 var init_scheduler = __esm({
   "src/scheduler/scheduler.ts"() {
     "use strict";
@@ -12616,6 +13537,1443 @@ var init_scheduler = __esm({
     init_schedule_parser();
     init_logger();
     init_state_machine_execution_engine();
+    Scheduler = class {
+      store;
+      visorConfig;
+      checkIntervalMs;
+      defaultTimezone;
+      checkInterval = null;
+      cronJobs = /* @__PURE__ */ new Map();
+      oneTimeTimeouts = /* @__PURE__ */ new Map();
+      running = false;
+      engine;
+      outputAdapters = /* @__PURE__ */ new Map();
+      executionContext = {};
+      contextEnricher;
+      // HA fields
+      haConfig;
+      nodeId;
+      heartbeatInterval = null;
+      heldLocks = /* @__PURE__ */ new Map();
+      // scheduleId → lockToken
+      constructor(visorConfig, config) {
+        this.visorConfig = visorConfig;
+        this.checkIntervalMs = config?.checkIntervalMs ?? 6e4;
+        this.defaultTimezone = config?.defaultTimezone ?? "UTC";
+        this.haConfig = config?.ha;
+        this.nodeId = config?.ha?.node_id || `${__require("os").hostname()}-${process.pid}`;
+        const storeConfig = {
+          path: config?.storagePath,
+          storage: config?.storage,
+          ha: config?.ha
+        };
+        this.store = ScheduleStore.getInstance(storeConfig, config?.limits);
+      }
+      /**
+       * Set the execution engine (called after construction to avoid circular deps)
+       */
+      setEngine(engine) {
+        this.engine = engine;
+      }
+      /**
+       * Set the execution context (e.g., Slack client) for workflow executions
+       */
+      setExecutionContext(context2) {
+        this.executionContext = { ...this.executionContext, ...context2 };
+      }
+      /**
+       * Register an output adapter for a specific type
+       */
+      registerOutputAdapter(adapter) {
+        this.outputAdapters.set(adapter.type, adapter);
+        logger.debug(`[Scheduler] Registered output adapter: ${adapter.type}`);
+      }
+      /**
+       * Register a context enricher for frontend-specific functionality
+       * This allows frontends to inject thread history, prompt state, etc.
+       */
+      registerContextEnricher(enricher) {
+        this.contextEnricher = enricher;
+        logger.debug("[Scheduler] Registered context enricher");
+      }
+      /**
+       * Get the schedule store instance
+       */
+      getStore() {
+        return this.store;
+      }
+      /**
+       * Cancel a schedule's in-memory job (cron or timeout).
+       * Called after deleting from DB to ensure the job doesn't fire again.
+       */
+      cancelSchedule(scheduleId) {
+        const cronJob = this.cronJobs.get(scheduleId);
+        if (cronJob) {
+          cronJob.stop();
+          this.cronJobs.delete(scheduleId);
+          logger.debug(`[Scheduler] Cancelled cron job for schedule ${scheduleId}`);
+          return;
+        }
+        const timeout = this.oneTimeTimeouts.get(scheduleId);
+        if (timeout) {
+          clearTimeout(timeout);
+          this.oneTimeTimeouts.delete(scheduleId);
+          logger.debug(`[Scheduler] Cancelled timeout for schedule ${scheduleId}`);
+        }
+      }
+      /**
+       * Start the scheduler
+       */
+      async start() {
+        if (this.running) {
+          logger.warn("[Scheduler] Already running");
+          return;
+        }
+        await this.store.initialize();
+        try {
+          await this.loadStaticCronJobs();
+        } catch (err) {
+          logger.error(
+            `[Scheduler] Failed to load static cron jobs: ${err instanceof Error ? err.message : err}`
+          );
+        }
+        try {
+          await this.restoreSchedules();
+        } catch (err) {
+          logger.error(
+            `[Scheduler] Failed to restore schedules: ${err instanceof Error ? err.message : err}`
+          );
+        }
+        this.checkInterval = setInterval(() => {
+          this.checkDueSchedules().catch((error) => {
+            logger.error(
+              `[Scheduler] Error checking due schedules: ${error instanceof Error ? error.message : "Unknown error"}`
+            );
+          });
+        }, this.checkIntervalMs);
+        if (this.haConfig?.enabled) {
+          this.startHeartbeat();
+        }
+        this.running = true;
+        logger.info("[Scheduler] Started");
+      }
+      /**
+       * Load and schedule static cron jobs from visor config
+       * These are defined in scheduler.cron section and always run regardless of permissions
+       */
+      async loadStaticCronJobs() {
+        const schedulerCfg = this.visorConfig.scheduler;
+        if (!schedulerCfg?.cron) {
+          return;
+        }
+        const cronJobs = schedulerCfg.cron;
+        let loadedCount = 0;
+        for (const [jobId, job] of Object.entries(cronJobs)) {
+          if (job.enabled === false) {
+            logger.debug(`[Scheduler] Static cron job '${jobId}' is disabled, skipping`);
+            continue;
+          }
+          try {
+            await this.scheduleStaticCronJob(jobId, job);
+            loadedCount++;
+          } catch (error) {
+            logger.error(
+              `[Scheduler] Failed to load static cron job '${jobId}': ${error instanceof Error ? error.message : "Unknown error"}`
+            );
+          }
+        }
+        if (loadedCount > 0) {
+          logger.info(`[Scheduler] Loaded ${loadedCount} static cron job(s) from config`);
+        }
+      }
+      /**
+       * Schedule a static cron job from config
+       */
+      async scheduleStaticCronJob(jobId, job) {
+        if (!cron.validate(job.schedule)) {
+          throw new Error(`Invalid cron expression: ${job.schedule}`);
+        }
+        const allChecks = Object.keys(this.visorConfig.checks || {});
+        if (!allChecks.includes(job.workflow)) {
+          throw new Error(`Workflow "${job.workflow}" not found in configuration`);
+        }
+        const internalId = `__static_cron__:${jobId}`;
+        const cronJob = cron.schedule(
+          job.schedule,
+          async () => {
+            logger.info(`[Scheduler] Executing static cron job '${jobId}': workflow="${job.workflow}"`);
+            await this.executeStaticCronJob(jobId, job);
+          },
+          {
+            scheduled: true,
+            timezone: job.timezone || this.defaultTimezone
+          }
+        );
+        this.cronJobs.set(internalId, cronJob);
+        try {
+          const nextRun = getNextRunTime(job.schedule, job.timezone || this.defaultTimezone);
+          const description = job.description ? ` (${job.description})` : "";
+          logger.debug(
+            `[Scheduler] Scheduled static cron job '${jobId}'${description}: ${job.schedule} \u2192 ${job.workflow}, next run: ${nextRun.toISOString()}`
+          );
+        } catch {
+        }
+      }
+      /**
+       * Execute a static cron job
+       */
+      async executeStaticCronJob(jobId, job) {
+        if (this.haConfig?.enabled) {
+          const ttl = this.haConfig.lock_ttl ?? 60;
+          const backend = this.store.getBackend();
+          const lockId = `__static_cron__:${jobId}`;
+          const lockToken = await backend.tryAcquireLock(lockId, this.nodeId, ttl);
+          if (!lockToken) {
+            logger.debug(`[Scheduler] Static cron job '${jobId}' locked by another node, skipping`);
+            return;
+          }
+          this.heldLocks.set(lockId, lockToken);
+          try {
+            await this.doExecuteStaticCronJob(jobId, job);
+          } finally {
+            await backend.releaseLock(lockId, lockToken);
+            this.heldLocks.delete(lockId);
+          }
+        } else {
+          await this.doExecuteStaticCronJob(jobId, job);
+        }
+      }
+      /**
+       * Internal: execute a static cron job (after lock is held in HA mode)
+       */
+      async doExecuteStaticCronJob(jobId, job) {
+        const startTime = Date.now();
+        let result;
+        const syntheticSchedule = {
+          id: `__static_cron__:${jobId}`,
+          creatorId: "system",
+          creatorContext: "config",
+          timezone: job.timezone || this.defaultTimezone,
+          schedule: job.schedule,
+          isRecurring: true,
+          originalExpression: job.schedule,
+          workflow: job.workflow,
+          workflowInputs: job.inputs,
+          outputContext: job.output ? {
+            type: job.output.type,
+            target: job.output.target,
+            threadId: job.output.thread_id
+          } : void 0,
+          status: "active",
+          createdAt: 0,
+          runCount: 0,
+          failureCount: 0
+        };
+        try {
+          const output = await this.executeWorkflow(syntheticSchedule);
+          result = {
+            success: true,
+            output,
+            executionTimeMs: Date.now() - startTime
+          };
+          logger.info(
+            `[Scheduler] Static cron job '${jobId}' completed in ${result.executionTimeMs}ms`
+          );
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : "Unknown error";
+          result = {
+            success: false,
+            error: errorMsg,
+            executionTimeMs: Date.now() - startTime
+          };
+          logger.error(`[Scheduler] Static cron job '${jobId}' failed: ${errorMsg}`);
+        }
+        await this.sendResult(syntheticSchedule, result);
+      }
+      /**
+       * Stop the scheduler
+       */
+      async stop() {
+        if (!this.running) {
+          return;
+        }
+        this.stopHeartbeat();
+        if (this.heldLocks.size > 0) {
+          const backend = this.store.getBackend();
+          for (const [scheduleId, lockToken] of this.heldLocks.entries()) {
+            await backend.releaseLock(scheduleId, lockToken).catch(() => {
+            });
+          }
+          this.heldLocks.clear();
+        }
+        if (this.checkInterval) {
+          clearInterval(this.checkInterval);
+          this.checkInterval = null;
+        }
+        for (const [id, job] of this.cronJobs.entries()) {
+          job.stop();
+          logger.debug(`[Scheduler] Stopped cron job for schedule ${id}`);
+        }
+        this.cronJobs.clear();
+        for (const [id, timeout] of this.oneTimeTimeouts.entries()) {
+          clearTimeout(timeout);
+          logger.debug(`[Scheduler] Cleared timeout for schedule ${id}`);
+        }
+        this.oneTimeTimeouts.clear();
+        await this.store.flush();
+        this.running = false;
+        logger.info("[Scheduler] Stopped");
+      }
+      /**
+       * Start the heartbeat timer for renewing HA locks
+       */
+      startHeartbeat() {
+        if (this.heartbeatInterval) return;
+        const intervalMs = (this.haConfig?.heartbeat_interval ?? 15) * 1e3;
+        this.heartbeatInterval = setInterval(async () => {
+          const backend = this.store.getBackend();
+          const ttl = this.haConfig?.lock_ttl ?? 60;
+          for (const [scheduleId, lockToken] of this.heldLocks.entries()) {
+            const renewed = await backend.renewLock(scheduleId, lockToken, ttl);
+            if (!renewed) {
+              logger.warn(`[Scheduler] Failed to renew lock for schedule ${scheduleId}, lock lost`);
+              this.heldLocks.delete(scheduleId);
+            }
+          }
+        }, intervalMs);
+        logger.debug(`[Scheduler] Heartbeat started (interval: ${intervalMs}ms)`);
+      }
+      /**
+       * Stop the heartbeat timer
+       */
+      stopHeartbeat() {
+        if (this.heartbeatInterval) {
+          clearInterval(this.heartbeatInterval);
+          this.heartbeatInterval = null;
+        }
+      }
+      /**
+       * Restore schedules from persistent storage
+       */
+      async restoreSchedules() {
+        const activeSchedules = await this.store.getActiveSchedulesAsync();
+        logger.info(`[Scheduler] Restoring ${activeSchedules.length} active schedules`);
+        for (const schedule of activeSchedules) {
+          try {
+            await this.scheduleExecution(schedule);
+          } catch (error) {
+            logger.error(
+              `[Scheduler] Failed to restore schedule ${schedule.id}: ${error instanceof Error ? error.message : "Unknown error"}`
+            );
+          }
+        }
+      }
+      /**
+       * Schedule a workflow for execution
+       */
+      async scheduleExecution(schedule) {
+        if (schedule.isRecurring) {
+          await this.scheduleRecurring(schedule);
+        } else {
+          await this.scheduleOneTime(schedule);
+        }
+      }
+      /**
+       * Schedule a recurring workflow using cron
+       */
+      async scheduleRecurring(schedule) {
+        if (!cron.validate(schedule.schedule)) {
+          logger.error(
+            `[Scheduler] Invalid cron expression for schedule ${schedule.id}: ${schedule.schedule}`
+          );
+          const existingJob2 = this.cronJobs.get(schedule.id);
+          if (existingJob2) {
+            existingJob2.stop();
+            this.cronJobs.delete(schedule.id);
+          }
+          await this.store.updateAsync(schedule.id, {
+            status: "failed",
+            lastError: "Invalid cron expression"
+          });
+          return;
+        }
+        const existingJob = this.cronJobs.get(schedule.id);
+        if (existingJob) {
+          existingJob.stop();
+        }
+        const job = cron.schedule(
+          schedule.schedule,
+          async () => {
+            await this.executeSchedule(schedule);
+          },
+          {
+            scheduled: true,
+            timezone: schedule.timezone || this.defaultTimezone
+          }
+        );
+        this.cronJobs.set(schedule.id, job);
+        try {
+          const nextRun = getNextRunTime(schedule.schedule, schedule.timezone);
+          await this.store.updateAsync(schedule.id, { nextRunAt: nextRun.getTime() });
+        } catch (error) {
+          logger.warn(
+            `[Scheduler] Could not compute next run time for ${schedule.id}: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+        logger.debug(`[Scheduler] Scheduled recurring execution ${schedule.id}: ${schedule.schedule}`);
+      }
+      /**
+       * Schedule a one-time workflow using setTimeout
+       */
+      async scheduleOneTime(schedule) {
+        const existingTimeout = this.oneTimeTimeouts.get(schedule.id);
+        if (existingTimeout) {
+          clearTimeout(existingTimeout);
+        }
+        if (!schedule.runAt) {
+          logger.error(`[Scheduler] One-time schedule ${schedule.id} has no runAt time`);
+          return;
+        }
+        const delayMs = schedule.runAt - Date.now();
+        if (delayMs <= 0) {
+          await this.executeSchedule(schedule);
+          return;
+        }
+        const timeout = setTimeout(async () => {
+          this.oneTimeTimeouts.delete(schedule.id);
+          await this.executeSchedule(schedule);
+        }, delayMs);
+        this.oneTimeTimeouts.set(schedule.id, timeout);
+        logger.debug(
+          `[Scheduler] Scheduled one-time execution ${schedule.id} for ${new Date(schedule.runAt).toISOString()}`
+        );
+      }
+      /**
+       * Check for and execute due schedules
+       */
+      async checkDueSchedules() {
+        const dueSchedules = await this.store.getDueSchedulesAsync();
+        for (const schedule of dueSchedules) {
+          if (this.cronJobs.has(schedule.id) || this.oneTimeTimeouts.has(schedule.id)) {
+            continue;
+          }
+          if (this.haConfig?.enabled) {
+            const ttl = this.haConfig.lock_ttl ?? 60;
+            const backend = this.store.getBackend();
+            const lockToken = await backend.tryAcquireLock(schedule.id, this.nodeId, ttl);
+            if (!lockToken) {
+              logger.debug(`[Scheduler] Schedule ${schedule.id} locked by another node, skipping`);
+              continue;
+            }
+            this.heldLocks.set(schedule.id, lockToken);
+            try {
+              await this.executeSchedule(schedule);
+            } finally {
+              await backend.releaseLock(schedule.id, lockToken);
+              this.heldLocks.delete(schedule.id);
+            }
+          } else {
+            await this.executeSchedule(schedule);
+          }
+        }
+      }
+      /**
+       * Execute a scheduled workflow
+       */
+      async executeSchedule(schedule) {
+        try {
+          const fresh = await this.store.getAsync(schedule.id);
+          if (!fresh || fresh.status !== "active") {
+            logger.info(
+              `[Scheduler] Schedule ${schedule.id} is no longer active (${fresh ? fresh.status : "deleted"}), skipping execution`
+            );
+            this.cancelSchedule(schedule.id);
+            return;
+          }
+        } catch {
+          logger.warn(
+            `[Scheduler] Could not verify schedule ${schedule.id} freshness, proceeding with execution`
+          );
+        }
+        const description = schedule.workflow || "reminder";
+        logger.info(`[Scheduler] Executing schedule ${schedule.id}: ${description}`);
+        const startTime = Date.now();
+        let result;
+        try {
+          const output = await this.executeWorkflow(schedule);
+          result = {
+            success: true,
+            output,
+            executionTimeMs: Date.now() - startTime
+          };
+          const now = Date.now();
+          await this.store.updateAsync(schedule.id, {
+            lastRunAt: now,
+            runCount: schedule.runCount + 1,
+            failureCount: 0,
+            // Reset on success
+            lastError: void 0
+          });
+          if (!schedule.isRecurring) {
+            await this.store.updateAsync(schedule.id, { status: "completed" });
+            await this.store.deleteAsync(schedule.id);
+            logger.info(`[Scheduler] One-time schedule ${schedule.id} completed and removed`);
+          } else {
+            try {
+              const nextRun = getNextRunTime(schedule.schedule, schedule.timezone);
+              await this.store.updateAsync(schedule.id, { nextRunAt: nextRun.getTime() });
+            } catch (err) {
+              logger.warn(
+                `[Scheduler] Failed to compute next run time for ${schedule.id}, pausing schedule: ${err instanceof Error ? err.message : err}`
+              );
+              await this.store.updateAsync(schedule.id, {
+                status: "paused",
+                lastError: `Failed to compute next run time: ${err instanceof Error ? err.message : err}`
+              });
+            }
+          }
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : "Unknown error";
+          result = {
+            success: false,
+            error: errorMsg,
+            executionTimeMs: Date.now() - startTime
+          };
+          await this.handleScheduleFailure(schedule, error);
+        }
+        await this.sendResult(schedule, result);
+      }
+      /**
+       * Helper to prepare execution environment - reduces duplication between workflow and reminder execution
+       */
+      prepareExecution(schedule, cliMessage) {
+        const config = JSON.parse(JSON.stringify(this.visorConfig));
+        const fronts = Array.isArray(config.frontends) ? config.frontends : [];
+        const hasSlackFrontend = fronts.some((f) => f && f.name === "slack");
+        if (!hasSlackFrontend && (cliMessage || schedule.outputContext?.type === "slack")) {
+          fronts.push({ name: "slack" });
+        }
+        config.frontends = fronts;
+        const engine = new StateMachineExecutionEngine();
+        const responseRef = {};
+        const responseCapture = (text) => {
+          responseRef.captured = text;
+          logger.debug(
+            `[Scheduler] Captured AI response for schedule ${schedule.id} (${text.length} chars)`
+          );
+        };
+        engine.setExecutionContext({
+          ...this.executionContext,
+          cliMessage,
+          responseCapture
+        });
+        return { engine, config, responseRef };
+      }
+      /**
+       * Execute the workflow for a schedule
+       */
+      async executeWorkflow(schedule) {
+        if (!schedule.workflow) {
+          return this.executeSimpleReminder(schedule);
+        }
+        if (!this.engine) {
+          logger.warn("[Scheduler] No execution engine set, skipping workflow execution");
+          return { message: "No execution engine configured" };
+        }
+        const allChecks = Object.keys(this.visorConfig.checks || {});
+        if (!allChecks.includes(schedule.workflow)) {
+          throw new Error(`Workflow "${schedule.workflow}" not found in configuration`);
+        }
+        const syntheticPayload = {
+          event: {
+            type: "schedule_triggered",
+            schedule_id: schedule.id,
+            workflow: schedule.workflow,
+            creator_id: schedule.creatorId,
+            creator_context: schedule.creatorContext,
+            timestamp: Date.now()
+          },
+          schedule: {
+            id: schedule.id,
+            workflow: schedule.workflow,
+            workflowInputs: schedule.workflowInputs,
+            isRecurring: schedule.isRecurring,
+            outputContext: schedule.outputContext
+          }
+        };
+        const webhookData = /* @__PURE__ */ new Map();
+        const endpoint = "/scheduler/trigger";
+        webhookData.set(endpoint, syntheticPayload);
+        try {
+          const { refreshGitHubCredentials } = await import("./github-auth-UPBBBOME.mjs");
+          await refreshGitHubCredentials();
+        } catch {
+        }
+        const { engine: runEngine, config: cfgForRun } = this.prepareExecution(schedule);
+        await runEngine.executeChecks({
+          checks: [schedule.workflow],
+          showDetails: true,
+          outputFormat: "json",
+          config: cfgForRun,
+          webhookContext: { webhookData, eventType: "schedule" },
+          debug: process.env.VISOR_DEBUG === "true",
+          inputs: schedule.workflowInputs
+        });
+        return { message: "Workflow completed", workflow: schedule.workflow };
+      }
+      /**
+       * Execute a simple reminder by running it through the visor pipeline
+       * Treats the reminder text as if the user sent it as a message
+       */
+      async executeSimpleReminder(schedule) {
+        const reminderText = schedule.workflowInputs?.text;
+        if (!reminderText) {
+          return { message: "Reminder!", type: "simple_reminder" };
+        }
+        const allChecks = Object.keys(this.visorConfig.checks || {});
+        if (allChecks.length === 0) {
+          logger.warn("[Scheduler] No checks configured, returning reminder text directly");
+          return { message: reminderText, type: "simple_reminder" };
+        }
+        logger.info(`[Scheduler] Running reminder through visor pipeline (${allChecks.length} checks)`);
+        const channel = schedule.outputContext?.target || "";
+        const threadId = schedule.outputContext?.threadId;
+        let threadMessages = [];
+        let additionalPayload = {};
+        if (this.contextEnricher?.enrichContext) {
+          try {
+            const enriched = await this.contextEnricher.enrichContext(schedule);
+            threadMessages = enriched.threadMessages || [];
+            additionalPayload = enriched.additionalPayload || {};
+            if (threadMessages.length > 0) {
+              logger.debug(
+                `[Scheduler] Context enricher provided ${threadMessages.length} thread messages`
+              );
+            }
+          } catch (error) {
+            logger.warn(
+              `[Scheduler] Context enrichment failed: ${error instanceof Error ? error.message : error}`
+            );
+          }
+        }
+        let contextualReminderText = reminderText;
+        if (schedule.isRecurring && schedule.previousResponse) {
+          contextualReminderText = `${reminderText}
+
+---
+**Previous Response (for context):**
+${schedule.previousResponse}
+---
+
+Please provide an updated response based on the reminder above. You may reference or build upon the previous response if relevant.`;
+        }
+        const conversationData = {
+          current: {
+            user: schedule.creatorName || schedule.creatorId,
+            text: contextualReminderText
+          },
+          messages: threadMessages.length > 0 ? [
+            ...threadMessages,
+            { user: schedule.creatorName || schedule.creatorId, text: contextualReminderText }
+          ] : [{ user: schedule.creatorName || schedule.creatorId, text: contextualReminderText }]
+        };
+        const syntheticPayload = {
+          event: {
+            type: "message",
+            subtype: "scheduled_reminder",
+            text: contextualReminderText,
+            user: schedule.creatorId,
+            channel,
+            ts: String(Date.now() / 1e3),
+            thread_ts: threadId
+          },
+          // Include both for compatibility (slack_conversation for existing checks, conversation for generic)
+          slack_conversation: conversationData,
+          conversation: conversationData,
+          // Include schedule context for any checks that need it
+          schedule: {
+            id: schedule.id,
+            isReminder: true,
+            creatorId: schedule.creatorId,
+            creatorContext: schedule.creatorContext,
+            previousResponse: schedule.previousResponse
+          },
+          // Merge any additional frontend-specific payload
+          ...additionalPayload
+        };
+        const endpoint = this.contextEnricher?.getWebhookEndpoint?.() || this.visorConfig.slack?.endpoint || "/bots/slack/support";
+        const webhookData = /* @__PURE__ */ new Map();
+        webhookData.set(endpoint, syntheticPayload);
+        if (this.contextEnricher?.prepareExecution) {
+          try {
+            await this.contextEnricher.prepareExecution(schedule, reminderText);
+          } catch (error) {
+            logger.warn(
+              `[Scheduler] Execution preparation failed: ${error instanceof Error ? error.message : error}`
+            );
+          }
+        }
+        try {
+          const { refreshGitHubCredentials } = await import("./github-auth-UPBBBOME.mjs");
+          await refreshGitHubCredentials();
+        } catch {
+        }
+        const {
+          engine: runEngine,
+          config: cfgForRun,
+          responseRef
+        } = this.prepareExecution(schedule, reminderText);
+        try {
+          await runEngine.executeChecks({
+            checks: allChecks,
+            showDetails: true,
+            outputFormat: "json",
+            config: cfgForRun,
+            webhookContext: { webhookData, eventType: "schedule" },
+            debug: process.env.VISOR_DEBUG === "true"
+          });
+          if (schedule.isRecurring && responseRef.captured) {
+            await this.store.updateAsync(schedule.id, { previousResponse: responseRef.captured });
+            logger.info(
+              `[Scheduler] Saved previousResponse for recurring schedule ${schedule.id} (${responseRef.captured.length} chars)`
+            );
+          }
+          return {
+            message: "Reminder processed through pipeline",
+            type: "pipeline_executed",
+            reminderText,
+            capturedResponse: responseRef.captured
+          };
+        } catch (error) {
+          logger.error(
+            `[Scheduler] Failed to run reminder through pipeline: ${error instanceof Error ? error.message : error}`
+          );
+          return { message: reminderText, type: "simple_reminder" };
+        }
+      }
+      /**
+       * Handle schedule execution failure
+       */
+      async handleScheduleFailure(schedule, error) {
+        const errorMsg = error instanceof Error ? error.message : "Unknown error";
+        logger.error(`[Scheduler] Schedule ${schedule.id} failed: ${errorMsg}`);
+        const newFailureCount = schedule.failureCount + 1;
+        await this.store.updateAsync(schedule.id, {
+          failureCount: newFailureCount,
+          lastError: errorMsg
+        });
+        if (newFailureCount >= 3) {
+          await this.store.updateAsync(schedule.id, { status: "failed" });
+          const job = this.cronJobs.get(schedule.id);
+          if (job) {
+            job.stop();
+            this.cronJobs.delete(schedule.id);
+          }
+          logger.warn(`[Scheduler] Schedule ${schedule.id} paused after 3 consecutive failures`);
+        }
+      }
+      /**
+       * Send execution result to the appropriate output adapter
+       */
+      async sendResult(schedule, result) {
+        const outputType = schedule.outputContext?.type || "none";
+        const adapter = this.outputAdapters.get(outputType);
+        if (!adapter) {
+          if (outputType !== "none") {
+            logger.warn(`[Scheduler] No output adapter registered for type: ${outputType}`);
+          }
+          return;
+        }
+        try {
+          await adapter.sendResult(schedule, result);
+        } catch (error) {
+          logger.error(
+            `[Scheduler] Failed to send result via ${outputType} adapter: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+      }
+      /**
+       * Check if scheduler is running
+       */
+      isRunning() {
+        return this.running;
+      }
+      /**
+       * Get scheduler stats
+       */
+      async getStats() {
+        return {
+          running: this.running,
+          activeCronJobs: this.cronJobs.size,
+          pendingOneTimeSchedules: this.oneTimeTimeouts.size,
+          storeStats: await this.store.getStatsAsync()
+        };
+      }
+    };
+  }
+});
+
+// src/scheduler/schedule-tool.ts
+function matchGlobPattern(pattern, value) {
+  const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${regexPattern}$`).test(value);
+}
+function isWorkflowAllowedByPatterns(workflow, allowedPatterns, deniedPatterns) {
+  if (deniedPatterns && deniedPatterns.length > 0) {
+    for (const pattern of deniedPatterns) {
+      if (matchGlobPattern(pattern, workflow)) {
+        return {
+          allowed: false,
+          reason: `Workflow "${workflow}" matches denied pattern "${pattern}"`
+        };
+      }
+    }
+  }
+  if (allowedPatterns && allowedPatterns.length > 0) {
+    for (const pattern of allowedPatterns) {
+      if (matchGlobPattern(pattern, workflow)) {
+        return { allowed: true };
+      }
+    }
+    return {
+      allowed: false,
+      reason: `Workflow "${workflow}" does not match any allowed patterns: ${allowedPatterns.join(", ")}`
+    };
+  }
+  return { allowed: true };
+}
+function checkSchedulePermissions(context2, workflow, requestedScheduleType) {
+  const permissions = context2.permissions;
+  const scheduleType = requestedScheduleType || context2.scheduleType || "personal";
+  if (context2.allowedScheduleType && scheduleType !== context2.allowedScheduleType) {
+    const contextNames = {
+      personal: "a direct message (DM)",
+      channel: "a channel",
+      dm: "a group DM"
+    };
+    const targetNames = {
+      personal: "personal",
+      channel: "channel",
+      dm: "group"
+    };
+    return {
+      allowed: false,
+      reason: `From ${contextNames[context2.allowedScheduleType]}, you can only create ${targetNames[context2.allowedScheduleType]} schedules. To create a ${targetNames[scheduleType]} schedule, please use the appropriate context.`
+    };
+  }
+  if (!permissions) {
+    return { allowed: true };
+  }
+  switch (scheduleType) {
+    case "personal":
+      if (permissions.allowPersonal === false) {
+        return {
+          allowed: false,
+          reason: "Personal schedules are not allowed in this configuration"
+        };
+      }
+      break;
+    case "channel":
+      if (permissions.allowChannel === false) {
+        return {
+          allowed: false,
+          reason: "Channel schedules are not allowed in this configuration"
+        };
+      }
+      break;
+    case "dm":
+      if (permissions.allowDm === false) {
+        return {
+          allowed: false,
+          reason: "DM schedules are not allowed in this configuration"
+        };
+      }
+      break;
+  }
+  return isWorkflowAllowedByPatterns(
+    workflow,
+    permissions.allowedWorkflows,
+    permissions.deniedWorkflows
+  );
+}
+function formatSchedule(schedule) {
+  const time = schedule.isRecurring ? schedule.originalExpression : new Date(schedule.runAt).toLocaleString();
+  const status = schedule.status !== "active" ? ` (${schedule.status})` : "";
+  const displayName = schedule.workflow || schedule.workflowInputs?.text || "scheduled message";
+  const truncatedName = displayName.length > 30 ? displayName.substring(0, 27) + "..." : displayName;
+  const output = schedule.outputContext?.type || "none";
+  return `\`${schedule.id.substring(0, 8)}\` - "${truncatedName}" - ${time} (\u2192 ${output})${status}`;
+}
+function formatCreateConfirmation(schedule) {
+  const outputDesc = schedule.outputContext?.type ? `${schedule.outputContext.type}${schedule.outputContext.target ? `:${schedule.outputContext.target}` : ""}` : "none";
+  const displayName = schedule.workflow || schedule.workflowInputs?.text || "scheduled message";
+  if (schedule.isRecurring) {
+    const nextRun = schedule.nextRunAt ? new Date(schedule.nextRunAt).toLocaleString("en-US", {
+      weekday: "long",
+      month: "short",
+      day: "numeric",
+      hour: "numeric",
+      minute: "2-digit"
+    }) : "calculating...";
+    return `**Schedule created!**
+
+**${schedule.workflow ? "Workflow" : "Reminder"}**: ${displayName}
+**When**: ${schedule.originalExpression}
+**Output**: ${outputDesc}
+**Next run**: ${nextRun}
+
+ID: \`${schedule.id.substring(0, 8)}\``;
+  } else {
+    const when = new Date(schedule.runAt).toLocaleString("en-US", {
+      weekday: "long",
+      month: "short",
+      day: "numeric",
+      hour: "numeric",
+      minute: "2-digit"
+    });
+    return `**Schedule created!**
+
+**${schedule.workflow ? "Workflow" : "Reminder"}**: ${displayName}
+**When**: ${when}
+**Output**: ${outputDesc}
+
+ID: \`${schedule.id.substring(0, 8)}\``;
+  }
+}
+function formatScheduleList(schedules) {
+  if (schedules.length === 0) {
+    return `You don't have any active schedules.
+
+To create one: "remind me every Monday at 9am to check PRs" or "schedule %daily-report every Monday at 9am"`;
+  }
+  const lines = schedules.map((s, i) => `${i + 1}. ${formatSchedule(s)}`);
+  return `**Your active schedules:**
+
+${lines.join("\n")}
+
+To cancel: "cancel schedule <id>"
+To pause: "pause schedule <id>"`;
+}
+async function handleScheduleAction(args, context2) {
+  const store = ScheduleStore.getInstance();
+  if (!store.isInitialized()) {
+    await store.initialize();
+  }
+  switch (args.action) {
+    case "create":
+      return handleCreate(args, context2, store);
+    case "list":
+      return handleList(context2, store);
+    case "cancel":
+      return handleCancel(args, context2, store);
+    case "pause":
+      return handlePauseResume(args, context2, store, "paused");
+    case "resume":
+      return handlePauseResume(args, context2, store, "active");
+    default:
+      return {
+        success: false,
+        message: `Unknown action: ${args.action}`,
+        error: `Supported actions: create, list, cancel, pause, resume`
+      };
+  }
+}
+async function handleCreate(args, context2, store) {
+  if (!args.reminder_text && !args.workflow) {
+    return {
+      success: false,
+      message: "Missing reminder content",
+      error: "Please specify either reminder_text (what to say) or workflow (what to run)"
+    };
+  }
+  if (!args.cron && !args.run_at) {
+    return {
+      success: false,
+      message: "Missing schedule timing",
+      error: 'Please specify either cron (for recurring, e.g., "* * * * *") or run_at (ISO timestamp for one-time)'
+    };
+  }
+  if (args.cron && !isValidCronExpression(args.cron)) {
+    return {
+      success: false,
+      message: "Invalid cron expression",
+      error: `"${args.cron}" is not a valid cron expression. Format: "minute hour day-of-month month day-of-week"`
+    };
+  }
+  let runAtTimestamp;
+  if (args.run_at) {
+    const parsed = new Date(args.run_at);
+    if (isNaN(parsed.getTime())) {
+      return {
+        success: false,
+        message: "Invalid run_at timestamp",
+        error: `"${args.run_at}" is not a valid ISO 8601 timestamp`
+      };
+    }
+    if (parsed.getTime() <= Date.now()) {
+      return {
+        success: false,
+        message: "run_at must be in the future",
+        error: "Cannot schedule a reminder in the past"
+      };
+    }
+    runAtTimestamp = parsed.getTime();
+  }
+  if (args.target_type && !args.target_id) {
+    return {
+      success: false,
+      message: "Missing target_id",
+      error: `target_type "${args.target_type}" requires a target_id (channel ID, user ID, or thread_ts)`
+    };
+  }
+  let scheduleType = "personal";
+  if (args.target_type === "channel") {
+    scheduleType = "channel";
+  } else if (args.target_type === "user") {
+    scheduleType = "dm";
+  }
+  const workflowName = args.workflow || "reminder";
+  const permissionCheck = checkSchedulePermissions(context2, workflowName, scheduleType);
+  if (!permissionCheck.allowed) {
+    logger.warn(
+      `[ScheduleTool] Permission denied for user ${context2.userId}: ${permissionCheck.reason}`
+    );
+    return {
+      success: false,
+      message: "Permission denied",
+      error: permissionCheck.reason || "You do not have permission to create this schedule"
+    };
+  }
+  if (args.workflow && context2.availableWorkflows && !context2.availableWorkflows.includes(args.workflow)) {
+    return {
+      success: false,
+      message: `Workflow "${args.workflow}" not found`,
+      error: `Available workflows: ${context2.availableWorkflows.slice(0, 5).join(", ")}${context2.availableWorkflows.length > 5 ? "..." : ""}`
+    };
+  }
+  try {
+    const timezone = context2.timezone || "UTC";
+    const isRecurring = args.is_recurring === true || !!args.cron;
+    let outputContext;
+    if (args.target_type && args.target_id) {
+      outputContext = {
+        type: "slack",
+        // Currently only Slack supported
+        target: args.target_id,
+        // Channel ID (C... or D...)
+        threadId: args.thread_ts,
+        // Thread timestamp for replies
+        metadata: {
+          targetType: args.target_type,
+          reminderText: args.reminder_text
+        }
+      };
+    }
+    let nextRunAt;
+    if (isRecurring && args.cron) {
+      nextRunAt = getNextRunTime(args.cron, timezone).getTime();
+    } else if (runAtTimestamp) {
+      nextRunAt = runAtTimestamp;
+    }
+    const schedule = await store.createAsync({
+      creatorId: context2.userId,
+      creatorContext: context2.contextType,
+      creatorName: context2.userName,
+      timezone,
+      schedule: args.cron || "",
+      runAt: runAtTimestamp,
+      isRecurring,
+      originalExpression: args.original_expression || args.cron || args.run_at || "",
+      workflow: args.workflow,
+      // Only set if explicitly provided
+      workflowInputs: args.workflow_inputs || (args.reminder_text ? { text: args.reminder_text } : void 0),
+      outputContext,
+      nextRunAt
+    });
+    const displayText = args.reminder_text || args.workflow || "scheduled task";
+    logger.info(
+      `[ScheduleTool] Created schedule ${schedule.id} for user ${context2.userId}: "${displayText}"`
+    );
+    return {
+      success: true,
+      message: formatCreateConfirmation(schedule),
+      schedule
+    };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : "Unknown error";
+    logger.warn(`[ScheduleTool] Failed to create schedule: ${errorMsg}`);
+    return {
+      success: false,
+      message: `Failed to create schedule: ${errorMsg}`,
+      error: errorMsg
+    };
+  }
+}
+async function handleList(context2, store) {
+  const allUserSchedules = await store.getByCreatorAsync(context2.userId);
+  const schedules = allUserSchedules.filter((s) => s.status !== "completed");
+  let filteredSchedules = schedules;
+  if (context2.allowedScheduleType) {
+    filteredSchedules = schedules.filter((s) => {
+      const scheduleOutputType = s.outputContext?.type;
+      if (!scheduleOutputType || scheduleOutputType === "none") {
+        return context2.allowedScheduleType === "personal";
+      }
+      if (scheduleOutputType === "slack") {
+        const target = s.outputContext?.target || "";
+        if (target.startsWith("#") || target.match(/^C[A-Z0-9]+$/)) {
+          return context2.allowedScheduleType === "channel";
+        }
+        if (target.startsWith("@") || target.match(/^U[A-Z0-9]+$/)) {
+          return context2.allowedScheduleType === "dm";
+        }
+      }
+      return context2.allowedScheduleType === "personal";
+    });
+  }
+  return {
+    success: true,
+    message: formatScheduleList(filteredSchedules),
+    schedules: filteredSchedules
+  };
+}
+async function handleCancel(args, context2, store) {
+  let schedule;
+  if (args.schedule_id) {
+    const userSchedules = await store.getByCreatorAsync(context2.userId);
+    schedule = userSchedules.find((s) => s.id === args.schedule_id);
+    if (!schedule) {
+      schedule = userSchedules.find((s) => s.id.startsWith(args.schedule_id));
+    }
+  }
+  if (!schedule) {
+    return {
+      success: false,
+      message: "Schedule not found",
+      error: `Could not find schedule with ID "${args.schedule_id}" in your schedules. Use "list my schedules" to see your schedules.`
+    };
+  }
+  if (schedule.creatorId !== context2.userId) {
+    logger.warn(
+      `[ScheduleTool] Attempted cross-user schedule cancellation: ${context2.userId} tried to cancel ${schedule.id} owned by ${schedule.creatorId}`
+    );
+    return {
+      success: false,
+      message: "Not your schedule",
+      error: "You can only cancel your own schedules."
+    };
+  }
+  await store.deleteAsync(schedule.id);
+  const scheduler = getScheduler();
+  if (scheduler) {
+    scheduler.cancelSchedule(schedule.id);
+  }
+  logger.info(`[ScheduleTool] Cancelled schedule ${schedule.id} for user ${context2.userId}`);
+  return {
+    success: true,
+    message: `**Schedule cancelled!**
+
+Was: "${schedule.workflow}" scheduled for ${schedule.originalExpression}`
+  };
+}
+async function handlePauseResume(args, context2, store, newStatus) {
+  if (!args.schedule_id) {
+    return {
+      success: false,
+      message: "Missing schedule ID",
+      error: "Please specify which schedule to pause/resume."
+    };
+  }
+  const userSchedules = await store.getByCreatorAsync(context2.userId);
+  let schedule = userSchedules.find((s) => s.id === args.schedule_id);
+  if (!schedule) {
+    schedule = userSchedules.find((s) => s.id.startsWith(args.schedule_id));
+  }
+  if (!schedule) {
+    return {
+      success: false,
+      message: "Schedule not found",
+      error: `Could not find schedule with ID "${args.schedule_id}" in your schedules.`
+    };
+  }
+  if (schedule.creatorId !== context2.userId) {
+    logger.warn(
+      `[ScheduleTool] Attempted cross-user schedule modification: ${context2.userId} tried to modify ${schedule.id} owned by ${schedule.creatorId}`
+    );
+    return {
+      success: false,
+      message: "Not your schedule",
+      error: "You can only modify your own schedules."
+    };
+  }
+  const updated = await store.updateAsync(schedule.id, { status: newStatus });
+  const action = newStatus === "paused" ? "paused" : "resumed";
+  logger.info(`[ScheduleTool] ${action} schedule ${schedule.id} for user ${context2.userId}`);
+  return {
+    success: true,
+    message: `**Schedule ${action}!**
+
+"${schedule.workflow}" - ${schedule.originalExpression}`,
+    schedule: updated
+  };
+}
+function getScheduleToolDefinition() {
+  return {
+    name: "schedule",
+    description: `Schedule, list, and manage reminders or workflow executions.
+
+YOU (the AI) must extract and structure all scheduling parameters. Do NOT pass natural language time expressions - convert them to cron or ISO timestamps.
+
+CRITICAL WORKFLOW RULE:
+- To schedule a WORKFLOW, the user MUST use a '%' prefix (e.g., "schedule %my-workflow daily").
+- If the '%' prefix is present, extract the word following it as the 'workflow' parameter (without the '%').
+- If the '%' prefix is NOT present, the request is a simple text reminder. The ENTIRE user request (excluding the schedule expression) MUST be placed in the 'reminder_text' parameter.
+- DO NOT guess or infer a workflow name from a user's request without the '%' prefix.
+
+ACTIONS:
+- create: Schedule a new reminder or workflow
+- list: Show user's active schedules
+- cancel: Remove a schedule by ID
+- pause/resume: Temporarily disable/enable a schedule
+
+FOR CREATE ACTION - Extract these from user's request:
+1. WHAT:
+   - If user says "schedule %some-workflow ...", populate 'workflow' with "some-workflow".
+   - Otherwise, populate 'reminder_text' with the user's full request text.
+2. WHERE: Use the CURRENT channel from context
+   - target_id: The channel ID from context (C... for channels, D... for DMs)
+   - target_type: "channel" for public/private channels, "dm" for direct messages
+   - ONLY use target_type="thread" with thread_ts if user is INSIDE a thread
+   - When NOT in a thread, reminders post as NEW messages (not thread replies)
+3. WHEN: Either cron (for recurring) OR run_at (ISO 8601 for one-time)
+   - Recurring: Generate cron expression (minute hour day-of-month month day-of-week)
+   - One-time: Generate ISO 8601 timestamp
+
+CRON EXAMPLES:
+- "every minute" \u2192 cron: "* * * * *"
+- "every hour" \u2192 cron: "0 * * * *"
+- "every day at 9am" \u2192 cron: "0 9 * * *"
+- "every Monday at 9am" \u2192 cron: "0 9 * * 1"
+- "weekdays at 8:30am" \u2192 cron: "30 8 * * 1-5"
+- "every 5 minutes" \u2192 cron: "*/5 * * * *"
+
+ONE-TIME EXAMPLES:
+- "in 2 hours" \u2192 run_at: "<ISO timestamp 2 hours from now>"
+- "tomorrow at 3pm" \u2192 run_at: "2026-02-08T15:00:00Z"
+
+USAGE EXAMPLES:
+
+User in DM: "remind me to check builds every day at 9am"
+\u2192 {
+    "action": "create",
+    "reminder_text": "check builds",
+    "is_recurring": true,
+    "cron": "0 9 * * *",
+    "target_type": "dm",
+    "target_id": "<DM channel ID from context, e.g., D09SZABNLG3>",
+    "original_expression": "every day at 9am"
+  }
+
+User in #security channel: "schedule %security-scan every Monday at 10am"
+\u2192 {
+    "action": "create",
+    "workflow": "security-scan",
+    "is_recurring": true,
+    "cron": "0 10 * * 1",
+    "target_type": "channel",
+    "target_id": "<channel ID from context, e.g., C05ABC123>",
+    "original_expression": "every Monday at 10am"
+  }
+
+User in #security channel: "run security-scan every Monday at 10am" (NO % prefix!)
+\u2192 {
+    "action": "create",
+    "reminder_text": "run security-scan every Monday at 10am",
+    "is_recurring": true,
+    "cron": "0 10 * * 1",
+    "target_type": "channel",
+    "target_id": "<channel ID from context, e.g., C05ABC123>",
+    "original_expression": "every Monday at 10am"
+  }
+
+User in DM: "remind me in 2 hours to review the PR"
+\u2192 {
+    "action": "create",
+    "reminder_text": "review the PR",
+    "is_recurring": false,
+    "run_at": "2026-02-07T18:00:00Z",
+    "target_type": "dm",
+    "target_id": "<DM channel ID from context>",
+    "original_expression": "in 2 hours"
+  }
+
+User inside a thread: "remind me about this tomorrow"
+\u2192 {
+    "action": "create",
+    "reminder_text": "Check this thread",
+    "is_recurring": false,
+    "run_at": "2026-02-08T09:00:00Z",
+    "target_type": "thread",
+    "target_id": "<channel ID>",
+    "thread_ts": "<thread_ts from context>",
+    "original_expression": "tomorrow"
+  }
+
+User: "list my schedules"
+\u2192 { "action": "list" }
+
+User: "cancel schedule abc123"
+\u2192 { "action": "cancel", "schedule_id": "abc123" }`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["create", "list", "cancel", "pause", "resume"],
+          description: "What to do: create new, list existing, cancel/pause/resume by ID"
+        },
+        // WHAT to do
+        reminder_text: {
+          type: "string",
+          description: "For create: the message/reminder text to send when triggered"
+        },
+        workflow: {
+          type: "string",
+          description: 'For create: workflow ID to run. ONLY populate this if the user used the % prefix (e.g., "%my-workflow"). Extract the name without the % symbol. If no % prefix, use reminder_text instead.'
+        },
+        workflow_inputs: {
+          type: "object",
+          description: "For create: optional inputs to pass to the workflow"
+        },
+        // WHERE to send
+        target_type: {
+          type: "string",
+          enum: ["channel", "dm", "thread", "user"],
+          description: "For create: where to send output. channel=public/private channel, dm=DM to self (current DM channel), user=DM to specific user, thread=reply in current thread"
+        },
+        target_id: {
+          type: "string",
+          description: "For create: Slack channel ID. Channels start with C, DMs start with D. Always use the channel ID from the current context."
+        },
+        thread_ts: {
+          type: "string",
+          description: "For create with target_type=thread: the thread timestamp to reply to. Get this from the current thread context."
+        },
+        // WHEN to run
+        is_recurring: {
+          type: "boolean",
+          description: "For create: true for recurring schedules (cron), false for one-time (run_at)"
+        },
+        cron: {
+          type: "string",
+          description: 'For create recurring: cron expression (minute hour day-of-month month day-of-week). Examples: "0 9 * * *" (daily 9am), "* * * * *" (every minute), "0 9 * * 1" (Mondays 9am)'
+        },
+        run_at: {
+          type: "string",
+          description: 'For create one-time: ISO 8601 timestamp when to run (e.g., "2026-02-07T15:00:00Z")'
+        },
+        original_expression: {
+          type: "string",
+          description: "For create: the original natural language expression from user (for display only)"
+        },
+        // For cancel/pause/resume
+        schedule_id: {
+          type: "string",
+          description: "For cancel/pause/resume: the schedule ID to act on (first 8 chars is enough)"
+        }
+      },
+      required: ["action"]
+    },
+    exec: ""
+    // Not used - this tool has a custom handler
+  };
+}
+function isScheduleTool(toolName) {
+  return toolName === "schedule";
+}
+function determineScheduleType(contextType, outputType, outputTarget) {
+  if (outputType === "slack" && outputTarget) {
+    if (outputTarget.startsWith("#") || outputTarget.match(/^C[A-Z0-9]+$/)) {
+      return "channel";
+    }
+    if (outputTarget.startsWith("@") || outputTarget.match(/^U[A-Z0-9]+$/)) {
+      return "dm";
+    }
+  }
+  if (contextType === "cli" || contextType.startsWith("github:")) {
+    return "personal";
+  }
+  return "personal";
+}
+function slackChannelTypeToScheduleType(channelType) {
+  switch (channelType) {
+    case "channel":
+      return "channel";
+    case "group":
+      return "dm";
+    // Group DMs map to 'dm' schedule type
+    case "dm":
+    default:
+      return "personal";
+  }
+}
+function buildScheduleToolContext(sources, availableWorkflows, permissions, outputInfo) {
+  if (sources.slackContext) {
+    const contextType = `slack:${sources.slackContext.userId}`;
+    const scheduleType = determineScheduleType(
+      contextType,
+      outputInfo?.outputType,
+      outputInfo?.outputTarget
+    );
+    let allowedScheduleType;
+    if (sources.slackContext.channelType) {
+      allowedScheduleType = slackChannelTypeToScheduleType(sources.slackContext.channelType);
+    }
+    let finalScheduleType = scheduleType;
+    if (!outputInfo?.outputType && sources.slackContext.channelType) {
+      finalScheduleType = slackChannelTypeToScheduleType(sources.slackContext.channelType);
+    }
+    return {
+      userId: sources.slackContext.userId,
+      userName: sources.slackContext.userName,
+      contextType,
+      timezone: sources.slackContext.timezone,
+      availableWorkflows,
+      scheduleType: finalScheduleType,
+      permissions,
+      allowedScheduleType
+    };
+  }
+  if (sources.githubContext) {
+    return {
+      userId: sources.githubContext.login,
+      contextType: `github:${sources.githubContext.login}`,
+      timezone: "UTC",
+      // GitHub doesn't provide timezone
+      availableWorkflows,
+      scheduleType: "personal",
+      permissions,
+      allowedScheduleType: "personal"
+      // GitHub context only allows personal schedules
+    };
+  }
+  return {
+    userId: sources.cliContext?.userId || process.env.USER || "cli-user",
+    contextType: "cli",
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC",
+    availableWorkflows,
+    scheduleType: "personal",
+    permissions,
+    allowedScheduleType: "personal"
+    // CLI context only allows personal schedules
+  };
+}
+var init_schedule_tool = __esm({
+  "src/scheduler/schedule-tool.ts"() {
+    init_schedule_store();
+    init_schedule_parser();
+    init_scheduler();
+    init_logger();
   }
 });
 
@@ -13489,6 +15847,13 @@ var init_mcp_custom_sse_server = __esm({
 // src/utils/tool-resolver.ts
 function resolveTools(toolItems, globalTools, logPrefix = "[ToolResolver]") {
   const tools = /* @__PURE__ */ new Map();
+  const registry = WorkflowRegistry.getInstance();
+  const registeredWorkflows = registry.list().map((w) => w.id);
+  if (toolItems.some((item) => typeof item !== "string" && isWorkflowToolReference(item))) {
+    logger.info(
+      `${logPrefix} Resolving ${toolItems.length} tool items. WorkflowRegistry has ${registeredWorkflows.length} workflows: [${registeredWorkflows.join(", ")}]`
+    );
+  }
   for (const item of toolItems) {
     const workflowTool = resolveWorkflowToolFromItem(item);
     if (workflowTool) {
@@ -13505,7 +15870,9 @@ function resolveTools(toolItems, globalTools, logPrefix = "[ToolResolver]") {
       }
       logger.warn(`${logPrefix} Tool '${item}' not found in global tools or workflow registry`);
     } else if (isWorkflowToolReference(item)) {
-      logger.warn(`${logPrefix} Workflow '${item.workflow}' referenced but not found in registry`);
+      logger.warn(
+        `${logPrefix} Workflow '${item.workflow}' referenced but not found in registry. Available: [${registeredWorkflows.join(", ")}]`
+      );
     }
   }
   if (tools.size === 0 && toolItems.length > 0 && !globalTools) {
@@ -13519,13 +15886,14 @@ var init_tool_resolver = __esm({
   "src/utils/tool-resolver.ts"() {
     "use strict";
     init_workflow_tool_executor();
+    init_workflow_registry();
     init_logger();
   }
 });
 
 // src/providers/ai-check-provider.ts
-import fs5 from "fs/promises";
-import path7 from "path";
+import fs7 from "fs/promises";
+import path9 from "path";
 var AICheckProvider;
 var init_ai_check_provider = __esm({
   "src/providers/ai-check-provider.ts"() {
@@ -13699,7 +16067,7 @@ var init_ai_check_provider = __esm({
         const hasFileExtension = /\.[a-zA-Z0-9]{1,10}$/i.test(str);
         const hasPathSeparators = /[\/\\]/.test(str);
         const isRelativePath = /^\.{1,2}\//.test(str);
-        const isAbsolutePath = path7.isAbsolute(str);
+        const isAbsolutePath = path9.isAbsolute(str);
         const hasTypicalFileChars = /^[a-zA-Z0-9._\-\/\\:~]+$/.test(str);
         if (!(hasFileExtension || isRelativePath || isAbsolutePath || hasPathSeparators)) {
           return false;
@@ -13709,14 +16077,14 @@ var init_ai_check_provider = __esm({
         }
         try {
           let resolvedPath;
-          if (path7.isAbsolute(str)) {
-            resolvedPath = path7.normalize(str);
+          if (path9.isAbsolute(str)) {
+            resolvedPath = path9.normalize(str);
           } else {
-            resolvedPath = path7.resolve(process.cwd(), str);
+            resolvedPath = path9.resolve(process.cwd(), str);
           }
-          const fs10 = __require("fs").promises;
+          const fs12 = __require("fs").promises;
           try {
-            const stat2 = await fs10.stat(resolvedPath);
+            const stat2 = await fs12.stat(resolvedPath);
             return stat2.isFile();
           } catch {
             return hasFileExtension && (isRelativePath || isAbsolutePath || hasPathSeparators);
@@ -13733,14 +16101,14 @@ var init_ai_check_provider = __esm({
           throw new Error("Prompt file must have .liquid extension");
         }
         let resolvedPath;
-        if (path7.isAbsolute(promptPath)) {
+        if (path9.isAbsolute(promptPath)) {
           resolvedPath = promptPath;
         } else {
-          resolvedPath = path7.resolve(process.cwd(), promptPath);
+          resolvedPath = path9.resolve(process.cwd(), promptPath);
         }
-        if (!path7.isAbsolute(promptPath)) {
-          const normalizedPath = path7.normalize(resolvedPath);
-          const currentDir = path7.resolve(process.cwd());
+        if (!path9.isAbsolute(promptPath)) {
+          const normalizedPath = path9.normalize(resolvedPath);
+          const currentDir = path9.resolve(process.cwd());
           if (!normalizedPath.startsWith(currentDir)) {
             throw new Error("Invalid prompt file path: path traversal detected");
           }
@@ -13749,7 +16117,7 @@ var init_ai_check_provider = __esm({
           throw new Error("Invalid prompt file path: path traversal detected");
         }
         try {
-          const promptContent = await fs5.readFile(resolvedPath, "utf-8");
+          const promptContent = await fs7.readFile(resolvedPath, "utf-8");
           return promptContent;
         } catch (error) {
           throw new Error(
@@ -14322,10 +16690,41 @@ ${preview}`);
             if (Object.keys(dynamicServers).length > 0) {
               Object.assign(mcpServers, dynamicServers);
             }
+            try {
+              const span = trace.getSpan(context.active());
+              if (span) {
+                span.addEvent("tool_setup.mcp_servers_js", {
+                  "tool_setup.server_count": Object.keys(dynamicServers).length,
+                  "tool_setup.server_names": Object.keys(dynamicServers).join(","),
+                  "tool_setup.workflow_entries": Object.entries(dynamicServers).filter(([, cfg]) => cfg?.workflow).map(([name, cfg]) => `${name}\u2192${cfg.workflow}`).join(",")
+                });
+              }
+            } catch {
+            }
           } catch (error) {
-            logger.error(
-              `[AICheckProvider] Failed to evaluate ai_mcp_servers_js: ${error instanceof Error ? error.message : "Unknown error"}`
-            );
+            const errMsg = error instanceof Error ? error.message : "Unknown error";
+            logger.error(`[AICheckProvider] Failed to evaluate ai_mcp_servers_js: ${errMsg}`);
+            try {
+              const span = trace.getSpan(context.active());
+              if (span) {
+                span.addEvent("tool_setup.mcp_servers_js_error", {
+                  "tool_setup.error": errMsg
+                });
+              }
+            } catch {
+            }
+          }
+        } else if (mcpServersJsExpr && !_dependencyResults) {
+          try {
+            const span = trace.getSpan(context.active());
+            if (span) {
+              span.addEvent("tool_setup.mcp_servers_js_skipped", {
+                "tool_setup.reason": "no_dependency_results",
+                "tool_setup.has_expr": true,
+                "tool_setup.has_deps": false
+              });
+            }
+          } catch {
           }
         }
         for (const serverConfig of Object.values(mcpServers)) {
@@ -14463,6 +16862,27 @@ ${preview}`);
           }
           try {
             const customTools = this.loadCustomTools(customToolsToLoad, config);
+            try {
+              const span = trace.getSpan(context.active());
+              if (span) {
+                const requestedNames = customToolsToLoad.map(
+                  (item) => typeof item === "string" ? item : `${item.name || item.workflow}(wf:${item.workflow})`
+                );
+                span.addEvent("tool_setup.resolution", {
+                  "tool_setup.requested_count": customToolsToLoad.length,
+                  "tool_setup.requested_names": requestedNames.join(","),
+                  "tool_setup.resolved_count": customTools.size,
+                  "tool_setup.resolved_names": Array.from(customTools.keys()).join(","),
+                  "tool_setup.missing_count": customToolsToLoad.length - customTools.size
+                });
+              }
+            } catch {
+            }
+            if (customToolsToLoad.length > 0 && customTools.size === 0) {
+              logger.warn(
+                `[AICheckProvider] All ${customToolsToLoad.length} custom tools failed to resolve! Requested: ${customToolsToLoad.map((item) => typeof item === "string" ? item : item.workflow).join(", ")}. AI will have no workflow tools available.`
+              );
+            }
             if (scheduleToolEnabled) {
               const scheduleTool = getScheduleToolDefinition();
               customTools.set(scheduleTool.name, scheduleTool);
@@ -14500,11 +16920,35 @@ ${preview}`);
               };
             }
           } catch (error) {
+            const errMsg = error instanceof Error ? error.message : "Unknown error";
             logger.error(
-              `[AICheckProvider] Failed to start custom tools SSE server '${customToolsServerName}': ${error instanceof Error ? error.message : "Unknown error"}`
+              `[AICheckProvider] Failed to start custom tools SSE server '${customToolsServerName}': ${errMsg}`
             );
+            try {
+              const span = trace.getSpan(context.active());
+              if (span) {
+                span.addEvent("tool_setup.sse_server_error", {
+                  "tool_setup.error": errMsg,
+                  "tool_setup.server_name": customToolsServerName || ""
+                });
+              }
+            } catch {
+            }
           }
         }
+        try {
+          const span = trace.getSpan(context.active());
+          if (span) {
+            const finalServerNames = Object.keys(mcpServers);
+            span.addEvent("tool_setup.final", {
+              "tool_setup.final_server_count": finalServerNames.length,
+              "tool_setup.final_server_names": finalServerNames.join(","),
+              "tool_setup.has_custom_tools_server": !!customToolsServer,
+              "tool_setup.tools_disabled": !!config.ai?.disableTools
+            });
+          }
+        } catch {
+        }
         if (Object.keys(mcpServers).length > 0 && !config.ai?.disableTools) {
           aiConfig.mcpServers = mcpServers;
         } else if (config.ai?.disableTools) {
@@ -15703,8 +18147,8 @@ var init_template_context = __esm({
 });
 
 // src/providers/http-client-provider.ts
-import * as fs6 from "fs";
-import * as path8 from "path";
+import * as fs8 from "fs";
+import * as path10 from "path";
 var HttpClientProvider;
 var init_http_client_provider = __esm({
   "src/providers/http-client-provider.ts"() {
@@ -15809,14 +18253,14 @@ var init_http_client_provider = __esm({
             const parentContext = context2?._parentContext;
             const workingDirectory = parentContext?.workingDirectory;
             const workspaceEnabled = parentContext?.workspace?.isEnabled?.();
-            if (workspaceEnabled && workingDirectory && !path8.isAbsolute(resolvedOutputFile)) {
-              resolvedOutputFile = path8.join(workingDirectory, resolvedOutputFile);
+            if (workspaceEnabled && workingDirectory && !path10.isAbsolute(resolvedOutputFile)) {
+              resolvedOutputFile = path10.join(workingDirectory, resolvedOutputFile);
               logger.debug(
                 `[http_client] Resolved relative output_file to workspace: ${resolvedOutputFile}`
               );
             }
-            if (skipIfExists && fs6.existsSync(resolvedOutputFile)) {
-              const stats = fs6.statSync(resolvedOutputFile);
+            if (skipIfExists && fs8.existsSync(resolvedOutputFile)) {
+              const stats = fs8.statSync(resolvedOutputFile);
               logger.verbose(`[http_client] File cached: ${resolvedOutputFile} (${stats.size} bytes)`);
               return {
                 issues: [],
@@ -16027,13 +18471,13 @@ var init_http_client_provider = __esm({
               ]
             };
           }
-          const parentDir = path8.dirname(outputFile);
-          if (parentDir && !fs6.existsSync(parentDir)) {
-            fs6.mkdirSync(parentDir, { recursive: true });
+          const parentDir = path10.dirname(outputFile);
+          if (parentDir && !fs8.existsSync(parentDir)) {
+            fs8.mkdirSync(parentDir, { recursive: true });
           }
           const arrayBuffer = await response.arrayBuffer();
           const buffer = Buffer.from(arrayBuffer);
-          fs6.writeFileSync(outputFile, buffer);
+          fs8.writeFileSync(outputFile, buffer);
           const contentType = response.headers.get("content-type") || "application/octet-stream";
           logger.verbose(`[http_client] Downloaded: ${outputFile} (${buffer.length} bytes)`);
           return {
@@ -16789,8 +19233,8 @@ var init_claude_code_types = __esm({
 });
 
 // src/providers/claude-code-check-provider.ts
-import fs7 from "fs/promises";
-import path9 from "path";
+import fs9 from "fs/promises";
+import path11 from "path";
 function isClaudeCodeConstructor(value) {
   return typeof value === "function";
 }
@@ -16949,7 +19393,7 @@ var init_claude_code_check_provider = __esm({
         const hasFileExtension = /\.[a-zA-Z0-9]{1,10}$/i.test(str);
         const hasPathSeparators = /[\/\\]/.test(str);
         const isRelativePath = /^\.{1,2}\//.test(str);
-        const isAbsolutePath = path9.isAbsolute(str);
+        const isAbsolutePath = path11.isAbsolute(str);
         const hasTypicalFileChars = /^[a-zA-Z0-9._\-\/\\:~]+$/.test(str);
         if (!(hasFileExtension || isRelativePath || isAbsolutePath || hasPathSeparators)) {
           return false;
@@ -16959,13 +19403,13 @@ var init_claude_code_check_provider = __esm({
         }
         try {
           let resolvedPath;
-          if (path9.isAbsolute(str)) {
-            resolvedPath = path9.normalize(str);
+          if (path11.isAbsolute(str)) {
+            resolvedPath = path11.normalize(str);
           } else {
-            resolvedPath = path9.resolve(process.cwd(), str);
+            resolvedPath = path11.resolve(process.cwd(), str);
           }
           try {
-            const stat2 = await fs7.stat(resolvedPath);
+            const stat2 = await fs9.stat(resolvedPath);
             return stat2.isFile();
           } catch {
             return hasFileExtension && (isRelativePath || isAbsolutePath || hasPathSeparators);
@@ -16982,14 +19426,14 @@ var init_claude_code_check_provider = __esm({
           throw new Error("Prompt file must have .liquid extension");
         }
         let resolvedPath;
-        if (path9.isAbsolute(promptPath)) {
+        if (path11.isAbsolute(promptPath)) {
           resolvedPath = promptPath;
         } else {
-          resolvedPath = path9.resolve(process.cwd(), promptPath);
+          resolvedPath = path11.resolve(process.cwd(), promptPath);
         }
-        if (!path9.isAbsolute(promptPath)) {
-          const normalizedPath = path9.normalize(resolvedPath);
-          const currentDir = path9.resolve(process.cwd());
+        if (!path11.isAbsolute(promptPath)) {
+          const normalizedPath = path11.normalize(resolvedPath);
+          const currentDir = path11.resolve(process.cwd());
           if (!normalizedPath.startsWith(currentDir)) {
             throw new Error("Invalid prompt file path: path traversal detected");
           }
@@ -16998,7 +19442,7 @@ var init_claude_code_check_provider = __esm({
           throw new Error("Invalid prompt file path: path traversal detected");
         }
         try {
-          const promptContent = await fs7.readFile(resolvedPath, "utf-8");
+          const promptContent = await fs9.readFile(resolvedPath, "utf-8");
           return promptContent;
         } catch (error) {
           throw new Error(
@@ -19568,14 +22012,14 @@ var require_util = __commonJS({
         }
         const port = url.port != null ? url.port : url.protocol === "https:" ? 443 : 80;
         let origin = url.origin != null ? url.origin : `${url.protocol}//${url.hostname}:${port}`;
-        let path13 = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`;
+        let path15 = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`;
         if (origin.endsWith("/")) {
           origin = origin.substring(0, origin.length - 1);
         }
-        if (path13 && !path13.startsWith("/")) {
-          path13 = `/${path13}`;
+        if (path15 && !path15.startsWith("/")) {
+          path15 = `/${path15}`;
         }
-        url = new URL(origin + path13);
+        url = new URL(origin + path15);
       }
       return url;
     }
@@ -21189,20 +23633,20 @@ var require_parseParams = __commonJS({
 var require_basename = __commonJS({
   "node_modules/@fastify/busboy/lib/utils/basename.js"(exports, module) {
     "use strict";
-    module.exports = function basename2(path13) {
-      if (typeof path13 !== "string") {
+    module.exports = function basename2(path15) {
+      if (typeof path15 !== "string") {
         return "";
       }
-      for (var i = path13.length - 1; i >= 0; --i) {
-        switch (path13.charCodeAt(i)) {
+      for (var i = path15.length - 1; i >= 0; --i) {
+        switch (path15.charCodeAt(i)) {
           case 47:
           // '/'
           case 92:
-            path13 = path13.slice(i + 1);
-            return path13 === ".." || path13 === "." ? "" : path13;
+            path15 = path15.slice(i + 1);
+            return path15 === ".." || path15 === "." ? "" : path15;
         }
       }
-      return path13 === ".." || path13 === "." ? "" : path13;
+      return path15 === ".." || path15 === "." ? "" : path15;
     };
   }
 });
@@ -24233,7 +26677,7 @@ var require_request = __commonJS({
     }
     var Request = class _Request {
       constructor(origin, {
-        path: path13,
+        path: path15,
         method,
         body,
         headers,
@@ -24247,11 +26691,11 @@ var require_request = __commonJS({
         throwOnError,
         expectContinue
       }, handler) {
-        if (typeof path13 !== "string") {
+        if (typeof path15 !== "string") {
           throw new InvalidArgumentError("path must be a string");
-        } else if (path13[0] !== "/" && !(path13.startsWith("http://") || path13.startsWith("https://")) && method !== "CONNECT") {
+        } else if (path15[0] !== "/" && !(path15.startsWith("http://") || path15.startsWith("https://")) && method !== "CONNECT") {
           throw new InvalidArgumentError("path must be an absolute URL or start with a slash");
-        } else if (invalidPathRegex.exec(path13) !== null) {
+        } else if (invalidPathRegex.exec(path15) !== null) {
           throw new InvalidArgumentError("invalid request path");
         }
         if (typeof method !== "string") {
@@ -24314,7 +26758,7 @@ var require_request = __commonJS({
         this.completed = false;
         this.aborted = false;
         this.upgrade = upgrade || null;
-        this.path = query ? util.buildURL(path13, query) : path13;
+        this.path = query ? util.buildURL(path15, query) : path15;
         this.origin = origin;
         this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent;
         this.blocking = blocking == null ? false : blocking;
@@ -25322,9 +27766,9 @@ var require_RedirectHandler = __commonJS({
           return this.handler.onHeaders(statusCode, headers, resume, statusText);
         }
         const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)));
-        const path13 = search ? `${pathname}${search}` : pathname;
+        const path15 = search ? `${pathname}${search}` : pathname;
         this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin);
-        this.opts.path = path13;
+        this.opts.path = path15;
         this.opts.origin = origin;
         this.opts.maxRedirections = 0;
         this.opts.query = null;
@@ -26566,7 +29010,7 @@ var require_client = __commonJS({
         writeH2(client, client[kHTTP2Session], request);
         return;
       }
-      const { body, method, path: path13, host, upgrade, headers, blocking, reset } = request;
+      const { body, method, path: path15, host, upgrade, headers, blocking, reset } = request;
       const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
       if (body && typeof body.read === "function") {
         body.read(0);
@@ -26616,7 +29060,7 @@ var require_client = __commonJS({
       if (blocking) {
         socket[kBlocking] = true;
       }
-      let header = `${method} ${path13} HTTP/1.1\r
+      let header = `${method} ${path15} HTTP/1.1\r
 `;
       if (typeof host === "string") {
         header += `host: ${host}\r
@@ -26679,7 +29123,7 @@ upgrade: ${upgrade}\r
       return true;
     }
     function writeH2(client, session, request) {
-      const { body, method, path: path13, host, upgrade, expectContinue, signal, headers: reqHeaders } = request;
+      const { body, method, path: path15, host, upgrade, expectContinue, signal, headers: reqHeaders } = request;
       let headers;
       if (typeof reqHeaders === "string") headers = Request[kHTTP2CopyHeaders](reqHeaders.trim());
       else headers = reqHeaders;
@@ -26722,7 +29166,7 @@ upgrade: ${upgrade}\r
         });
         return true;
       }
-      headers[HTTP2_HEADER_PATH] = path13;
+      headers[HTTP2_HEADER_PATH] = path15;
       headers[HTTP2_HEADER_SCHEME] = "https";
       const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
       if (body && typeof body.read === "function") {
@@ -28965,20 +31409,20 @@ var require_mock_utils = __commonJS({
       }
       return true;
     }
-    function safeUrl(path13) {
-      if (typeof path13 !== "string") {
-        return path13;
+    function safeUrl(path15) {
+      if (typeof path15 !== "string") {
+        return path15;
       }
-      const pathSegments = path13.split("?");
+      const pathSegments = path15.split("?");
       if (pathSegments.length !== 2) {
-        return path13;
+        return path15;
       }
       const qp = new URLSearchParams(pathSegments.pop());
       qp.sort();
       return [...pathSegments, qp.toString()].join("?");
     }
-    function matchKey(mockDispatch2, { path: path13, method, body, headers }) {
-      const pathMatch = matchValue(mockDispatch2.path, path13);
+    function matchKey(mockDispatch2, { path: path15, method, body, headers }) {
+      const pathMatch = matchValue(mockDispatch2.path, path15);
       const methodMatch = matchValue(mockDispatch2.method, method);
       const bodyMatch = typeof mockDispatch2.body !== "undefined" ? matchValue(mockDispatch2.body, body) : true;
       const headersMatch = matchHeaders(mockDispatch2, headers);
@@ -28996,7 +31440,7 @@ var require_mock_utils = __commonJS({
     function getMockDispatch(mockDispatches, key) {
       const basePath = key.query ? buildURL(key.path, key.query) : key.path;
       const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath;
-      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path13 }) => matchValue(safeUrl(path13), resolvedPath));
+      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path15 }) => matchValue(safeUrl(path15), resolvedPath));
       if (matchedMockDispatches.length === 0) {
         throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`);
       }
@@ -29033,9 +31477,9 @@ var require_mock_utils = __commonJS({
       }
     }
     function buildKey(opts) {
-      const { path: path13, method, body, headers, query } = opts;
+      const { path: path15, method, body, headers, query } = opts;
       return {
-        path: path13,
+        path: path15,
         method,
         body,
         headers,
@@ -29484,10 +31928,10 @@ var require_pending_interceptors_formatter = __commonJS({
       }
       format(pendingInterceptors) {
         const withPrettyHeaders = pendingInterceptors.map(
-          ({ method, path: path13, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
+          ({ method, path: path15, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
             Method: method,
             Origin: origin,
-            Path: path13,
+            Path: path15,
             "Status code": statusCode,
             Persistent: persist ? "\u2705" : "\u274C",
             Invocations: timesInvoked,
@@ -34108,8 +36552,8 @@ var require_util6 = __commonJS({
         }
       }
     }
-    function validateCookiePath(path13) {
-      for (const char of path13) {
+    function validateCookiePath(path15) {
+      for (const char of path15) {
         const code = char.charCodeAt(0);
         if (code < 33 || char === ";") {
           throw new Error("Invalid cookie path");
@@ -35789,11 +38233,11 @@ var require_undici = __commonJS({
           if (typeof opts.path !== "string") {
             throw new InvalidArgumentError("invalid opts.path");
           }
-          let path13 = opts.path;
+          let path15 = opts.path;
           if (!opts.path.startsWith("/")) {
-            path13 = `/${path13}`;
+            path15 = `/${path15}`;
           }
-          url = new URL(util.parseOrigin(url).origin + path13);
+          url = new URL(util.parseOrigin(url).origin + path15);
         } else {
           if (!opts) {
             opts = typeof url === "object" ? url : {};
@@ -36950,8 +39394,8 @@ var init_stdin_reader = __esm({
 });
 
 // src/providers/human-input-check-provider.ts
-import * as fs8 from "fs";
-import * as path10 from "path";
+import * as fs10 from "fs";
+import * as path12 from "path";
 var HumanInputCheckProvider;
 var init_human_input_check_provider = __esm({
   "src/providers/human-input-check-provider.ts"() {
@@ -37134,19 +39578,19 @@ var init_human_input_check_provider = __esm({
        */
       async tryReadFile(filePath) {
         try {
-          const absolutePath = path10.isAbsolute(filePath) ? filePath : path10.resolve(process.cwd(), filePath);
-          const normalizedPath = path10.normalize(absolutePath);
+          const absolutePath = path12.isAbsolute(filePath) ? filePath : path12.resolve(process.cwd(), filePath);
+          const normalizedPath = path12.normalize(absolutePath);
           const cwd = process.cwd();
-          if (!normalizedPath.startsWith(cwd + path10.sep) && normalizedPath !== cwd) {
+          if (!normalizedPath.startsWith(cwd + path12.sep) && normalizedPath !== cwd) {
             return null;
           }
           try {
-            await fs8.promises.access(normalizedPath, fs8.constants.R_OK);
-            const stats = await fs8.promises.stat(normalizedPath);
+            await fs10.promises.access(normalizedPath, fs10.constants.R_OK);
+            const stats = await fs10.promises.stat(normalizedPath);
             if (!stats.isFile()) {
               return null;
             }
-            const content = await fs8.promises.readFile(normalizedPath, "utf-8");
+            const content = await fs10.promises.readFile(normalizedPath, "utf-8");
             return content.trim();
           } catch {
             return null;
@@ -37707,8 +40151,8 @@ function buildBuiltinGlobals(opts) {
   const asyncFunctionNames = /* @__PURE__ */ new Set();
   const scheduleFn = async (args = {}) => {
     try {
-      const { handleScheduleAction: handleScheduleAction2, buildScheduleToolContext: buildScheduleToolContext2 } = await import("./schedule-tool-2COUUTF7.mjs");
-      const { extractSlackContext: extractSlackContext2 } = await import("./schedule-tool-handler-KFYNV7HL.mjs");
+      const { handleScheduleAction: handleScheduleAction2, buildScheduleToolContext: buildScheduleToolContext2 } = await import("./schedule-tool-CONR4VW3.mjs");
+      const { extractSlackContext: extractSlackContext2 } = await import("./schedule-tool-handler-YUC6CAXX.mjs");
       const parentCtx = opts.sessionInfo?._parentContext;
       const webhookData = parentCtx?.prInfo?.eventContext?.webhookData;
       const visorCfg = parentCtx?.config;
@@ -38292,9 +40736,9 @@ var init_script_check_provider = __esm({
 });
 
 // src/utils/worktree-manager.ts
-import * as fs9 from "fs";
+import * as fs11 from "fs";
 import * as fsp2 from "fs/promises";
-import * as path11 from "path";
+import * as path13 from "path";
 import * as crypto from "crypto";
 var WorktreeManager, worktreeManager;
 var init_worktree_manager = __esm({
@@ -38314,7 +40758,7 @@ var init_worktree_manager = __esm({
         } catch {
           cwd = "/tmp";
         }
-        const defaultBasePath = process.env.VISOR_WORKTREE_PATH || path11.join(cwd, ".visor", "worktrees");
+        const defaultBasePath = process.env.VISOR_WORKTREE_PATH || path13.join(cwd, ".visor", "worktrees");
         this.config = {
           enabled: true,
           base_path: defaultBasePath,
@@ -38351,20 +40795,20 @@ var init_worktree_manager = __esm({
         }
         const reposDir = this.getReposDir();
         const worktreesDir = this.getWorktreesDir();
-        if (!fs9.existsSync(reposDir)) {
-          fs9.mkdirSync(reposDir, { recursive: true });
+        if (!fs11.existsSync(reposDir)) {
+          fs11.mkdirSync(reposDir, { recursive: true });
           logger.debug(`Created repos directory: ${reposDir}`);
         }
-        if (!fs9.existsSync(worktreesDir)) {
-          fs9.mkdirSync(worktreesDir, { recursive: true });
+        if (!fs11.existsSync(worktreesDir)) {
+          fs11.mkdirSync(worktreesDir, { recursive: true });
           logger.debug(`Created worktrees directory: ${worktreesDir}`);
         }
       }
       getReposDir() {
-        return path11.join(this.config.base_path, "repos");
+        return path13.join(this.config.base_path, "repos");
       }
       getWorktreesDir() {
-        return path11.join(this.config.base_path, "worktrees");
+        return path13.join(this.config.base_path, "worktrees");
       }
       /**
        * Generate a deterministic worktree ID based on repository and ref.
@@ -38382,8 +40826,8 @@ var init_worktree_manager = __esm({
       async getOrCreateBareRepo(repository, repoUrl, _token, fetchDepth, cloneTimeoutMs) {
         const reposDir = this.getReposDir();
         const repoName = repository.replace(/\//g, "-");
-        const bareRepoPath = path11.join(reposDir, `${repoName}.git`);
-        if (fs9.existsSync(bareRepoPath)) {
+        const bareRepoPath = path13.join(reposDir, `${repoName}.git`);
+        if (fs11.existsSync(bareRepoPath)) {
           logger.debug(`Bare repository already exists: ${bareRepoPath}`);
           const verifyResult = await this.verifyBareRepoRemote(bareRepoPath, repoUrl);
           if (verifyResult === "timeout") {
@@ -38530,11 +40974,11 @@ var init_worktree_manager = __esm({
           options.cloneTimeoutMs
         );
         const worktreeId = this.generateWorktreeId(repository, ref);
-        let worktreePath = options.workingDirectory || path11.join(this.getWorktreesDir(), worktreeId);
+        let worktreePath = options.workingDirectory || path13.join(this.getWorktreesDir(), worktreeId);
         if (options.workingDirectory) {
           worktreePath = this.validatePath(options.workingDirectory);
         }
-        if (fs9.existsSync(worktreePath)) {
+        if (fs11.existsSync(worktreePath)) {
           logger.debug(`Worktree already exists: ${worktreePath}`);
           const metadata2 = await this.loadMetadata(worktreePath);
           if (metadata2) {
@@ -38775,31 +41219,48 @@ var init_worktree_manager = __esm({
         const result = await this.executeGitCommand(removeCmd, { timeout: 3e4 });
         if (result.exitCode !== 0) {
           logger.warn(`Failed to remove worktree via git: ${result.stderr}`);
-          if (fs9.existsSync(worktree_path)) {
+          if (fs11.existsSync(worktree_path)) {
             logger.debug(`Manually removing worktree directory`);
-            fs9.rmSync(worktree_path, { recursive: true, force: true });
+            fs11.rmSync(worktree_path, { recursive: true, force: true });
           }
         }
+        const metadataPath = this.getMetadataPath(worktree_path);
+        try {
+          if (fs11.existsSync(metadataPath)) {
+            fs11.unlinkSync(metadataPath);
+          }
+        } catch {
+        }
         this.activeWorktrees.delete(worktreeId);
         logger.info(`Successfully removed worktree: ${worktreeId}`);
       }
+      /**
+       * Get the metadata file path for a worktree.
+       * Stored as a sibling file OUTSIDE the worktree to avoid being committed
+       * when agents run `git add .` inside the checked-out repo.
+       */
+      getMetadataPath(worktreePath) {
+        return worktreePath.replace(/\/?$/, "") + ".metadata.json";
+      }
       /**
        * Save worktree metadata
        */
       async saveMetadata(worktreePath, metadata) {
-        const metadataPath = path11.join(worktreePath, ".visor-metadata.json");
-        fs9.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), "utf8");
+        const metadataPath = this.getMetadataPath(worktreePath);
+        fs11.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), "utf8");
       }
       /**
        * Load worktree metadata
        */
       async loadMetadata(worktreePath) {
-        const metadataPath = path11.join(worktreePath, ".visor-metadata.json");
-        if (!fs9.existsSync(metadataPath)) {
+        const metadataPath = this.getMetadataPath(worktreePath);
+        const legacyPath = path13.join(worktreePath, ".visor-metadata.json");
+        const pathToRead = fs11.existsSync(metadataPath) ? metadataPath : fs11.existsSync(legacyPath) ? legacyPath : null;
+        if (!pathToRead) {
           return null;
         }
         try {
-          const content = fs9.readFileSync(metadataPath, "utf8");
+          const content = fs11.readFileSync(pathToRead, "utf8");
           return JSON.parse(content);
         } catch (error) {
           logger.warn(`Failed to load metadata: ${error}`);
@@ -38811,14 +41272,14 @@ var init_worktree_manager = __esm({
        */
       async listWorktrees() {
         const worktreesDir = this.getWorktreesDir();
-        if (!fs9.existsSync(worktreesDir)) {
+        if (!fs11.existsSync(worktreesDir)) {
           return [];
         }
-        const entries = fs9.readdirSync(worktreesDir, { withFileTypes: true });
+        const entries = fs11.readdirSync(worktreesDir, { withFileTypes: true });
         const worktrees = [];
         for (const entry of entries) {
           if (!entry.isDirectory()) continue;
-          const worktreePath = path11.join(worktreesDir, entry.name);
+          const worktreePath = path13.join(worktreesDir, entry.name);
           const metadata = await this.loadMetadata(worktreePath);
           if (metadata) {
             worktrees.push({
@@ -38950,8 +41411,8 @@ var init_worktree_manager = __esm({
        * Validate path to prevent directory traversal
        */
       validatePath(userPath) {
-        const resolvedPath = path11.resolve(userPath);
-        if (!path11.isAbsolute(resolvedPath)) {
+        const resolvedPath = path13.resolve(userPath);
+        if (!path13.isAbsolute(resolvedPath)) {
           throw new Error("Path must be absolute");
         }
         const sensitivePatterns = [
@@ -39930,7 +42391,7 @@ var init_workflow_projection = __esm({
 });
 
 // src/providers/workflow-check-provider.ts
-import * as path12 from "path";
+import * as path14 from "path";
 import * as yaml from "js-yaml";
 var WorkflowCheckProvider;
 var init_workflow_check_provider = __esm({
@@ -40149,13 +42610,13 @@ var init_workflow_check_provider = __esm({
         const loadConfigLiquid = createExtendedLiquid();
         const loadConfig = (filePath) => {
           try {
-            const normalizedBasePath = path12.normalize(basePath);
-            const resolvedPath = path12.isAbsolute(filePath) ? path12.normalize(filePath) : path12.normalize(path12.resolve(basePath, filePath));
-            const basePathWithSep = normalizedBasePath.endsWith(path12.sep) ? normalizedBasePath : normalizedBasePath + path12.sep;
+            const normalizedBasePath = path14.normalize(basePath);
+            const resolvedPath = path14.isAbsolute(filePath) ? path14.normalize(filePath) : path14.normalize(path14.resolve(basePath, filePath));
+            const basePathWithSep = normalizedBasePath.endsWith(path14.sep) ? normalizedBasePath : normalizedBasePath + path14.sep;
             if (!resolvedPath.startsWith(basePathWithSep) && resolvedPath !== normalizedBasePath) {
               throw new Error(`Path '${filePath}' escapes base directory`);
             }
-            const configDir = path12.dirname(resolvedPath);
+            const configDir = path14.dirname(resolvedPath);
             const rawContent = __require("fs").readFileSync(resolvedPath, "utf-8");
             const renderedContent = loadConfigLiquid.parseAndRenderSync(rawContent, {
               basePath: configDir
@@ -40606,17 +43067,17 @@ var init_workflow_check_provider = __esm({
        * so it can be executed by the state machine as a nested workflow.
        */
       async loadWorkflowFromConfigPath(sourcePath, baseDir) {
-        const path13 = __require("path");
-        const fs10 = __require("fs");
+        const path15 = __require("path");
+        const fs12 = __require("fs");
         const yaml2 = __require("js-yaml");
-        const resolved = path13.isAbsolute(sourcePath) ? sourcePath : path13.resolve(baseDir, sourcePath);
-        if (!fs10.existsSync(resolved)) {
+        const resolved = path15.isAbsolute(sourcePath) ? sourcePath : path15.resolve(baseDir, sourcePath);
+        if (!fs12.existsSync(resolved)) {
           throw new Error(`Workflow config not found at: ${resolved}`);
         }
-        const rawContent = fs10.readFileSync(resolved, "utf8");
+        const rawContent = fs12.readFileSync(resolved, "utf8");
         const rawData = yaml2.load(rawContent);
         if (rawData.imports && Array.isArray(rawData.imports)) {
-          const configDir = path13.dirname(resolved);
+          const configDir = path15.dirname(resolved);
           for (const source of rawData.imports) {
             const results = await this.registry.import(source, {
               basePath: configDir,
@@ -40646,8 +43107,8 @@ ${errors}`);
         if (!steps || Object.keys(steps).length === 0) {
           throw new Error(`Config '${resolved}' does not contain any steps to execute as a workflow`);
         }
-        const id = path13.basename(resolved).replace(/\.(ya?ml)$/i, "");
-        const name = loaded.name || `Workflow from ${path13.basename(resolved)}`;
+        const id = path15.basename(resolved).replace(/\.(ya?ml)$/i, "");
+        const name = loaded.name || `Workflow from ${path15.basename(resolved)}`;
         const workflowDef = {
           id,
           name,
@@ -40670,6 +43131,11 @@ ${errors}`);
 export {
   WorkflowCheckProvider,
   init_workflow_check_provider,
+  handleScheduleAction,
+  getScheduleToolDefinition,
+  isScheduleTool,
+  buildScheduleToolContext,
+  init_schedule_tool,
   extractSlackContext,
   createScheduleToolWithContext,
   executeScheduleTool,
@@ -40690,4 +43156,4 @@ undici/lib/fetch/body.js:
 undici/lib/websocket/frame.js:
   (*! ws. MIT License. Einar Otto Stangvik <einaros@gmail.com> *)
 */
-//# sourceMappingURL=chunk-EWGX7LI7.mjs.map
+//# sourceMappingURL=chunk-H4AYMOAT.mjs.map