@probelabs/visor 0.1.149 → 0.1.150

package/dist/sdk/{chunk-V6GI4U2M.mjs → chunk-AADKUA6L.mjs}

@@ -33,7 +33,7 @@ import {
 import {
   config_exports,
   init_config
-} from "./chunk-YYZAN5NK.mjs";
+} from "./chunk-FYK2DJK6.mjs";
 import {
   ExecutionJournal,
   checkLoopBudget,
@@ -42,11 +42,11 @@ import {
   init_routing,
   init_snapshot_store,
   snapshot_store_exports
-} from "./chunk-CISJ6DJW.mjs";
+} from "./chunk-GLROSEYJ.mjs";
 import {
   FailureConditionEvaluator,
   init_failure_condition_evaluator
-} from "./chunk-RJLJUTSU.mjs";
+} from "./chunk-FZEQ744M.mjs";
 import {
   addEvent,
   emitNdjsonFallback,
@@ -57,7 +57,7 @@ import {
   setSpanAttributes,
   trace_helpers_exports,
   withActiveSpan
-} from "./chunk-62TNF5PJ.mjs";
+} from "./chunk-PETLPNRA.mjs";
 import {
   addDiagramBlock,
   init_metrics
@@ -257,6 +257,23 @@ function createProbeTracerAdapter(fallbackTracer) {
         }
       }
     },
+    recordToolResult: (toolName, result, success, durationMs, metadata) => {
+      const resultStr = typeof result === "string" ? result : JSON.stringify(result || "");
+      emitEvent("tool.result", {
+        "tool.name": toolName,
+        "tool.result": resultStr.substring(0, 1e4),
+        "tool.result.length": resultStr.length,
+        "tool.duration_ms": durationMs,
+        "tool.success": success,
+        ...metadata || {}
+      });
+      if (fallback && typeof fallback.recordToolResult === "function") {
+        try {
+          fallback.recordToolResult(toolName, result, success, durationMs, metadata);
+        } catch {
+        }
+      }
+    },
     recordDelegationEvent: (phase, attrs) => {
       emitEvent(`delegation.${phase}`, attrs);
       if (fallback && typeof fallback.recordDelegationEvent === "function") {
@@ -3942,7 +3959,7 @@ async function executeWorkflowAsTool(workflowId, args, context2, argsOverrides)
     ...args,
     ...argsOverrides
   };
-  const { WorkflowCheckProvider: WorkflowCheckProvider2 } = await import("./workflow-check-provider-AGZ5JY2I.mjs");
+  const { WorkflowCheckProvider: WorkflowCheckProvider2 } = await import("./workflow-check-provider-XLH7N4FV.mjs");
   const provider = new WorkflowCheckProvider2();
   const checkConfig = {
     type: "workflow",
@@ -4070,6 +4087,48 @@ function fromDbRow(row) {
     previousResponse: row.previous_response ?? void 0
   };
 }
+function toTriggerRow(trigger) {
+  return {
+    id: trigger.id,
+    creator_id: trigger.creatorId,
+    creator_context: trigger.creatorContext ?? null,
+    creator_name: trigger.creatorName ?? null,
+    description: trigger.description ?? null,
+    channels: trigger.channels ? JSON.stringify(trigger.channels) : null,
+    from_users: trigger.fromUsers ? JSON.stringify(trigger.fromUsers) : null,
+    from_bots: trigger.fromBots ? 1 : 0,
+    contains: trigger.contains ? JSON.stringify(trigger.contains) : null,
+    match_pattern: trigger.matchPattern ?? null,
+    threads: trigger.threads,
+    workflow: trigger.workflow,
+    inputs: trigger.inputs ? JSON.stringify(trigger.inputs) : null,
+    output_context: trigger.outputContext ? JSON.stringify(trigger.outputContext) : null,
+    status: trigger.status,
+    enabled: trigger.enabled ? 1 : 0,
+    created_at: trigger.createdAt
+  };
+}
+function fromTriggerRow(row) {
+  return {
+    id: row.id,
+    creatorId: row.creator_id,
+    creatorContext: row.creator_context ?? void 0,
+    creatorName: row.creator_name ?? void 0,
+    description: row.description ?? void 0,
+    channels: safeJsonParse(row.channels),
+    fromUsers: safeJsonParse(row.from_users),
+    fromBots: row.from_bots === 1,
+    contains: safeJsonParse(row.contains),
+    matchPattern: row.match_pattern ?? void 0,
+    threads: row.threads,
+    workflow: row.workflow,
+    inputs: safeJsonParse(row.inputs),
+    outputContext: safeJsonParse(row.output_context),
+    status: row.status,
+    enabled: row.enabled === 1,
+    createdAt: row.created_at
+  };
+}
 var SqliteStoreBackend;
 var init_sqlite_store = __esm({
   "src/scheduler/store/sqlite-store.ts"() {
@@ -4159,6 +4218,32 @@ var init_sqlite_store = __esm({
         acquired_at BIGINT       NOT NULL,
         expires_at  BIGINT       NOT NULL
       );
+
+      CREATE TABLE IF NOT EXISTS message_triggers (
+        id              VARCHAR(36)  PRIMARY KEY,
+        creator_id      VARCHAR(255) NOT NULL,
+        creator_context VARCHAR(255),
+        creator_name    VARCHAR(255),
+        description     TEXT,
+        channels        TEXT,
+        from_users      TEXT,
+        from_bots       BOOLEAN      NOT NULL DEFAULT 0,
+        contains        TEXT,
+        match_pattern   TEXT,
+        threads         VARCHAR(20)  NOT NULL DEFAULT 'any',
+        workflow        VARCHAR(255) NOT NULL,
+        inputs          TEXT,
+        output_context  TEXT,
+        status          VARCHAR(20)  NOT NULL DEFAULT 'active',
+        enabled         BOOLEAN      NOT NULL DEFAULT 1,
+        created_at      BIGINT       NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_message_triggers_creator
+        ON message_triggers(creator_id);
+
+      CREATE INDEX IF NOT EXISTS idx_message_triggers_status
+        ON message_triggers(status);
     `);
       }
       // --- Helpers ---
@@ -4440,6 +4525,114 @@ var init_sqlite_store = __esm({
       }
       async flush() {
       }
+      // --- Message Triggers ---
+      async createTrigger(trigger) {
+        const db = this.getDb();
+        const newTrigger = {
+          ...trigger,
+          id: uuidv4(),
+          createdAt: Date.now()
+        };
+        const row = toTriggerRow(newTrigger);
+        db.prepare(
+          `INSERT INTO message_triggers (
+        id, creator_id, creator_context, creator_name, description,
+        channels, from_users, from_bots, contains, match_pattern,
+        threads, workflow, inputs, output_context,
+        status, enabled, created_at
+      ) VALUES (
+        ?, ?, ?, ?, ?,
+        ?, ?, ?, ?, ?,
+        ?, ?, ?, ?,
+        ?, ?, ?
+      )`
+        ).run(
+          row.id,
+          row.creator_id,
+          row.creator_context,
+          row.creator_name,
+          row.description,
+          row.channels,
+          row.from_users,
+          row.from_bots,
+          row.contains,
+          row.match_pattern,
+          row.threads,
+          row.workflow,
+          row.inputs,
+          row.output_context,
+          row.status,
+          row.enabled,
+          row.created_at
+        );
+        logger.info(
+          `[SqliteStore] Created message trigger ${newTrigger.id} for user ${newTrigger.creatorId}`
+        );
+        return newTrigger;
+      }
+      async getTrigger(id) {
+        const db = this.getDb();
+        const row = db.prepare("SELECT * FROM message_triggers WHERE id = ?").get(id);
+        return row ? fromTriggerRow(row) : void 0;
+      }
+      async updateTrigger(id, patch) {
+        const db = this.getDb();
+        const existing = db.prepare("SELECT * FROM message_triggers WHERE id = ?").get(id);
+        if (!existing) return void 0;
+        const current = fromTriggerRow(existing);
+        const updated = {
+          ...current,
+          ...patch,
+          id: current.id,
+          createdAt: current.createdAt
+        };
+        const row = toTriggerRow(updated);
+        db.prepare(
+          `UPDATE message_triggers SET
+        creator_id = ?, creator_context = ?, creator_name = ?, description = ?,
+        channels = ?, from_users = ?, from_bots = ?, contains = ?, match_pattern = ?,
+        threads = ?, workflow = ?, inputs = ?, output_context = ?,
+        status = ?, enabled = ?
+      WHERE id = ?`
+        ).run(
+          row.creator_id,
+          row.creator_context,
+          row.creator_name,
+          row.description,
+          row.channels,
+          row.from_users,
+          row.from_bots,
+          row.contains,
+          row.match_pattern,
+          row.threads,
+          row.workflow,
+          row.inputs,
+          row.output_context,
+          row.status,
+          row.enabled,
+          row.id
+        );
+        return updated;
+      }
+      async deleteTrigger(id) {
+        const db = this.getDb();
+        const result = db.prepare("DELETE FROM message_triggers WHERE id = ?").run(id);
+        if (result.changes > 0) {
+          logger.info(`[SqliteStore] Deleted message trigger ${id}`);
+          return true;
+        }
+        return false;
+      }
+      async getTriggersByCreator(creatorId) {
+        const db = this.getDb();
+        const rows = db.prepare("SELECT * FROM message_triggers WHERE creator_id = ?").all(creatorId);
+        return rows.map(fromTriggerRow);
+      }
+      async getActiveTriggers() {
+        const db = this.getDb();
+        const rows = db.prepare("SELECT * FROM message_triggers WHERE status = 'active' AND enabled = 1").all();
+        return rows.map(fromTriggerRow);
+      }
     };
   }
 });
@@ -4558,11 +4751,19 @@ var init_schedule_store = __esm({
     init_json_migrator();
     ScheduleStore = class _ScheduleStore {
       static instance;
+      static onTriggersChanged;
       backend = null;
       initialized = false;
       limits;
       config;
       externalBackend = null;
+      /**
+       * Register a callback to be invoked when message triggers change (create/update/delete).
+       * Used by SlackSocketRunner to rebuild its evaluator.
+       */
+      static setTriggersChangedCallback(cb) {
+        _ScheduleStore.onTriggersChanged = cb;
+      }
       constructor(config, limits, backend) {
         this.config = config || {};
         this.limits = {
@@ -4724,6 +4925,53 @@ var init_schedule_store = __esm({
         }
         return this.backend;
       }
+      // --- Message Trigger Methods ---
+      /**
+       * Create a new message trigger
+       */
+      async createTriggerAsync(trigger) {
+        const result = await this.getBackend().createTrigger(trigger);
+        _ScheduleStore.onTriggersChanged?.();
+        return result;
+      }
+      /**
+       * Get a trigger by ID
+       */
+      async getTriggerAsync(id) {
+        return this.getBackend().getTrigger(id);
+      }
+      /**
+       * Update a trigger
+       */
+      async updateTriggerAsync(id, patch) {
+        const result = await this.getBackend().updateTrigger(id, patch);
+        if (result) {
+          _ScheduleStore.onTriggersChanged?.();
+        }
+        return result;
+      }
+      /**
+       * Delete a trigger
+       */
+      async deleteTriggerAsync(id) {
+        const result = await this.getBackend().deleteTrigger(id);
+        if (result) {
+          _ScheduleStore.onTriggersChanged?.();
+        }
+        return result;
+      }
+      /**
+       * Get all triggers for a specific creator
+       */
+      async getTriggersByCreatorAsync(creatorId) {
+        return this.getBackend().getTriggersByCreator(creatorId);
+      }
+      /**
+       * Get all active triggers
+       */
+      async getActiveTriggersAsync() {
+        return this.getBackend().getActiveTriggers();
+      }
       /**
        * Shut down the backend cleanly
        */
@@ -9007,7 +9255,7 @@ async function executeCheckWithForEachItems2(checkId, forEachParent, forEachItem
           }
         }
         try {
-          const { evaluateTransitions } = await import("./routing-LU5PAREW.mjs");
+          const { evaluateTransitions } = await import("./routing-V3MYZAOH.mjs");
           const transTarget = await evaluateTransitions(
             onFinish.transitions,
             forEachParent,
@@ -9067,7 +9315,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-LU5PAREW.mjs");
+        const { evaluateGoto: evaluateGoto2 } = await import("./routing-V3MYZAOH.mjs");
         if (context2.debug) {
           logger.info(
             `[LevelDispatch] Evaluating on_finish.goto_js for forEach parent: ${forEachParent}`
@@ -12323,6 +12571,30 @@ var init_workspace_manager = __esm({
         if (cleanResult.exitCode !== 0) {
           logger.warn(`[Workspace] clean -fdx failed: ${cleanResult.stderr}`);
         }
+        await this.deleteLocalBranches(worktreePath);
+      }
+      /**
+       * Delete all local branches in a worktree.
+       */
+      async deleteLocalBranches(worktreePath) {
+        const escapedPath = shellEscape(worktreePath);
+        const listResult = await commandExecutor.execute(
+          `git -C ${escapedPath} branch --list --format='%(refname:short)'`,
+          { timeout: 1e4 }
+        );
+        if (listResult.exitCode !== 0 || !listResult.stdout.trim()) {
+          return;
+        }
+        const branches = listResult.stdout.trim().split("\n").map((b) => b.trim()).filter((b) => b.length > 0);
+        for (const branch of branches) {
+          const deleteResult = await commandExecutor.execute(
+            `git -C ${escapedPath} branch -D ${shellEscape(branch)}`,
+            { timeout: 1e4 }
+          );
+          if (deleteResult.exitCode === 0) {
+            logger.debug(`[Workspace] Deleted local branch '${branch}' from worktree`);
+          }
+        }
       }
       /**
        * Refresh an existing worktree to the latest upstream default branch
@@ -12692,7 +12964,7 @@ var init_state_machine_execution_engine = __esm({
             await memoryStore.initialize();
             logger.debug("Memory store initialized");
           }
-          const { GitRepositoryAnalyzer } = await import("./git-repository-analyzer-QFMW6WIS.mjs");
+          const { GitRepositoryAnalyzer } = await import("./git-repository-analyzer-TWNJUN42.mjs");
           const gitAnalyzer = new GitRepositoryAnalyzer(options.workingDirectory);
           logger.info("Analyzing local git repository...");
           const repositoryInfo = await gitAnalyzer.analyzeRepository();
@@ -12729,7 +13001,7 @@ var init_state_machine_execution_engine = __esm({
           try {
             const map = options?.webhookContext?.webhookData;
             if (map) {
-              const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-LVLC4EPF.mjs");
+              const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-RRYBG6AU.mjs");
               const reg = CheckProviderRegistry2.getInstance();
               const p = reg.getProvider("http_input");
               if (p && typeof p.setWebhookContext === "function") p.setWebhookContext(map);
@@ -12842,7 +13114,7 @@ var init_state_machine_execution_engine = __esm({
           logger.info("[StateMachine] Using state machine engine");
         }
         if (!config) {
-          const { ConfigManager } = await import("./config-KQH254CA.mjs");
+          const { ConfigManager } = await import("./config-MTEIGCOQ.mjs");
           const configManager = new ConfigManager();
           config = await configManager.getDefaultConfig();
           logger.debug("[StateMachine] Using default configuration (no config provided)");
@@ -12852,7 +13124,7 @@ var init_state_machine_execution_engine = __esm({
           tag_filter: tagFilter
         } : config;
         try {
-          const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-LVLC4EPF.mjs");
+          const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-RRYBG6AU.mjs");
           const registry = CheckProviderRegistry2.getInstance();
           registry.setCustomTools(configWithTagFilter.tools || {});
         } catch (error) {
@@ -12916,7 +13188,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-KKN7XJYT.mjs");
+              const { extractSlackContext: extractSlackContext2 } = await import("./schedule-tool-handler-EFQIYD3W.mjs");
               const slackCtx = extractSlackContext2(webhookData);
               if (slackCtx) {
                 const payload = Array.from(webhookData.values())[0];
@@ -12945,7 +13217,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-H7IX4GBK.mjs");
+            const { FrontendsHost } = await import("./host-MR7L57QI.mjs");
             const bus = new EventBus();
             context2.eventBus = bus;
             frontendsHost = new FrontendsHost(bus, logger);
@@ -13295,9 +13567,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-IVCTD4BZ.mjs");
+        const { FailureConditionEvaluator: FailureConditionEvaluator2 } = await import("./failure-condition-evaluator-XV2ZMFFY.mjs");
         const evaluator = new FailureConditionEvaluator2();
-        const { addEvent: addEvent3 } = await import("./trace-helpers-6ROJR7N3.mjs");
+        const { addEvent: addEvent3 } = await import("./trace-helpers-6NSZBC35.mjs");
         const { addFailIfTriggered } = await import("./metrics-I6A7IHG4.mjs");
         const checkConfig = config.checks?.[checkName];
         if (!checkConfig) {
@@ -13400,7 +13672,7 @@ var init_state_machine_execution_engine = __esm({
        */
       async getRepositoryStatus() {
         try {
-          const { GitRepositoryAnalyzer } = await import("./git-repository-analyzer-QFMW6WIS.mjs");
+          const { GitRepositoryAnalyzer } = await import("./git-repository-analyzer-TWNJUN42.mjs");
           const analyzer = new GitRepositoryAnalyzer(this.workingDirectory);
           const info = await analyzer.analyzeRepository();
           return {
@@ -14470,11 +14742,19 @@ async function handleScheduleAction(args, context2) {
       return handlePauseResume(args, context2, store, "paused");
     case "resume":
       return handlePauseResume(args, context2, store, "active");
+    case "create_trigger":
+      return handleCreateTrigger(args, context2, store);
+    case "list_triggers":
+      return handleListTriggers(context2, store);
+    case "delete_trigger":
+      return handleDeleteTrigger(args, context2, store);
+    case "update_trigger":
+      return handleUpdateTrigger(args, context2, store);
     default:
       return {
         success: false,
         message: `Unknown action: ${args.action}`,
-        error: `Supported actions: create, list, cancel, pause, resume`
+        error: `Supported actions: create, list, cancel, pause, resume, create_trigger, list_triggers, delete_trigger, update_trigger`
       };
   }
 }
@@ -14717,6 +14997,172 @@ async function handlePauseResume(args, context2, store, newStatus) {
     schedule: updated
   };
 }
+function formatTrigger(trigger) {
+  const channels = trigger.channels?.length ? trigger.channels.join(", ") : "all";
+  const filters = [];
+  if (trigger.contains?.length) filters.push(`contains: ${trigger.contains.join(", ")}`);
+  if (trigger.matchPattern) filters.push(`match: /${trigger.matchPattern}/`);
+  if (trigger.fromBots) filters.push("bots: yes");
+  const filterStr = filters.length ? ` [${filters.join("; ")}]` : "";
+  const status = trigger.enabled ? "" : " (disabled)";
+  return `\`${trigger.id.substring(0, 8)}\` - channels: ${channels} \u2192 workflow: "${trigger.workflow}"${filterStr}${status}`;
+}
+async function handleCreateTrigger(args, context2, store) {
+  if (!args.workflow) {
+    return {
+      success: false,
+      message: "Missing workflow",
+      error: "Please specify the workflow to run when the trigger fires."
+    };
+  }
+  if (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 ? "..." : ""}`
+    };
+  }
+  if ((!args.trigger_channels || args.trigger_channels.length === 0) && (!args.trigger_contains || args.trigger_contains.length === 0) && !args.trigger_match) {
+    return {
+      success: false,
+      message: "Missing trigger filters",
+      error: "Please specify at least one filter: trigger_channels, trigger_contains, or trigger_match."
+    };
+  }
+  const permissionCheck = checkSchedulePermissions(context2, args.workflow);
+  if (!permissionCheck.allowed) {
+    return {
+      success: false,
+      message: "Permission denied",
+      error: permissionCheck.reason || "You do not have permission to create triggers for this workflow"
+    };
+  }
+  try {
+    const trigger = await store.createTriggerAsync({
+      creatorId: context2.userId,
+      creatorContext: context2.contextType,
+      creatorName: context2.userName,
+      description: args.trigger_description,
+      channels: args.trigger_channels,
+      fromBots: args.trigger_from_bots ?? false,
+      contains: args.trigger_contains,
+      matchPattern: args.trigger_match,
+      threads: args.trigger_threads ?? "any",
+      workflow: args.workflow,
+      inputs: args.workflow_inputs,
+      status: "active",
+      enabled: true
+    });
+    logger.info(
+      `[ScheduleTool] Created message trigger ${trigger.id} for user ${context2.userId}: workflow="${args.workflow}"`
+    );
+    return {
+      success: true,
+      message: `**Message trigger created!**
+
+**Workflow**: ${trigger.workflow}
+**Channels**: ${trigger.channels?.join(", ") || "all"}
+${trigger.contains?.length ? `**Contains**: ${trigger.contains.join(", ")}
+` : ""}${trigger.matchPattern ? `**Pattern**: /${trigger.matchPattern}/
+` : ""}${trigger.description ? `**Description**: ${trigger.description}
+` : ""}
+ID: \`${trigger.id.substring(0, 8)}\``
+    };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : "Unknown error";
+    logger.warn(`[ScheduleTool] Failed to create trigger: ${errorMsg}`);
+    return {
+      success: false,
+      message: `Failed to create trigger: ${errorMsg}`,
+      error: errorMsg
+    };
+  }
+}
+async function handleListTriggers(context2, store) {
+  const triggers = await store.getTriggersByCreatorAsync(context2.userId);
+  const active = triggers.filter((t) => t.status !== "deleted");
+  if (active.length === 0) {
+    return {
+      success: true,
+      message: `You don't have any message triggers.
+
+To create one: "watch #channel for messages containing 'error' and run %my-workflow"`
+    };
+  }
+  const lines = active.map((t, i) => `${i + 1}. ${formatTrigger(t)}`);
+  return {
+    success: true,
+    message: `**Your message triggers:**
+
+${lines.join("\n")}
+
+To delete: "delete trigger <id>"
+To disable: "disable trigger <id>"`
+  };
+}
+async function handleDeleteTrigger(args, context2, store) {
+  if (!args.trigger_id) {
+    return {
+      success: false,
+      message: "Missing trigger ID",
+      error: "Please specify which trigger to delete."
+    };
+  }
+  const userTriggers = await store.getTriggersByCreatorAsync(context2.userId);
+  let trigger = userTriggers.find((t) => t.id === args.trigger_id);
+  if (!trigger) {
+    trigger = userTriggers.find((t) => t.id.startsWith(args.trigger_id));
+  }
+  if (!trigger) {
+    return {
+      success: false,
+      message: "Trigger not found",
+      error: `Could not find trigger with ID "${args.trigger_id}" in your triggers. Use "list my triggers" to see your triggers.`
+    };
+  }
+  await store.deleteTriggerAsync(trigger.id);
+  logger.info(`[ScheduleTool] Deleted trigger ${trigger.id} for user ${context2.userId}`);
+  return {
+    success: true,
+    message: `**Trigger deleted!**
+
+Was: watching for "${trigger.workflow}" ${trigger.channels?.length ? `in ${trigger.channels.join(", ")}` : ""}`
+  };
+}
+async function handleUpdateTrigger(args, context2, store) {
+  if (!args.trigger_id) {
+    return {
+      success: false,
+      message: "Missing trigger ID",
+      error: "Please specify which trigger to update."
+    };
+  }
+  const userTriggers = await store.getTriggersByCreatorAsync(context2.userId);
+  let trigger = userTriggers.find((t) => t.id === args.trigger_id);
+  if (!trigger) {
+    trigger = userTriggers.find((t) => t.id.startsWith(args.trigger_id));
+  }
+  if (!trigger) {
+    return {
+      success: false,
+      message: "Trigger not found",
+      error: `Could not find trigger with ID "${args.trigger_id}" in your triggers.`
+    };
+  }
+  const patch = {};
+  if (args.trigger_enabled !== void 0) {
+    patch.enabled = args.trigger_enabled;
+  }
+  await store.updateTriggerAsync(trigger.id, patch);
+  const action = args.trigger_enabled === false ? "disabled" : "enabled";
+  logger.info(`[ScheduleTool] ${action} trigger ${trigger.id} for user ${context2.userId}`);
+  return {
+    success: true,
+    message: `**Trigger ${action}!**
+
+"${trigger.workflow}" ${trigger.channels?.length ? `in ${trigger.channels.join(", ")}` : ""}`
+  };
+}
 function getScheduleToolDefinition() {
   return {
     name: "schedule",
@@ -14736,6 +15182,17 @@ ACTIONS:
 - cancel: Remove a schedule by ID
 - pause/resume: Temporarily disable/enable a schedule
 
+MESSAGE-BASED TRIGGERS:
+In addition to time-based schedules, this tool can create/manage message-based triggers that react to
+Slack messages in specific channels. Use the create_trigger, list_triggers, delete_trigger, and update_trigger
+actions for this. Message triggers fire workflows based on message content, channel, sender, and thread scope.
+
+TRIGGER ACTIONS:
+- create_trigger: Create a new message trigger (requires workflow + at least one filter)
+- list_triggers: Show user's message triggers
+- delete_trigger: Remove a trigger by ID
+- update_trigger: Enable/disable a trigger by ID
+
 FOR CREATE ACTION - Extract these from user's request:
 1. WHAT:
    - If user says "schedule %some-workflow ...", populate 'workflow' with "some-workflow".
@@ -14823,14 +15280,36 @@ User: "list my schedules"
 \u2192 { "action": "list" }
 
 User: "cancel schedule abc123"
-\u2192 { "action": "cancel", "schedule_id": "abc123" }`,
+\u2192 { "action": "cancel", "schedule_id": "abc123" }
+
+User: "watch #cicd for messages containing 'failed' and run %handle-cicd"
+\u2192 { "action": "create_trigger", "trigger_channels": ["C0CICD"], "trigger_contains": ["failed"], "workflow": "handle-cicd" }
+
+User: "list my message triggers"
+\u2192 { "action": "list_triggers" }
+
+User: "delete trigger abc123"
+\u2192 { "action": "delete_trigger", "trigger_id": "abc123" }
+
+User: "disable trigger abc123"
+\u2192 { "action": "update_trigger", "trigger_id": "abc123", "trigger_enabled": false }`,
     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"
+          enum: [
+            "create",
+            "list",
+            "cancel",
+            "pause",
+            "resume",
+            "create_trigger",
+            "list_triggers",
+            "delete_trigger",
+            "update_trigger"
+          ],
+          description: "What to do: create/list/cancel/pause/resume for time-based schedules; create_trigger/list_triggers/delete_trigger/update_trigger for message-based triggers"
         },
         // WHAT to do
         reminder_text: {
@@ -14880,6 +15359,42 @@ User: "cancel schedule abc123"
         schedule_id: {
           type: "string",
           description: "For cancel/pause/resume: the schedule ID to act on (first 8 chars is enough)"
+        },
+        // For message trigger actions
+        trigger_channels: {
+          type: "array",
+          items: { type: "string" },
+          description: 'For create_trigger: Slack channel IDs to monitor (e.g., ["C0CICD"]). Supports wildcard suffix (e.g., "CENG*").'
+        },
+        trigger_from_bots: {
+          type: "boolean",
+          description: "For create_trigger: allow bot messages to trigger (default: false)"
+        },
+        trigger_contains: {
+          type: "array",
+          items: { type: "string" },
+          description: 'For create_trigger: keywords to match (case-insensitive OR). E.g., ["failed", "error"].'
+        },
+        trigger_match: {
+          type: "string",
+          description: "For create_trigger: regex pattern to match against message text."
+        },
+        trigger_threads: {
+          type: "string",
+          enum: ["root_only", "thread_only", "any"],
+          description: 'For create_trigger: thread scope filter (default: "any").'
+        },
+        trigger_description: {
+          type: "string",
+          description: "For create_trigger: human-readable description of the trigger."
+        },
+        trigger_id: {
+          type: "string",
+          description: "For delete_trigger/update_trigger: the trigger ID to act on (first 8 chars is enough)."
+        },
+        trigger_enabled: {
+          type: "boolean",
+          description: "For update_trigger: set to false to disable, true to enable."
         }
       },
       required: ["action"]
@@ -40151,8 +40666,8 @@ function buildBuiltinGlobals(opts) {
   const asyncFunctionNames = /* @__PURE__ */ new Set();
   const scheduleFn = async (args = {}) => {
     try {
-      const { handleScheduleAction: handleScheduleAction2, buildScheduleToolContext: buildScheduleToolContext2 } = await import("./schedule-tool-NX75VKGA.mjs");
-      const { extractSlackContext: extractSlackContext2 } = await import("./schedule-tool-handler-KKN7XJYT.mjs");
+      const { handleScheduleAction: handleScheduleAction2, buildScheduleToolContext: buildScheduleToolContext2 } = await import("./schedule-tool-NYLNJUEW.mjs");
+      const { extractSlackContext: extractSlackContext2 } = await import("./schedule-tool-handler-EFQIYD3W.mjs");
       const parentCtx = opts.sessionInfo?._parentContext;
       const webhookData = parentCtx?.prInfo?.eventContext?.webhookData;
       const visorCfg = parentCtx?.config;
@@ -41013,7 +41528,7 @@ var init_worktree_manager = __esm({
                     await this.saveMetadata(worktreePath, updatedMetadata);
                     if (options.clean) {
                       logger.debug(`Cleaning updated worktree`);
-                      await this.cleanWorktree(worktreePath);
+                      await this.cleanWorktree(worktreePath, latestCommit);
                     }
                     this.activeWorktrees.set(worktreeId, updatedMetadata);
                     return {
@@ -41032,7 +41547,7 @@ var init_worktree_manager = __esm({
               }
               if (options.clean) {
                 logger.debug(`Cleaning existing worktree`);
-                await this.cleanWorktree(worktreePath);
+                await this.cleanWorktree(worktreePath, metadata2.commit);
               }
               this.activeWorktrees.set(worktreeId, metadata2);
               return {
@@ -41074,7 +41589,7 @@ var init_worktree_manager = __esm({
                 await this.saveMetadata(worktreePath, updatedMetadata);
                 if (options.clean) {
                   logger.debug(`Cleaning updated worktree`);
-                  await this.cleanWorktree(worktreePath);
+                  await this.cleanWorktree(worktreePath, newCommit);
                 }
                 this.activeWorktrees.set(worktreeId, updatedMetadata);
                 logger.info(`Successfully updated worktree to ${ref} (${newCommit})`);
@@ -41164,13 +41679,54 @@ var init_worktree_manager = __esm({
         return true;
       }
       /**
-       * Clean worktree (reset and remove untracked files)
-       */
-      async cleanWorktree(worktreePath) {
+       * Clean worktree (reset and remove untracked files).
+       *
+       * When `expectedCommit` is provided the worktree is first forced back to a
+       * detached HEAD at that commit.  This is essential because AI agents or user
+       * commands may have created local branches inside the worktree, switching
+       * HEAD away from the detached state.  A plain `reset --hard HEAD` would
+       * then reset to the *wrong* commit.  After resetting, any local branches
+       * that were created inside the worktree are deleted so they cannot leak
+       * into future runs or PRs.
+       */
+      async cleanWorktree(worktreePath, expectedCommit) {
+        if (expectedCommit) {
+          const detachCmd = `git -C ${this.escapeShellArg(worktreePath)} checkout --detach ${this.escapeShellArg(expectedCommit)}`;
+          const detachResult = await this.executeGitCommand(detachCmd, { timeout: 3e4 });
+          if (detachResult.exitCode !== 0) {
+            await this.executeGitCommand(`git -C ${this.escapeShellArg(worktreePath)} reset --hard`, {
+              timeout: 1e4
+            });
+            await this.executeGitCommand(detachCmd, { timeout: 3e4 });
+          }
+        }
         const resetCmd = `git -C ${this.escapeShellArg(worktreePath)} reset --hard HEAD`;
         await this.executeGitCommand(resetCmd);
         const cleanCmd = `git -C ${this.escapeShellArg(worktreePath)} clean -fdx`;
         await this.executeGitCommand(cleanCmd);
+        await this.deleteLocalBranches(worktreePath);
+      }
+      /**
+       * Delete all local branches in a worktree.
+       * Worktrees are always used in detached HEAD state, so any local branches
+       * were unintentionally created and should be cleaned up.
+       */
+      async deleteLocalBranches(worktreePath) {
+        const listCmd = `git -C ${this.escapeShellArg(worktreePath)} branch --list --format='%(refname:short)'`;
+        const listResult = await this.executeGitCommand(listCmd, { timeout: 1e4 });
+        if (listResult.exitCode !== 0 || !listResult.stdout.trim()) {
+          return;
+        }
+        const branches = listResult.stdout.trim().split("\n").map((b) => b.trim()).filter((b) => b.length > 0);
+        for (const branch of branches) {
+          const deleteCmd = `git -C ${this.escapeShellArg(worktreePath)} branch -D ${this.escapeShellArg(branch)}`;
+          const deleteResult = await this.executeGitCommand(deleteCmd, { timeout: 1e4 });
+          if (deleteResult.exitCode === 0) {
+            logger.debug(`Deleted local branch '${branch}' from worktree`);
+          } else {
+            logger.warn(`Failed to delete branch '${branch}': ${deleteResult.stderr}`);
+          }
+        }
       }
       /**
        * Get commit SHA for a given ref inside a bare repository.
@@ -43156,4 +43712,4 @@ undici/lib/fetch/body.js:
 undici/lib/websocket/frame.js:
   (*! ws. MIT License. Einar Otto Stangvik <einaros@gmail.com> *)
 */
-//# sourceMappingURL=chunk-V6GI4U2M.mjs.map
+//# sourceMappingURL=chunk-AADKUA6L.mjs.map