@probelabs/visor 0.1.183-ee → 0.1.184-ee

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-process.env.VISOR_VERSION = '0.1.183';
-process.env.PROBE_VERSION = '0.6.0-rc308';
-process.env.VISOR_COMMIT_SHA = '0840de72a184fe6e122d343e1628c34c92b88922';
-process.env.VISOR_COMMIT_SHORT = '0840de7';
+process.env.VISOR_VERSION = '0.1.184';
+process.env.PROBE_VERSION = '0.6.0-rc311';
+process.env.VISOR_COMMIT_SHA = 'fa523b7486d2550f30d84ebab4c46da43fafecaf';
+process.env.VISOR_COMMIT_SHORT = 'fa523b7';
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
@@ -293448,6 +293448,868 @@ async function evaluateAndStore(taskId, store, config) {
 }
 
 
+/***/ }),
+
+/***/ 90535:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.SlackTaskLiveUpdateSink = void 0;
+const markdown_1 = __nccwpck_require__(34907);
+const logger_1 = __nccwpck_require__(86999);
+class SlackTaskLiveUpdateSink {
+    slack;
+    channel;
+    threadTs;
+    kind = 'slack';
+    messageTs;
+    constructor(slack, channel, threadTs, initialMessageTs) {
+        this.slack = slack;
+        this.channel = channel;
+        this.threadTs = threadTs;
+        this.messageTs = initialMessageTs;
+    }
+    async start() {
+        logger_1.logger.debug(`[TaskLiveUpdates][Slack] Initialized live update sink for channel=${this.channel} thread=${this.threadTs}`);
+        return null;
+    }
+    async update(text) {
+        return this.publish(text, 'progress');
+    }
+    async complete(text) {
+        return this.publish(text, 'final');
+    }
+    async fail(text) {
+        return this.publish(text, 'final');
+    }
+    async publish(text, mode) {
+        if (this.messageTs) {
+            logger_1.logger.debug(`[TaskLiveUpdates][Slack] Updating existing message ts=${this.messageTs} in channel=${this.channel}`);
+            const updated = await this.slack.chat.update({
+                channel: this.channel,
+                ts: this.messageTs,
+                text: (0, markdown_1.formatSlackText)(text),
+            });
+            if (updated?.ok)
+                return null;
+            logger_1.logger.warn(`[TaskLiveUpdates][Slack] chat.update failed for ts=${this.messageTs} error=${updated?.error || 'unknown_error'}; falling back to chat.postMessage`);
+        }
+        logger_1.logger.info(`[TaskLiveUpdates][Slack] Posting live update message in channel=${this.channel} thread=${this.threadTs}`);
+        const posted = await this.slack.chat.postMessage({
+            channel: this.channel,
+            thread_ts: this.threadTs,
+            text: (0, markdown_1.formatSlackText)(text),
+        });
+        if (posted?.ok && posted.ts) {
+            const previousTs = this.messageTs;
+            this.messageTs = posted.ts;
+            if (mode === 'final' && previousTs && previousTs !== posted.ts) {
+                const deleted = await this.slack.chat.delete({
+                    channel: this.channel,
+                    ts: previousTs,
+                });
+                if (!deleted?.ok) {
+                    logger_1.logger.warn(`[TaskLiveUpdates][Slack] chat.delete failed for stale live update ts=${previousTs} error=${deleted?.error || 'unknown_error'}`);
+                }
+                else {
+                    logger_1.logger.info(`[TaskLiveUpdates][Slack] Removed stale live update message ts=${previousTs} after final fallback post`);
+                }
+            }
+            return {
+                ref: {
+                    slack_live_update_channel: this.channel,
+                    slack_live_update_ts: posted.ts,
+                    slack_live_update_thread_ts: this.threadTs,
+                },
+            };
+        }
+        return null;
+    }
+}
+exports.SlackTaskLiveUpdateSink = SlackTaskLiveUpdateSink;
+
+
+/***/ }),
+
+/***/ 82309:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.TeamsTaskLiveUpdateSink = void 0;
+const markdown_1 = __nccwpck_require__(37349);
+const logger_1 = __nccwpck_require__(86999);
+class TeamsTaskLiveUpdateSink {
+    teams;
+    conversationReference;
+    replyToActivityId;
+    kind = 'teams';
+    activityId;
+    constructor(teams, conversationReference, replyToActivityId, initialActivityId) {
+        this.teams = teams;
+        this.conversationReference = conversationReference;
+        this.replyToActivityId = replyToActivityId;
+        this.activityId = initialActivityId;
+    }
+    async start() {
+        logger_1.logger.debug('[TaskLiveUpdates][Teams] Initialized live update sink');
+        return null;
+    }
+    async update(text) {
+        return this.publish(text, 'progress');
+    }
+    async complete(text) {
+        return this.publish(text, 'final');
+    }
+    async fail(text) {
+        return this.publish(text, 'final');
+    }
+    async publish(text, mode) {
+        const formatted = (0, markdown_1.formatTeamsText)(text);
+        if (this.activityId) {
+            logger_1.logger.debug(`[TaskLiveUpdates][Teams] Updating existing activityId=${this.activityId}`);
+            const updated = await this.teams.updateMessage({
+                conversationReference: this.conversationReference,
+                activityId: this.activityId,
+                text: formatted,
+            });
+            if (updated?.ok)
+                return null;
+            logger_1.logger.warn(`[TaskLiveUpdates][Teams] updateMessage failed for activityId=${this.activityId} error=${updated?.error || 'unknown_error'}; falling back to sendMessage`);
+        }
+        logger_1.logger.info('[TaskLiveUpdates][Teams] Posting live update message');
+        const posted = await this.teams.sendMessage({
+            conversationReference: this.conversationReference,
+            text: formatted,
+            ...(this.replyToActivityId ? { replyToActivityId: this.replyToActivityId } : {}),
+        });
+        if (posted?.ok && posted.activityId) {
+            const previousActivityId = this.activityId;
+            this.activityId = posted.activityId;
+            if (mode === 'final' && previousActivityId && previousActivityId !== posted.activityId) {
+                const deleted = await this.teams.deleteMessage({
+                    conversationReference: this.conversationReference,
+                    activityId: previousActivityId,
+                });
+                if (!deleted) {
+                    logger_1.logger.warn(`[TaskLiveUpdates][Teams] deleteMessage failed for stale live update activityId=${previousActivityId}`);
+                }
+                else {
+                    logger_1.logger.info(`[TaskLiveUpdates][Teams] Removed stale live update activityId=${previousActivityId} after final fallback post`);
+                }
+            }
+            return {
+                ref: {
+                    teams_live_update_activity_id: posted.activityId,
+                },
+            };
+        }
+        return null;
+    }
+}
+exports.TeamsTaskLiveUpdateSink = TeamsTaskLiveUpdateSink;
+
+
+/***/ }),
+
+/***/ 71872:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.TelegramTaskLiveUpdateSink = void 0;
+const markdown_1 = __nccwpck_require__(21506);
+const logger_1 = __nccwpck_require__(86999);
+class TelegramTaskLiveUpdateSink {
+    telegram;
+    chatId;
+    replyToMessageId;
+    messageThreadId;
+    kind = 'telegram';
+    messageId;
+    constructor(telegram, chatId, replyToMessageId, messageThreadId, initialMessageId) {
+        this.telegram = telegram;
+        this.chatId = chatId;
+        this.replyToMessageId = replyToMessageId;
+        this.messageThreadId = messageThreadId;
+        this.messageId = initialMessageId;
+    }
+    async start() {
+        logger_1.logger.debug(`[TaskLiveUpdates][Telegram] Initialized live update sink for chat=${this.chatId} reply_to=${this.replyToMessageId}`);
+        return null;
+    }
+    async update(text) {
+        return this.publish(text, 'progress');
+    }
+    async complete(text) {
+        return this.publish(text, 'final');
+    }
+    async fail(text) {
+        return this.publish(text, 'final');
+    }
+    async publish(text, mode) {
+        const formatted = (0, markdown_1.formatTelegramText)(text);
+        if (this.messageId) {
+            logger_1.logger.debug(`[TaskLiveUpdates][Telegram] Updating existing message id=${this.messageId} in chat=${this.chatId}`);
+            const updated = await this.telegram.editMessageText({
+                chat_id: this.chatId,
+                message_id: this.messageId,
+                text: formatted,
+                parse_mode: 'HTML',
+            });
+            if (updated?.ok)
+                return null;
+            logger_1.logger.warn(`[TaskLiveUpdates][Telegram] editMessageText failed for message_id=${this.messageId} error=${updated?.error || 'unknown_error'}; falling back to sendMessage`);
+        }
+        logger_1.logger.info(`[TaskLiveUpdates][Telegram] Posting live update message in chat=${this.chatId} reply_to=${this.replyToMessageId}`);
+        const posted = await this.telegram.sendMessage({
+            chat_id: this.chatId,
+            text: formatted,
+            parse_mode: 'HTML',
+            reply_to_message_id: this.replyToMessageId,
+            ...(this.messageThreadId ? { message_thread_id: this.messageThreadId } : {}),
+        });
+        if (posted?.ok && posted.message_id) {
+            const previousMessageId = this.messageId;
+            this.messageId = posted.message_id;
+            if (mode === 'final' && previousMessageId && previousMessageId !== posted.message_id) {
+                const deleted = await this.telegram.deleteMessage({
+                    chat_id: this.chatId,
+                    message_id: previousMessageId,
+                });
+                if (!deleted) {
+                    logger_1.logger.warn(`[TaskLiveUpdates][Telegram] deleteMessage failed for stale live update message_id=${previousMessageId}`);
+                }
+                else {
+                    logger_1.logger.info(`[TaskLiveUpdates][Telegram] Removed stale live update message id=${previousMessageId} after final fallback post`);
+                }
+            }
+            return {
+                ref: {
+                    telegram_live_update_chat_id: String(this.chatId),
+                    telegram_live_update_message_id: posted.message_id,
+                    ...(this.messageThreadId ? { telegram_live_update_thread_id: this.messageThreadId } : {}),
+                },
+            };
+        }
+        return null;
+    }
+}
+exports.TelegramTaskLiveUpdateSink = TelegramTaskLiveUpdateSink;
+
+
+/***/ }),
+
+/***/ 5893:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.TaskLiveUpdateManager = exports.DEFAULT_TASK_LIVE_UPDATE_PROMPT = exports.DEFAULT_TASK_LIVE_UPDATE_MODEL = exports.DEFAULT_TASK_LIVE_UPDATE_STALL_FALLBACK_SECONDS = exports.DEFAULT_TASK_LIVE_UPDATE_METADATA_REFRESH_SECONDS = exports.DEFAULT_TASK_LIVE_UPDATE_FIRST_UPDATE_DELAY_SECONDS = exports.DEFAULT_TASK_LIVE_UPDATE_MAX_TRACE_CHARS = exports.DEFAULT_TASK_LIVE_UPDATE_INTERVAL_SECONDS = void 0;
+exports.resolveTaskLiveUpdatesConfig = resolveTaskLiveUpdatesConfig;
+exports.isFrontendLiveUpdatesEnabled = isFrontendLiveUpdatesEnabled;
+exports.summarizeTaskProgress = summarizeTaskProgress;
+const crypto_1 = __importDefault(__nccwpck_require__(76982));
+const logger_1 = __nccwpck_require__(86999);
+const trace_serializer_1 = __nccwpck_require__(48666);
+exports.DEFAULT_TASK_LIVE_UPDATE_INTERVAL_SECONDS = 10;
+exports.DEFAULT_TASK_LIVE_UPDATE_MAX_TRACE_CHARS = 12_000;
+exports.DEFAULT_TASK_LIVE_UPDATE_FIRST_UPDATE_DELAY_SECONDS = 10;
+exports.DEFAULT_TASK_LIVE_UPDATE_METADATA_REFRESH_SECONDS = 5;
+exports.DEFAULT_TASK_LIVE_UPDATE_STALL_FALLBACK_SECONDS = 60;
+exports.DEFAULT_TASK_LIVE_UPDATE_MODEL = 'gemini-3.1-flash-lite-preview';
+const DEFAULT_TASK_LIVE_UPDATE_STALL_NOTICE = '_No new meaningful progress is visible yet. Some steps can stay quiet for up to 5 minutes before there is new news._';
+exports.DEFAULT_TASK_LIVE_UPDATE_PROMPT = `You are generating a short live progress update for a user while an AI task is still running.
+
+This is NOT the final answer.
+Do NOT answer the user's original request.
+Do NOT write the final solution.
+Do NOT explain the topic in full.
+Do NOT provide a root cause, recommendation, summary of findings, or conclusion.
+Even if you think you already know the answer, do NOT give it here.
+
+You will receive:
+- the user's original request
+- the previous progress update, if any
+- timing metadata for this run
+- the latest execution trace snapshot
+
+Your job is to produce a concise status update that tells the user only:
+- the overall progress so far
+- the last meaningful action that finished
+- what the agent is doing right now
+- what it is likely waiting on, if anything
+
+Rules:
+- This is a STATUS UPDATE, not the final answer
+- Never answer the user's request directly
+- Never switch into explanation mode
+- Never write a complete answer, even partially
+- Keep it short: exactly 4 short bullet points
+- Use the exact bullet labels below
+- Do NOT generate timing metadata lines
+- Do NOT generate task_id lines
+- Timing metadata is provided only so you understand task pace and recency
+- The system will append timing and task metadata separately
+- Prefer concrete progress over generic wording
+- Mention the most recent completed action before the current action
+- Do not claim completion unless the task is actually done
+- Do not mention internal implementation details unless they help explain the current work
+- Avoid repeating the previous update verbatim
+- Do not use code fences
+- Plain markdown text only
+
+Required output format:
+- Progress: <very short overall progress statement, not a final answer>
+- Last done: <most recent completed action>
+- Now: <current action in progress>
+- Waiting on: <tool, search, model, user input, or "nothing blocking right now">
+
+Trace interpretation rules:
+- Translate internal trace phases into user-meaningful progress, do not just repeat raw span names
+- If the trace shows routing or classify work, describe that as understanding the request and choosing the right path
+- If the trace shows setup-projects, build-config, or loading context, describe that as preparing the workspace or gathering context
+- If the trace shows search, extract, code-explorer, or file inspection, describe that as investigating the codebase
+- If the trace shows engineer work, edits, tests, PR creation, or command execution, describe that as implementing or verifying changes
+- If the trace shows completion prompts, final answer generation, summarization, final validation, or output rendering, describe that as validating findings and preparing the final response
+- If the trace shows waiting on a long AI request, delegate, tool call, or sandboxed child task, describe that as waiting for analysis or validation to finish
+
+If you are tempted to answer the user's question, stop and convert that into:
+- what was learned so far
+- what was just completed
+- what is still being checked
+
+Bad update example:
+- "API rate limiting works by..."
+
+Good update example:
+- "Progress: identified the gateway components involved in rate limiting"
+- "Last done: found the middleware files and session manager entry points"
+- "Now: tracing the enforcement path through the gateway"
+- "Waiting on: search results for the limiter implementation details"`;
+function resolveTaskLiveUpdatesConfig(config) {
+    if (!config)
+        return null;
+    if (config === true) {
+        return {
+            enabled: true,
+            intervalSeconds: exports.DEFAULT_TASK_LIVE_UPDATE_INTERVAL_SECONDS,
+            model: exports.DEFAULT_TASK_LIVE_UPDATE_MODEL,
+            prompt: exports.DEFAULT_TASK_LIVE_UPDATE_PROMPT,
+            initialMessage: '',
+            maxTraceChars: exports.DEFAULT_TASK_LIVE_UPDATE_MAX_TRACE_CHARS,
+        };
+    }
+    if (config.enabled === false)
+        return null;
+    return {
+        enabled: true,
+        intervalSeconds: Math.max(1, Math.floor(config.interval_seconds || exports.DEFAULT_TASK_LIVE_UPDATE_INTERVAL_SECONDS)),
+        model: config.model || exports.DEFAULT_TASK_LIVE_UPDATE_MODEL,
+        provider: config.provider,
+        prompt: config.prompt || exports.DEFAULT_TASK_LIVE_UPDATE_PROMPT,
+        initialMessage: config.initial_message || '',
+        maxTraceChars: Math.max(1000, Math.floor(config.max_trace_chars || exports.DEFAULT_TASK_LIVE_UPDATE_MAX_TRACE_CHARS)),
+    };
+}
+function isFrontendLiveUpdatesEnabled(config, frontend) {
+    if (!config)
+        return false;
+    if (config === true)
+        return true;
+    if (config.enabled === false)
+        return false;
+    const frontendCfg = config.frontends?.[frontend];
+    if (frontendCfg?.enabled === false)
+        return false;
+    return true;
+}
+class TaskLiveUpdateManager {
+    ctx;
+    deps;
+    timer;
+    firstTickTimer;
+    metadataRefreshTimer;
+    running = false;
+    started = false;
+    completed = false;
+    startedAt = new Date();
+    lastUpdateText;
+    lastUpdateAt;
+    lastTraceSnapshot;
+    lastPostedMessage;
+    lastStallFallbackAt;
+    lastUpdateKind = 'semantic';
+    lastSkillMetadata;
+    constructor(ctx, deps) {
+        this.ctx = ctx;
+        this.deps = {
+            summarizeProgress: deps?.summarizeProgress || summarizeTaskProgress,
+            serializeTrace: deps?.serializeTrace || defaultSerializeTrace,
+            extractSkillMetadata: deps?.extractSkillMetadata || extractTraceSkillMetadata,
+        };
+    }
+    async start() {
+        if (this.started)
+            return;
+        this.started = true;
+        try {
+            const started = await this.ctx.sink.start();
+            this.recordSinkRef(started);
+            logger_1.logger.info(`[TaskLiveUpdates] Started for task ${this.ctx.taskId}; first update in ${exports.DEFAULT_TASK_LIVE_UPDATE_FIRST_UPDATE_DELAY_SECONDS}s, interval=${this.ctx.config.intervalSeconds}s, provider=${this.ctx.config.provider || 'default'}, model=${this.ctx.config.model}`);
+        }
+        catch (err) {
+            logger_1.logger.warn(`[TaskLiveUpdates] Failed to initialize live updates for task ${this.ctx.taskId}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        this.firstTickTimer = setTimeout(() => {
+            void this.runFirstTick();
+        }, exports.DEFAULT_TASK_LIVE_UPDATE_FIRST_UPDATE_DELAY_SECONDS * 1000);
+        if (typeof this.firstTickTimer?.unref === 'function') {
+            this.firstTickTimer.unref();
+        }
+    }
+    async complete(finalText) {
+        if (this.completed)
+            return;
+        this.completed = true;
+        this.stop();
+        try {
+            logger_1.logger.info(`[TaskLiveUpdates] Publishing final success update for task ${this.ctx.taskId}`);
+            const result = await this.ctx.sink.complete(this.decorateText(finalText));
+            this.recordSinkRef(result);
+            this.ctx.appendHistory?.(finalText, 'completed');
+        }
+        catch (err) {
+            logger_1.logger.warn(`[TaskLiveUpdates] Failed to publish final update for task ${this.ctx.taskId}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    async fail(finalText) {
+        if (this.completed)
+            return;
+        this.completed = true;
+        this.stop();
+        try {
+            logger_1.logger.info(`[TaskLiveUpdates] Publishing final failure update for task ${this.ctx.taskId}`);
+            const result = await this.ctx.sink.fail(this.decorateText(finalText));
+            this.recordSinkRef(result);
+            this.ctx.appendHistory?.(finalText, 'failed');
+        }
+        catch (err) {
+            logger_1.logger.warn(`[TaskLiveUpdates] Failed to publish failure update for task ${this.ctx.taskId}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    stop() {
+        if (this.firstTickTimer) {
+            clearTimeout(this.firstTickTimer);
+            this.firstTickTimer = undefined;
+        }
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = undefined;
+        }
+        if (this.metadataRefreshTimer) {
+            clearInterval(this.metadataRefreshTimer);
+            this.metadataRefreshTimer = undefined;
+        }
+    }
+    async tick() {
+        if (this.completed || this.running)
+            return;
+        const traceState = this.getTraceState();
+        if (!traceState.traceRef && !traceState.traceId) {
+            logger_1.logger.debug(`[TaskLiveUpdates] Skipping tick for task ${this.ctx.taskId}: no trace reference available yet`);
+            return;
+        }
+        this.running = true;
+        try {
+            const traceRef = traceState.traceRef || traceState.traceId;
+            const traceSnapshot = await this.deps.serializeTrace(traceRef, this.ctx.config.maxTraceChars, traceState.traceId);
+            if (this.completed) {
+                logger_1.logger.debug(`[TaskLiveUpdates] Aborting in-flight tick for task ${this.ctx.taskId}: task already completed`);
+                return;
+            }
+            if (!traceSnapshot || traceSnapshot === '(no trace data available)') {
+                logger_1.logger.debug(`[TaskLiveUpdates] Skipping tick for task ${this.ctx.taskId}: no trace data available yet (traceRef=${traceRef})`);
+                return;
+            }
+            if (traceSnapshot === this.lastTraceSnapshot) {
+                await this.maybePublishStallFallback(traceSnapshot, traceState.traceId);
+                logger_1.logger.debug(`[TaskLiveUpdates] Skipping tick for task ${this.ctx.taskId}: trace snapshot unchanged`);
+                return;
+            }
+            const summary = await this.deps.summarizeProgress({
+                requestText: this.ctx.requestText,
+                previousUpdate: this.lastUpdateText,
+                traceSnapshot,
+                config: this.ctx.config,
+                startedAt: this.startedAt,
+                now: new Date(),
+                elapsedSeconds: Math.max(0, Math.floor((Date.now() - this.startedAt.getTime()) / 1000)),
+                previousUpdateAt: this.lastUpdateAt,
+                secondsSincePreviousUpdate: this.lastUpdateAt
+                    ? Math.max(0, Math.floor((Date.now() - this.lastUpdateAt.getTime()) / 1000))
+                    : undefined,
+            });
+            if (this.completed) {
+                logger_1.logger.debug(`[TaskLiveUpdates] Aborting in-flight tick for task ${this.ctx.taskId}: task already completed after summarization`);
+                return;
+            }
+            const cleaned = summary?.trim();
+            if (!cleaned || cleaned === this.lastUpdateText) {
+                await this.maybePublishStallFallback(traceSnapshot, traceState.traceId);
+                logger_1.logger.debug(`[TaskLiveUpdates] Skipping tick for task ${this.ctx.taskId}: summary empty or unchanged`);
+                this.lastTraceSnapshot = traceSnapshot;
+                return;
+            }
+            logger_1.logger.info(`[TaskLiveUpdates] Publishing progress update for task ${this.ctx.taskId}: ${cleaned.slice(0, 160)}`);
+            this.lastSkillMetadata = await this.deps.extractSkillMetadata(traceRef, traceState.traceId);
+            this.lastUpdateKind = 'semantic';
+            const message = this.decorateProgressText(cleaned, {
+                elapsedSeconds: Math.max(0, Math.floor((Date.now() - this.startedAt.getTime()) / 1000)),
+                previousUpdateAt: this.lastUpdateAt,
+                secondsSincePreviousUpdate: this.lastUpdateAt
+                    ? Math.max(0, Math.floor((Date.now() - this.lastUpdateAt.getTime()) / 1000))
+                    : undefined,
+                activatedSkills: this.lastSkillMetadata?.activatedSkills,
+            }, traceState.traceId);
+            const result = await this.ctx.sink.update(message);
+            this.recordSinkRef(result);
+            this.ctx.appendHistory?.(cleaned, 'progress');
+            this.lastUpdateText = cleaned;
+            this.lastUpdateAt = new Date();
+            this.lastTraceSnapshot = traceSnapshot;
+            this.lastPostedMessage = message;
+            this.lastStallFallbackAt = undefined;
+        }
+        catch (err) {
+            logger_1.logger.warn(`[TaskLiveUpdates] Progress update failed for task ${this.ctx.taskId}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    async runFirstTick() {
+        if (this.completed)
+            return;
+        logger_1.logger.debug(`[TaskLiveUpdates] Running first scheduled tick for task ${this.ctx.taskId}`);
+        await this.tick();
+        if (this.completed)
+            return;
+        this.timer = setInterval(() => {
+            void this.tick();
+        }, this.ctx.config.intervalSeconds * 1000);
+        if (typeof this.timer?.unref === 'function') {
+            this.timer.unref();
+        }
+        this.metadataRefreshTimer = setInterval(() => {
+            void this.refreshProgressMetadata();
+        }, exports.DEFAULT_TASK_LIVE_UPDATE_METADATA_REFRESH_SECONDS * 1000);
+        if (typeof this.metadataRefreshTimer?.unref === 'function') {
+            this.metadataRefreshTimer.unref();
+        }
+    }
+    recordSinkRef(result) {
+        if (result?.ref)
+            this.ctx.onPostedRef?.(result.ref);
+    }
+    getTraceState() {
+        const resolved = this.ctx.resolveTraceState?.();
+        return {
+            traceRef: resolved?.traceRef || this.ctx.traceRef,
+            traceId: resolved?.traceId || this.ctx.traceId,
+        };
+    }
+    decorateText(text, _traceId) {
+        if (!this.ctx.includeTraceId)
+            return text;
+        if (text.includes(`task_id: ${this.ctx.taskId}`))
+            return text;
+        return `${text}\n\n\`task_id: ${this.ctx.taskId}\``;
+    }
+    decorateProgressText(text, timing, traceId) {
+        const normalized = normalizeProgressSummary(text);
+        const blocks = [
+            '*Live Update*',
+            '_Current task is still running. This message updates in place until the final answer is ready._',
+            this.lastUpdateKind === 'stall' ? DEFAULT_TASK_LIVE_UPDATE_STALL_NOTICE : '',
+            normalized,
+            formatProgressMetadata(timing),
+        ].filter(Boolean);
+        return this.decorateText(blocks.join('\n\n'), traceId);
+    }
+    async refreshProgressMetadata() {
+        if (this.completed || this.running || !this.lastUpdateText)
+            return;
+        const traceState = this.getTraceState();
+        const message = this.decorateProgressText(this.lastUpdateText, {
+            elapsedSeconds: Math.max(0, Math.floor((Date.now() - this.startedAt.getTime()) / 1000)),
+            previousUpdateAt: this.lastUpdateAt,
+            secondsSincePreviousUpdate: this.lastUpdateAt
+                ? Math.max(0, Math.floor((Date.now() - this.lastUpdateAt.getTime()) / 1000))
+                : undefined,
+            activatedSkills: this.lastSkillMetadata?.activatedSkills,
+        }, traceState.traceId);
+        if (!message || message === this.lastPostedMessage)
+            return;
+        if (this.completed)
+            return;
+        try {
+            logger_1.logger.debug(`[TaskLiveUpdates] Refreshing metadata-only live update for task ${this.ctx.taskId}`);
+            const result = await this.ctx.sink.update(message);
+            this.recordSinkRef(result);
+            this.lastPostedMessage = message;
+        }
+        catch (err) {
+            logger_1.logger.warn(`[TaskLiveUpdates] Metadata refresh failed for task ${this.ctx.taskId}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    async maybePublishStallFallback(traceSnapshot, traceId) {
+        if (this.completed)
+            return;
+        const now = new Date();
+        if (this.lastStallFallbackAt &&
+            now.getTime() - this.lastStallFallbackAt.getTime() <
+                exports.DEFAULT_TASK_LIVE_UPDATE_STALL_FALLBACK_SECONDS * 1000) {
+            return;
+        }
+        if (this.lastUpdateAt &&
+            now.getTime() - this.lastUpdateAt.getTime() <
+                exports.DEFAULT_TASK_LIVE_UPDATE_STALL_FALLBACK_SECONDS * 1000) {
+            return;
+        }
+        this.lastSkillMetadata = await this.deps.extractSkillMetadata(this.getTraceState().traceRef || traceId || '', traceId);
+        const fallback = buildStallFallbackSummary(traceSnapshot, this.lastUpdateText);
+        const baseText = this.lastUpdateText || fallback;
+        if (!baseText)
+            return;
+        logger_1.logger.info(`[TaskLiveUpdates] Publishing stall notice for task ${this.ctx.taskId}: ${baseText.slice(0, 160)}`);
+        this.lastUpdateKind = 'stall';
+        if (this.completed)
+            return;
+        const message = this.decorateProgressText(baseText, {
+            elapsedSeconds: Math.max(0, Math.floor((Date.now() - this.startedAt.getTime()) / 1000)),
+            previousUpdateAt: this.lastUpdateAt,
+            secondsSincePreviousUpdate: this.lastUpdateAt
+                ? Math.max(0, Math.floor((Date.now() - this.lastUpdateAt.getTime()) / 1000))
+                : undefined,
+            activatedSkills: this.lastSkillMetadata?.activatedSkills,
+        }, traceId);
+        if (message === this.lastPostedMessage) {
+            this.lastStallFallbackAt = now;
+            return;
+        }
+        const result = await this.ctx.sink.update(message);
+        this.recordSinkRef(result);
+        if (!this.lastUpdateText) {
+            this.ctx.appendHistory?.(baseText, 'progress');
+            this.lastUpdateText = baseText;
+            this.lastUpdateAt = now;
+        }
+        this.lastPostedMessage = message;
+        this.lastStallFallbackAt = now;
+    }
+}
+exports.TaskLiveUpdateManager = TaskLiveUpdateManager;
+async function defaultSerializeTrace(traceRef, maxChars, traceId) {
+    logger_1.logger.debug(`[TaskLiveUpdates] Serializing trace for progress update (traceRef=${traceRef}, traceId=${traceId || '-'}, sink=${process.env.VISOR_TELEMETRY_SINK || 'auto'})`);
+    return (0, trace_serializer_1.serializeTraceForPrompt)(traceRef, maxChars, undefined, undefined, traceId);
+}
+async function summarizeTaskProgress(input) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { ProbeAgent } = __nccwpck_require__(83841);
+    const agentOptions = {
+        sessionId: `visor-task-progress-${Date.now()}-${crypto_1.default.randomUUID().slice(0, 8)}`,
+        systemPrompt: input.config.prompt,
+        maxIterations: 1,
+        disableTools: true,
+    };
+    if (input.config.model)
+        agentOptions.model = input.config.model;
+    if (input.config.provider)
+        agentOptions.provider = input.config.provider;
+    const agent = new ProbeAgent(agentOptions);
+    if (typeof agent.initialize === 'function') {
+        await agent.initialize();
+    }
+    const userPrompt = [
+        `<user_request>\n${input.requestText}\n</user_request>`,
+        input.previousUpdate
+            ? `<previous_update>\n${input.previousUpdate}\n</previous_update>`
+            : '<previous_update>(none)</previous_update>',
+        `<timing>\nstarted_at: ${input.startedAt.toISOString()}\nnow: ${input.now.toISOString()}\nelapsed: ${formatDuration(input.elapsedSeconds)}\nlast_update_at: ${input.previousUpdateAt ? input.previousUpdateAt.toISOString() : '(none)'}\ntime_since_last_update: ${input.previousUpdateAt ? formatDuration(input.secondsSincePreviousUpdate || 0) : '(none)'}\n</timing>`,
+        `<execution_trace>\n${input.traceSnapshot}\n</execution_trace>`,
+    ].join('\n\n');
+    const response = await agent.answer(userPrompt);
+    const cleaned = response
+        .replace(/^```(?:markdown|md|text)?\s*\n?/i, '')
+        .replace(/\n?```\s*$/m, '')
+        .trim();
+    return cleaned || null;
+}
+function formatDuration(totalSeconds) {
+    const seconds = Math.max(0, Math.floor(totalSeconds));
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const remainingSeconds = seconds % 60;
+    const parts = [];
+    if (hours > 0)
+        parts.push(`${hours}h`);
+    if (minutes > 0)
+        parts.push(`${minutes}m`);
+    if (remainingSeconds > 0 || parts.length === 0)
+        parts.push(`${remainingSeconds}s`);
+    return parts.join(' ');
+}
+function normalizeProgressSummary(text) {
+    const wantedLabels = ['Progress', 'Last done', 'Now', 'Waiting on'];
+    const lines = text
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(Boolean);
+    const matched = new Map();
+    for (const line of lines) {
+        const match = line.match(/^-?\s*(Progress|Last done|Now|Waiting on|Timing)\s*:\s*(.+)$/i);
+        if (!match)
+            continue;
+        const label = match[1].toLowerCase();
+        if (label === 'timing')
+            continue;
+        const canonical = wantedLabels.find(item => item.toLowerCase() === label);
+        if (canonical && !matched.has(canonical)) {
+            matched.set(canonical, match[2].trim());
+        }
+    }
+    if (matched.size === wantedLabels.length) {
+        return wantedLabels.map(label => `- ${label}: ${matched.get(label)}`).join('\n');
+    }
+    const withoutTiming = lines.filter(line => !/^-?\s*(Timing|Metadata|Trace)\s*:/i.test(line));
+    return withoutTiming.join('\n');
+}
+function formatProgressMetadata(timing) {
+    const parts = [`elapsed ${formatDuration(timing.elapsedSeconds)}`];
+    if (timing.previousUpdateAt) {
+        parts.push(`previous update ${formatDuration(timing.secondsSincePreviousUpdate || 0)} ago`);
+        parts.push(`at ${timing.previousUpdateAt.toISOString()}`);
+    }
+    else {
+        parts.push('first live update');
+    }
+    if (timing.activatedSkills && timing.activatedSkills.length > 0) {
+        parts.push(`activated skills ${formatSkillList(timing.activatedSkills)}`);
+    }
+    return `_Metadata: ${parts.join(' | ')}_`;
+}
+function formatSkillList(skills) {
+    const normalized = dedupeStrings(skills);
+    if (normalized.length <= 4)
+        return normalized.join(', ');
+    return `${normalized.slice(0, 4).join(', ')} +${normalized.length - 4} more`;
+}
+function dedupeStrings(values) {
+    if (!Array.isArray(values))
+        return [];
+    return [...new Set(values.map(value => String(value || '').trim()).filter(Boolean))];
+}
+async function extractTraceSkillMetadata(traceRef, traceId) {
+    if (!traceRef && !traceId)
+        return undefined;
+    try {
+        const spans = await (0, trace_serializer_1.fetchTraceSpans)(traceId || traceRef);
+        if (!spans.length)
+            return undefined;
+        const routeIntentSpan = spans.find(span => span.attributes['visor.check.id'] === 'route-intent');
+        const buildConfigSpan = spans.find(span => span.attributes['visor.check.id'] === 'build-config');
+        const classifySpan = spans.find(span => span.attributes['visor.check.id'] === 'classify');
+        const routeIntentOutput = parseJsonAttribute(routeIntentSpan?.attributes['visor.check.output']);
+        const classifyOutput = parseJsonAttribute(classifySpan?.attributes['visor.check.output']);
+        const buildConfigOutput = parseJsonAttribute(buildConfigSpan?.attributes['visor.check.output']);
+        const activatedSkills = dedupeStrings(Array.isArray(buildConfigOutput?.activated_skills)
+            ? buildConfigOutput.activated_skills
+            : undefined);
+        const fallbackActivatedSkills = dedupeStrings((Array.isArray(routeIntentOutput?.skills) ? routeIntentOutput.skills : undefined) ||
+            (Array.isArray(classifyOutput?.skills) ? classifyOutput.skills : undefined));
+        const finalActivatedSkills = activatedSkills.length > 0 ? activatedSkills : fallbackActivatedSkills;
+        if (!finalActivatedSkills.length)
+            return undefined;
+        return { activatedSkills: finalActivatedSkills };
+    }
+    catch (err) {
+        logger_1.logger.debug(`[TaskLiveUpdates] Failed to extract skill metadata from trace: ${err instanceof Error ? err.message : String(err)}`);
+        return undefined;
+    }
+}
+function parseJsonAttribute(value) {
+    if (typeof value !== 'string' || !value.trim())
+        return undefined;
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function buildStallFallbackSummary(traceSnapshot, previousUpdate) {
+    const lastDone = extractProgressField(previousUpdate, 'Last done') ||
+        'continuing from the last completed analysis step';
+    const lower = traceSnapshot.toLowerCase();
+    let now = 'waiting for the current analysis step to finish';
+    let waitingOn = 'the current analysis step to complete';
+    if (lower.includes('search.delegate') ||
+        lower.includes('tool: search') ||
+        lower.includes('search(')) {
+        now = 'running or waiting on the current code search step';
+        waitingOn = 'search results and downstream analysis to finish';
+    }
+    else if (lower.includes('extract(') || lower.includes('tool: extract')) {
+        now = 'extracting the relevant code or documentation context';
+        waitingOn = 'the extract step to finish and be interpreted';
+    }
+    else if (lower.includes('engineer-task') || lower.includes('engineer')) {
+        now = 'waiting on the current implementation or validation step';
+        waitingOn = 'the engineer workflow to finish the current step';
+    }
+    else if (lower.includes('ai.request') ||
+        lower.includes('gemini') ||
+        lower.includes('claude') ||
+        lower.includes('openai')) {
+        now = 'waiting on the current model analysis step';
+        waitingOn = 'the active model response to finish';
+    }
+    else if (lower.includes('bash(') || lower.includes('go test') || lower.includes('npm test')) {
+        now = 'running or waiting on command-based validation';
+        waitingOn = 'the current command or test run to finish';
+    }
+    else if (lower.includes('setup-projects') || lower.includes('build-config')) {
+        now = 'preparing the workspace and loading the required context';
+        waitingOn = 'workspace setup and context loading to finish';
+    }
+    return [
+        '- Progress: still working through the same step; no new completed action yet',
+        `- Last done: ${lastDone}`,
+        `- Now: ${now}`,
+        `- Waiting on: ${waitingOn}`,
+    ].join('\n');
+}
+function extractProgressField(text, label) {
+    if (!text)
+        return undefined;
+    const match = text.match(new RegExp(`(?:^|\\n)-?\\s*${escapeRegExp(label)}\\s*:\\s*(.+)$`, 'im'));
+    return match?.[1]?.trim() || undefined;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+
 /***/ }),
 
 /***/ 38570:
@@ -293503,6 +294365,7 @@ exports.getTaskProgressToolDefinition = getTaskProgressToolDefinition;
 exports.isTaskProgressTool = isTaskProgressTool;
 exports.handleTaskProgressAction = handleTaskProgressAction;
 const logger_1 = __nccwpck_require__(86999);
+const task_trace_resolution_1 = __nccwpck_require__(4018);
 // ---------------------------------------------------------------------------
 // Tool definition
 // ---------------------------------------------------------------------------
@@ -293627,8 +294490,9 @@ async function handleTrace(taskId, taskStore) {
     if (!task) {
         return { success: false, error: `Task not found: ${taskId}` };
     }
-    const traceId = task.metadata?.trace_id;
-    const traceFile = task.metadata?.trace_file;
+    const resolvedTrace = await (0, task_trace_resolution_1.resolveTaskTraceReference)(task.metadata);
+    const traceId = resolvedTrace.traceId;
+    const traceFile = resolvedTrace.traceFile;
     if (!traceId && !traceFile) {
         // No trace available — return basic status info
         const trigger = task.metadata?.slack_trigger_text || '';
@@ -293648,17 +294512,12 @@ async function handleTrace(taskId, taskStore) {
         };
     }
     // Lazy-import the trace serializer to avoid circular dependencies
-    const { serializeTraceForPrompt, readTraceIdFromFile } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(48666)));
-    // Get trace ID from file if needed
-    let resolvedTraceId = traceId;
-    if (!resolvedTraceId && traceFile) {
-        resolvedTraceId = await readTraceIdFromFile(traceFile);
-    }
+    const { serializeTraceForPrompt } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(48666)));
     // Get the task response for full output context
     const taskResponse = task.status?.message?.parts?.[0]?.text;
     // Serialize the trace — use generous char limit for AI consumption
-    const traceTree = await serializeTraceForPrompt(traceFile || resolvedTraceId || '', 8000, // generous limit so AI gets good context
-    undefined, taskResponse, resolvedTraceId || undefined);
+    const traceTree = await serializeTraceForPrompt(resolvedTrace.primaryRef || '', 8000, // generous limit so AI gets good context
+    undefined, taskResponse, traceId || undefined);
     const trigger = task.metadata?.slack_trigger_text || '';
     const elapsed = timeSince(task.created_at);
     const lines = [
@@ -294429,6 +295288,68 @@ class TaskStreamManager {
 exports.TaskStreamManager = TaskStreamManager;
 
 
+/***/ }),
+
+/***/ 4018:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.resolveTaskTraceReference = resolveTaskTraceReference;
+async function resolveTaskTraceReference(metadata) {
+    const traceFile = metadata?.trace_file;
+    let traceId = metadata?.trace_id;
+    if (!traceId && traceFile) {
+        try {
+            const { readTraceIdFromFile } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(48666)));
+            traceId = (await readTraceIdFromFile(traceFile)) || undefined;
+        }
+        catch {
+            traceId = undefined;
+        }
+    }
+    return {
+        traceId,
+        traceFile,
+        primaryRef: traceId || traceFile || undefined,
+    };
+}
+
+
 /***/ }),
 
 /***/ 5932:
@@ -296786,13 +297707,17 @@ fallbackTraceId) {
     const remoteTraceId = fallbackTraceId ||
         (!isFilePath ? traceIdOrPath : (await readTraceIdFromFile(traceIdOrPath)) || undefined);
     const preferLocalFirst = backendOrder[0] === 'file';
+    logger_1.logger.debug(`[TraceSerializer] serializeTraceForPrompt ref=${traceIdOrPath} remoteTraceId=${remoteTraceId || '-'} backendOrder=${backendOrder.join('>')}`);
     if (preferLocalFirst && localTracePath) {
+        logger_1.logger.debug(`[TraceSerializer] Trying local trace file first: ${localTracePath}`);
         spans = await fetchTraceSpans(localTracePath, { ...cfg, type: 'file' });
     }
     if (spans.length === 0 && remoteTraceId) {
+        logger_1.logger.debug(`[TraceSerializer] Trying remote trace backends for trace_id=${remoteTraceId}`);
         spans = await fetchTraceSpans(remoteTraceId, cfg);
     }
     if (spans.length === 0 && localTracePath) {
+        logger_1.logger.debug(`[TraceSerializer] Falling back to local trace file: ${localTracePath}`);
         spans = await fetchTraceSpans(localTracePath, { ...cfg, type: 'file' });
     }
     if (spans.length === 0) {
@@ -296889,6 +297814,9 @@ function renderSpanYaml(tree, allSpans, opts) {
 }
 function renderYamlNode(node, indent, lines, dedup, renderContext, fallbackIntent, fullOutput, maxLen, parentSpan) {
     if (shouldSkipLifecycleSpan(node.span, renderContext)) {
+        for (const child of node.children) {
+            renderYamlNode(child, indent, lines, dedup, renderContext, fallbackIntent, fullOutput, maxLen, parentSpan);
+        }
         return;
     }
     const pad = '  '.repeat(indent);
@@ -297151,7 +298079,10 @@ function renderYamlOutput(rawOutput, pad, label, spanName, dedup, lines, fullOut
     // and {text: "..."} → render text inline
     if (typeof obj === 'object' && !Array.isArray(obj)) {
         const keys = Object.keys(obj);
-        if (keys.length === 1 && typeof obj[keys[0]] === 'object' && obj[keys[0]] !== null) {
+        if (keys.length === 1 &&
+            typeof obj[keys[0]] === 'object' &&
+            obj[keys[0]] !== null &&
+            !Array.isArray(obj[keys[0]])) {
             obj = obj[keys[0]]; // unwrap {answer: {...}} → {...}
         }
         // If single text key, render inline
@@ -297844,7 +298775,7 @@ function formatJsonPreview(obj, maxLen) {
     let len = 2; // for { }
     for (const [key, val] of Object.entries(obj)) {
         // Skip internal/verbose keys
-        if (key === 'raw' || key === 'skills' || key === 'tags')
+        if (key === 'raw' || key === 'tags')
             continue;
         let valStr;
         if (val === null || val === undefined)
@@ -297865,8 +298796,15 @@ function formatJsonPreview(obj, maxLen) {
                 .trim();
             valStr = `"${truncate(clean.split('\n')[0], Math.min(80, maxLen / 3))}"`;
         }
-        else if (Array.isArray(val))
-            valStr = `[${val.length}]`;
+        else if (Array.isArray(val)) {
+            if (val.every(item => typeof item === 'string') &&
+                val.join(', ').length < Math.min(120, maxLen / 2)) {
+                valStr = `[${val.join(', ')}]`;
+            }
+            else {
+                valStr = `[${val.length}]`;
+            }
+        }
         else if (typeof val === 'object')
             valStr = `{${Object.keys(val).length} keys}`;
         else
@@ -298217,6 +299155,8 @@ const path_1 = __importDefault(__nccwpck_require__(16928));
 const logger_1 = __nccwpck_require__(86999);
 const lazy_otel_1 = __nccwpck_require__(21084);
 const instance_id_1 = __nccwpck_require__(89942);
+const task_live_updates_1 = __nccwpck_require__(5893);
+const task_trace_resolution_1 = __nccwpck_require__(4018);
 function getPackageVersion() {
     try {
         return (__nccwpck_require__(8330).version) || 'dev';
@@ -298269,106 +299209,189 @@ async function trackExecution(opts, executor) {
         },
     });
     const instanceId = (0, instance_id_1.getInstanceId)();
-    taskStore.updateTaskState(task.id, 'working');
-    taskStore.claimTask(task.id, instanceId);
-    logger_1.logger.info(`[TaskTracking] Task ${task.id} started (source=${source}, workflow=${workflowId || '-'}, instance=${instanceId})`);
-    // Heartbeat: periodically touch updated_at so stale-task detection
-    // can distinguish live tasks from orphans (works across nodes).
-    const HEARTBEAT_INTERVAL = 60_000; // 1 minute
-    const heartbeatTimer = setInterval(() => {
-        try {
-            taskStore.heartbeat(task.id);
-        }
-        catch {
-            // best-effort — don't crash the task over a heartbeat failure
-        }
-    }, HEARTBEAT_INTERVAL);
-    try {
-        const result = await executor();
-        // Now that execution is done, capture the trace ID from the active span.
-        // At task creation time the span may not have been active yet, so we
-        // update metadata post-execution to ensure trace_id is stored.
-        try {
-            const activeTraceId = lazy_otel_1.trace.getActiveSpan()?.spanContext().traceId;
-            const persistedTraceId = (activeTraceId && activeTraceId !== '' ? activeTraceId : undefined) ||
-                (await readTraceIdFromFallbackFile(traceFile));
-            if (persistedTraceId && !task.metadata?.trace_id) {
-                taskStore.updateMetadata(task.id, { trace_id: persistedTraceId });
+    return await logger_1.logger.withTaskContext(task.id, async () => {
+        taskStore.updateTaskState(task.id, 'working');
+        taskStore.claimTask(task.id, instanceId);
+        logger_1.logger.info(`[TaskTracking] Task ${task.id} started (source=${source}, workflow=${workflowId || '-'}, instance=${instanceId})`);
+        const liveUpdateConfig = (0, task_live_updates_1.resolveTaskLiveUpdatesConfig)(opts.liveUpdates?.config);
+        const initialTraceId = lazy_otel_1.trace.getActiveSpan()?.spanContext().traceId ||
+            task.metadata?.trace_id;
+        if (initialTraceId && !task.metadata?.trace_id) {
+            try {
+                taskStore.updateMetadata(task.id, { trace_id: initialTraceId });
             }
+            catch {
+                // best-effort only
+            }
+        }
+        const initialResolvedTrace = await (0, task_trace_resolution_1.resolveTaskTraceReference)({
+            trace_id: initialTraceId || task.metadata?.trace_id,
+            trace_file: task.metadata?.trace_file,
+        });
+        const liveUpdateManager = liveUpdateConfig && opts.liveUpdates?.sink
+            ? new task_live_updates_1.TaskLiveUpdateManager({
+                taskId: task.id,
+                requestText: messageText,
+                traceRef: initialResolvedTrace.primaryRef,
+                traceId: initialResolvedTrace.traceId,
+                includeTraceId: opts.liveUpdates?.includeTraceId === true,
+                sink: opts.liveUpdates.sink,
+                config: liveUpdateConfig,
+                resolveTraceState: () => {
+                    let current;
+                    try {
+                        current = taskStore.getTask(task.id);
+                    }
+                    catch {
+                        return {
+                            traceRef: initialResolvedTrace.primaryRef,
+                            traceId: initialResolvedTrace.traceId,
+                        };
+                    }
+                    return {
+                        traceRef: current?.metadata?.trace_id ||
+                            current?.metadata?.trace_file ||
+                            initialResolvedTrace.primaryRef,
+                        traceId: current?.metadata?.trace_id,
+                    };
+                },
+                onPostedRef: ref => {
+                    try {
+                        taskStore.updateMetadata(task.id, ref);
+                    }
+                    catch {
+                        // best-effort only
+                    }
+                },
+                appendHistory: (text, stage) => {
+                    try {
+                        taskStore.appendHistory(task.id, {
+                            message_id: crypto_1.default.randomUUID(),
+                            role: 'agent',
+                            parts: [{ text }],
+                            metadata: { kind: 'task_live_update', stage, source },
+                        });
+                    }
+                    catch {
+                        // best-effort only
+                    }
+                },
+            })
+            : null;
+        if (liveUpdateConfig && !opts.liveUpdates?.sink) {
+            logger_1.logger.debug(`[TaskTracking] Live updates requested for task ${task.id} but no sink is available for source=${source}`);
         }
-        catch {
-            // best-effort — don't fail the task over metadata
+        else if (liveUpdateManager) {
+            logger_1.logger.info(`[TaskTracking] Live updates enabled for task ${task.id} (source=${source})`);
         }
-        // Extract AI response text from the result.
-        // result.reviewSummary.history is keyed by checkId with arrays of outputs.
-        // We want the LAST check's text output (the final AI response), not the
-        // first (which is typically the intent router).
-        let responseText = 'Execution completed';
+        // Heartbeat: periodically touch updated_at so stale-task detection
+        // can distinguish live tasks from orphans (works across nodes).
+        const HEARTBEAT_INTERVAL = 60_000; // 1 minute
+        const heartbeatTimer = setInterval(() => {
+            try {
+                taskStore.heartbeat(task.id);
+            }
+            catch {
+                // best-effort — don't crash the task over a heartbeat failure
+            }
+        }, HEARTBEAT_INTERVAL);
         try {
-            const history = result?.reviewSummary?.history;
-            if (history) {
-                const entries = Object.values(history);
-                // Iterate in reverse — last check output is the final response
-                for (let i = entries.length - 1; i >= 0; i--) {
-                    const outputs = entries[i];
-                    if (!Array.isArray(outputs))
-                        continue;
-                    // Within a check, look at the last output first too
-                    for (let j = outputs.length - 1; j >= 0; j--) {
-                        const text = outputs[j]?.text;
-                        if (typeof text === 'string' && text.trim().length > 0) {
-                            responseText = text.trim();
-                            break;
+            if (liveUpdateManager) {
+                await liveUpdateManager.start();
+            }
+            const result = await executor();
+            // Now that execution is done, capture the trace ID from the active span.
+            // At task creation time the span may not have been active yet, so we
+            // update metadata post-execution to ensure trace_id is stored.
+            try {
+                const activeTraceId = lazy_otel_1.trace.getActiveSpan()?.spanContext().traceId;
+                const persistedTraceId = (activeTraceId && activeTraceId !== '' ? activeTraceId : undefined) ||
+                    (await readTraceIdFromFallbackFile(traceFile));
+                if (persistedTraceId && !task.metadata?.trace_id) {
+                    taskStore.updateMetadata(task.id, { trace_id: persistedTraceId });
+                }
+            }
+            catch {
+                // best-effort — don't fail the task over metadata
+            }
+            // Extract AI response text from the result.
+            // result.reviewSummary.history is keyed by checkId with arrays of outputs.
+            // We want the LAST check's text output (the final AI response), not the
+            // first (which is typically the intent router).
+            let responseText = 'Execution completed';
+            try {
+                const history = result?.reviewSummary?.history;
+                if (history) {
+                    const entries = Object.values(history);
+                    // Iterate in reverse — last check output is the final response
+                    for (let i = entries.length - 1; i >= 0; i--) {
+                        const outputs = entries[i];
+                        if (!Array.isArray(outputs))
+                            continue;
+                        // Within a check, look at the last output first too
+                        for (let j = outputs.length - 1; j >= 0; j--) {
+                            const text = outputs[j]?.text;
+                            if (typeof text === 'string' && text.trim().length > 0) {
+                                responseText = text.trim();
+                                break;
+                            }
                         }
+                        if (responseText !== 'Execution completed')
+                            break;
                     }
-                    if (responseText !== 'Execution completed')
-                        break;
                 }
             }
+            catch {
+                // ignore extraction errors
+            }
+            const completedMsg = {
+                message_id: crypto_1.default.randomUUID(),
+                role: 'agent',
+                parts: [{ text: responseText }],
+            };
+            try {
+                taskStore.updateTaskState(task.id, 'completed', completedMsg);
+                logger_1.logger.info(`[TaskTracking] Task ${task.id} completed`);
+            }
+            catch (stateErr) {
+                // Another process (e.g. stale sweep) may have already marked this task as failed.
+                // Log a warning but do NOT re-throw — the execution itself succeeded.
+                logger_1.logger.warn(`[TaskTracking] Task ${task.id} completed but state transition failed: ${stateErr instanceof Error ? stateErr.message : stateErr}`);
+            }
+            // Fire-and-forget LLM evaluation (non-blocking)
+            // Enabled via opts.autoEvaluate (from config.task_evaluate) or VISOR_TASK_EVALUATE env var
+            if (opts.autoEvaluate || process.env.VISOR_TASK_EVALUATE === 'true') {
+                scheduleEvaluation(task.id, taskStore);
+            }
+            if (liveUpdateManager) {
+                await liveUpdateManager.complete(responseText);
+            }
+            return { task, result };
         }
-        catch {
-            // ignore extraction errors
-        }
-        const completedMsg = {
-            message_id: crypto_1.default.randomUUID(),
-            role: 'agent',
-            parts: [{ text: responseText }],
-        };
-        try {
-            taskStore.updateTaskState(task.id, 'completed', completedMsg);
-            logger_1.logger.info(`[TaskTracking] Task ${task.id} completed`);
-        }
-        catch (stateErr) {
-            // Another process (e.g. stale sweep) may have already marked this task as failed.
-            // Log a warning but do NOT re-throw — the execution itself succeeded.
-            logger_1.logger.warn(`[TaskTracking] Task ${task.id} completed but state transition failed: ${stateErr instanceof Error ? stateErr.message : stateErr}`);
-        }
-        // Fire-and-forget LLM evaluation (non-blocking)
-        // Enabled via opts.autoEvaluate (from config.task_evaluate) or VISOR_TASK_EVALUATE env var
-        if (opts.autoEvaluate || process.env.VISOR_TASK_EVALUATE === 'true') {
-            scheduleEvaluation(task.id, taskStore);
-        }
-        return { task, result };
-    }
-    catch (err) {
-        const errorText = err instanceof Error ? err.message : String(err);
-        const failMessage = {
-            message_id: crypto_1.default.randomUUID(),
-            role: 'agent',
-            parts: [{ text: errorText }],
-        };
-        try {
-            taskStore.updateTaskState(task.id, 'failed', failMessage);
-            logger_1.logger.info(`[TaskTracking] Task ${task.id} failed: ${errorText}`);
+        catch (err) {
+            const errorText = err instanceof Error ? err.message : String(err);
+            const failMessage = {
+                message_id: crypto_1.default.randomUUID(),
+                role: 'agent',
+                parts: [{ text: errorText }],
+            };
+            try {
+                taskStore.updateTaskState(task.id, 'failed', failMessage);
+                logger_1.logger.info(`[TaskTracking] Task ${task.id} failed: ${errorText}`);
+            }
+            catch {
+                // ignore double-failure
+            }
+            if (liveUpdateManager) {
+                await liveUpdateManager.fail(`:warning: ${errorText}`);
+            }
+            throw err; // re-throw to preserve original behavior
         }
-        catch {
-            // ignore double-failure
+        finally {
+            clearInterval(heartbeatTimer);
+            liveUpdateManager?.stop();
         }
-        throw err; // re-throw to preserve original behavior
-    }
-    finally {
-        clearInterval(heartbeatTimer);
-    }
+    });
 }
 // ---------------------------------------------------------------------------
 // Non-blocking auto-evaluation
@@ -298376,14 +299399,16 @@ async function trackExecution(opts, executor) {
 function scheduleEvaluation(taskId, taskStore) {
     // Delay slightly to let OTEL spans flush before we try to read the trace
     setTimeout(async () => {
-        try {
-            const { evaluateAndStore } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(53635)));
-            await evaluateAndStore(taskId, taskStore);
-            logger_1.logger.info(`[TaskEvaluator] Auto-evaluation completed for task ${taskId}`);
-        }
-        catch (err) {
-            logger_1.logger.warn(`[TaskEvaluator] Auto-evaluation failed for task ${taskId}: ${err instanceof Error ? err.message : err}`);
-        }
+        await logger_1.logger.withTaskContext(taskId, async () => {
+            try {
+                const { evaluateAndStore } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(53635)));
+                await evaluateAndStore(taskId, taskStore);
+                logger_1.logger.info(`[TaskEvaluator] Auto-evaluation completed for task ${taskId}`);
+            }
+            catch (err) {
+                logger_1.logger.warn(`[TaskEvaluator] Auto-evaluation failed for task ${taskId}: ${err instanceof Error ? err.message : err}`);
+            }
+        });
     }, 5000);
 }
 
@@ -302814,6 +303839,8 @@ async function main() {
                 authTokenEnv: getArg('--auth-token-env'),
                 tlsCert: getArg('--tls-cert'),
                 tlsKey: getArg('--tls-key'),
+                asyncMode: mcpArgs.includes('--async'),
+                longPollTimeout: getArg('--poll-timeout') ? Number(getArg('--poll-timeout')) : undefined,
             };
             const { startMcpServer } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(93143)));
             await startMcpServer(mcpOptions);
@@ -304288,6 +305315,7 @@ class CLI {
             .option('--mcp', 'Enable MCP HTTP server runner (composable, requires --mcp-auth-token)')
             .option('--mcp-port <port>', 'Port for MCP HTTP server (default: 8080)', value => parseInt(value, 10))
             .option('--mcp-auth-token <token>', 'Bearer token for MCP HTTP server authentication')
+            .option('--mcp-async', 'Enable async job mode for MCP (start_job/get_job pattern)')
             .option('-c, --check <type>', 'Specify check type (can be used multiple times)', this.collectChecks, [])
             .option('-o, --output <format>', 'Output format (table, json, markdown, sarif)', 'table')
             .option('--output-file <path>', 'Write formatted output to a file instead of stdout')
@@ -304428,6 +305456,7 @@ class CLI {
                 mcp: Boolean(options.mcp),
                 mcpPort: options.mcpPort,
                 mcpAuthToken: options.mcpAuthToken,
+                mcpAsync: Boolean(options.mcpAsync),
                 tui: Boolean(options.tui),
                 keepWorkspace: Boolean(options.keepWorkspace),
                 workspacePath: options.workspacePath,
@@ -306362,6 +307391,7 @@ class ConfigManager {
                             'sandbox',
                             'sandbox_defaults',
                             'policy',
+                            'task_live_updates',
                             // Workflow metadata fields used when configs are imported as reusable workflows
                             'id',
                             'name',
@@ -313538,6 +314568,8 @@ exports.SlackFrontend = void 0;
 const client_1 = __nccwpck_require__(67681);
 const markdown_1 = __nccwpck_require__(34907);
 const lazy_otel_1 = __nccwpck_require__(21084);
+const task_live_updates_1 = __nccwpck_require__(5893);
+const logger_1 = __nccwpck_require__(86999);
 class SlackFrontend {
     name = 'slack';
     subs = [];
@@ -313751,7 +314783,19 @@ class SlackFrontend {
             return false;
         }
     }
+    isLiveTaskUpdatesMode(ctx) {
+        try {
+            if (!this.getInboundSlackPayload(ctx))
+                return false;
+            return (0, task_live_updates_1.isFrontendLiveUpdatesEnabled)(ctx.config?.task_live_updates, 'slack');
+        }
+        catch {
+            return false;
+        }
+    }
     async maybePostError(ctx, title, message, checkId) {
+        if (this.isLiveTaskUpdatesMode(ctx))
+            return;
         if (this.errorNotified)
             return;
         return this.postErrorToSlack(ctx, title, message, checkId);
@@ -313761,6 +314805,8 @@ class SlackFrontend {
      * Used for fatal/shutdown errors that must always reach the user.
      */
     async forcePostError(ctx, title, message, checkId) {
+        if (this.isLiveTaskUpdatesMode(ctx))
+            return;
         return this.postErrorToSlack(ctx, title, message, checkId);
     }
     async postErrorToSlack(ctx, title, message, checkId) {
@@ -313784,9 +314830,9 @@ class SlackFrontend {
         if (message)
             text += `\n${message}`;
         if (this.isTelemetryEnabled(ctx)) {
-            const traceInfo = this.getTraceInfo() || this.cachedTraceInfo;
-            if (traceInfo?.traceId) {
-                text += `\n\n\`trace_id: ${traceInfo.traceId}\``;
+            const suffix = this.getExecutionReferenceSuffix();
+            if (suffix) {
+                text += `\n\n${suffix}`;
             }
         }
         const formattedText = (0, markdown_1.formatSlackText)(text);
@@ -313821,6 +314867,8 @@ class SlackFrontend {
     }
     async maybePostExecutionFailure(ctx, checkId, result) {
         try {
+            if (this.isLiveTaskUpdatesMode(ctx))
+                return;
             if (this.errorNotified)
                 return;
             const cfg = ctx.config || {};
@@ -313930,6 +314978,8 @@ class SlackFrontend {
      */
     async maybePostDirectReply(ctx, checkId, result) {
         try {
+            if (this.isLiveTaskUpdatesMode(ctx))
+                return;
             const cfg = ctx.config || {};
             const checkCfg = cfg.checks?.[checkId];
             if (!checkCfg)
@@ -314108,9 +315158,8 @@ class SlackFrontend {
             const telemetryEnabled = telemetryCfg === true ||
                 (telemetryCfg && typeof telemetryCfg === 'object' && telemetryCfg.enabled === true);
             if (telemetryEnabled) {
-                const traceInfo = this.getTraceInfo() || this.cachedTraceInfo;
-                if (traceInfo?.traceId) {
-                    const suffix = `\`trace_id: ${traceInfo.traceId}\``;
+                const suffix = this.getExecutionReferenceSuffix();
+                if (suffix) {
                     decoratedText = `${decoratedText}\n\n${suffix}`;
                 }
             }
@@ -314157,6 +315206,20 @@ class SlackFrontend {
             return null;
         }
     }
+    getExecutionReferenceSuffix() {
+        try {
+            const taskId = logger_1.logger.getCurrentTaskId();
+            if (taskId)
+                return `\`task_id: ${taskId}\``;
+            const traceInfo = this.getTraceInfo() || this.cachedTraceInfo;
+            if (traceInfo?.traceId)
+                return `\`trace_id: ${traceInfo.traceId}\``;
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
 }
 exports.SlackFrontend = SlackFrontend;
 
@@ -314172,6 +315235,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.TeamsFrontend = void 0;
 const client_1 = __nccwpck_require__(55391);
 const markdown_1 = __nccwpck_require__(37349);
+const task_live_updates_1 = __nccwpck_require__(5893);
 class TeamsFrontend {
     name = 'teams';
     subs = [];
@@ -314280,6 +315344,8 @@ class TeamsFrontend {
                 return;
             if (checkCfg.criticality === 'internal')
                 return;
+            if ((0, task_live_updates_1.isFrontendLiveUpdatesEnabled)(cfg.task_live_updates, 'teams'))
+                return;
             // For AI checks, only post simple schemas
             if (isAi) {
                 const schema = checkCfg.schema;
@@ -314360,6 +315426,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.TelegramFrontend = void 0;
 const client_1 = __nccwpck_require__(68148);
 const markdown_1 = __nccwpck_require__(21506);
+const task_live_updates_1 = __nccwpck_require__(5893);
 class TelegramFrontend {
     name = 'telegram';
     subs = [];
@@ -314548,6 +315615,8 @@ class TelegramFrontend {
                 return;
             if (checkCfg.criticality === 'internal')
                 return;
+            if ((0, task_live_updates_1.isFrontendLiveUpdatesEnabled)(cfg.task_live_updates, 'telegram'))
+                return;
             // For AI checks, only post simple schemas
             if (isAi) {
                 const schema = checkCfg.schema;
@@ -315039,6 +316108,17 @@ exports.configSchema = {
                     ],
                     description: 'Automatically evaluate completed tasks using an LLM judge. Requires task_tracking to be enabled. Runs asynchronously after task completion. Set to `true` for defaults, or provide an object to configure.',
                 },
+                task_live_updates: {
+                    anyOf: [
+                        {
+                            type: 'boolean',
+                        },
+                        {
+                            $ref: '#/definitions/TaskLiveUpdatesConfig',
+                        },
+                    ],
+                    description: 'Live progress updates for long-running tracked tasks on supported frontends.',
+                },
             },
             required: ['version'],
             patternProperties: {
@@ -315910,7 +316990,7 @@ exports.configSchema = {
                     description: 'Arguments/inputs for the workflow',
                 },
                 overrides: {
-                    $ref: '#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-15521-30601-src_types_config.ts-0-61047%3E%3E',
+                    $ref: '#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-15521-30601-src_types_config.ts-0-62422%3E%3E',
                     description: 'Override specific step configurations in the workflow',
                 },
                 output_mapping: {
@@ -315926,7 +317006,7 @@ exports.configSchema = {
                     description: 'Config file path - alternative to workflow ID (loads a Visor config file as workflow)',
                 },
                 workflow_overrides: {
-                    $ref: '#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-15521-30601-src_types_config.ts-0-61047%3E%3E',
+                    $ref: '#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-15521-30601-src_types_config.ts-0-62422%3E%3E',
                     description: 'Alias for overrides - workflow step overrides (backward compatibility)',
                 },
                 ref: {
@@ -316654,7 +317734,7 @@ exports.configSchema = {
                     description: 'Custom output name (defaults to workflow name)',
                 },
                 overrides: {
-                    $ref: '#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-15521-30601-src_types_config.ts-0-61047%3E%3E',
+                    $ref: '#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-15521-30601-src_types_config.ts-0-62422%3E%3E',
                     description: 'Step overrides',
                 },
                 output_mapping: {
@@ -316669,13 +317749,13 @@ exports.configSchema = {
                 '^x-': {},
             },
         },
-        'Record<string,Partial<interface-src_types_config.ts-15521-30601-src_types_config.ts-0-61047>>': {
+        'Record<string,Partial<interface-src_types_config.ts-15521-30601-src_types_config.ts-0-62422>>': {
             type: 'object',
             additionalProperties: {
-                $ref: '#/definitions/Partial%3Cinterface-src_types_config.ts-15521-30601-src_types_config.ts-0-61047%3E',
+                $ref: '#/definitions/Partial%3Cinterface-src_types_config.ts-15521-30601-src_types_config.ts-0-62422%3E',
             },
         },
-        'Partial<interface-src_types_config.ts-15521-30601-src_types_config.ts-0-61047>': {
+        'Partial<interface-src_types_config.ts-15521-30601-src_types_config.ts-0-62422>': {
             type: 'object',
             additionalProperties: false,
         },
@@ -318608,6 +319688,102 @@ exports.configSchema = {
                 '^x-': {},
             },
         },
+        TaskLiveUpdatesConfig: {
+            type: 'object',
+            properties: {
+                enabled: {
+                    type: 'boolean',
+                    description: 'Enable live task progress updates (default: true when config object is present)',
+                },
+                interval_seconds: {
+                    type: 'number',
+                    description: 'Update interval in seconds (default: 10)',
+                },
+                model: {
+                    type: 'string',
+                    description: 'LLM model to use for progress summarization',
+                },
+                provider: {
+                    type: 'string',
+                    description: 'AI provider to use for progress summarization',
+                },
+                prompt: {
+                    type: 'string',
+                    description: 'Custom system prompt for the progress summarizer',
+                },
+                initial_message: {
+                    type: 'string',
+                    description: 'Immediate placeholder text posted before the first summary is generated',
+                },
+                max_trace_chars: {
+                    type: 'number',
+                    description: 'Maximum serialized trace characters passed into the summarizer (default: 12000)',
+                },
+                frontends: {
+                    type: 'object',
+                    properties: {
+                        slack: {
+                            type: 'object',
+                            properties: {
+                                enabled: {
+                                    type: 'boolean',
+                                },
+                            },
+                            additionalProperties: false,
+                            patternProperties: {
+                                '^x-': {},
+                            },
+                        },
+                        telegram: {
+                            type: 'object',
+                            properties: {
+                                enabled: {
+                                    type: 'boolean',
+                                },
+                            },
+                            additionalProperties: false,
+                            patternProperties: {
+                                '^x-': {},
+                            },
+                        },
+                        teams: {
+                            type: 'object',
+                            properties: {
+                                enabled: {
+                                    type: 'boolean',
+                                },
+                            },
+                            additionalProperties: false,
+                            patternProperties: {
+                                '^x-': {},
+                            },
+                        },
+                        whatsapp: {
+                            type: 'object',
+                            properties: {
+                                enabled: {
+                                    type: 'boolean',
+                                },
+                            },
+                            additionalProperties: false,
+                            patternProperties: {
+                                '^x-': {},
+                            },
+                        },
+                    },
+                    additionalProperties: false,
+                    description: 'Per-frontend enablement overrides',
+                    patternProperties: {
+                        '^x-': {},
+                    },
+                },
+            },
+            additionalProperties: false,
+            description: 'Live task progress updates for supported interactive frontends.\n\nWhen enabled, Visor posts a "working on it" placeholder and periodically updates the same message using a cheap internal LLM summary of the current execution trace. The final answer replaces that same message.',
+            patternProperties: {
+                '^x-': {},
+            },
+        },
     },
 };
 exports["default"] = exports.configSchema;
@@ -322522,6 +323698,7 @@ exports.configureLoggerFromCli = configureLoggerFromCli;
  * - Supports levels: silent < error < warn < info < verbose < debug
  * - Routes logs to stderr to keep stdout clean for machine-readable output
  */
+const node_async_hooks_1 = __nccwpck_require__(16698);
 const lazy_otel_1 = __nccwpck_require__(21084);
 function levelToNumber(level) {
     switch (level) {
@@ -322549,6 +323726,7 @@ const OTEL_SEVERITY = {
     debug: 5, // DEBUG
 };
 class Logger {
+    taskContextStorage = new node_async_hooks_1.AsyncLocalStorage();
     level = 'info';
     isJsonLike = false;
     isTTY = typeof process !== 'undefined' ? !!process.stderr.isTTY : false;
@@ -322605,11 +323783,25 @@ class Logger {
         }
         return true;
     }
-    getTraceSuffix(msg) {
+    withTaskContext(taskId, fn) {
+        const current = this.taskContextStorage.getStore() || {};
+        return this.taskContextStorage.run({ ...current, taskId }, fn);
+    }
+    getCurrentTaskId() {
+        return this.taskContextStorage.getStore()?.taskId;
+    }
+    getContextSuffix(msg) {
         if (!msg)
             return '';
-        if (msg.includes('trace_id=') || msg.includes('trace_id:'))
+        if (msg.includes('task_id=') ||
+            msg.includes('task_id:') ||
+            msg.includes('trace_id=') ||
+            msg.includes('trace_id:')) {
             return '';
+        }
+        const taskId = this.getCurrentTaskId();
+        if (taskId)
+            return ` [task_id=${taskId}]`;
         try {
             const span = lazy_otel_1.trace.getSpan(lazy_otel_1.context.active()) || lazy_otel_1.trace.getActiveSpan();
             const ctx = span?.spanContext?.();
@@ -322639,12 +323831,14 @@ class Logger {
                 return;
             const span = lazy_otel_1.trace.getSpan(lazy_otel_1.context.active()) || lazy_otel_1.trace.getActiveSpan();
             const spanCtx = span?.spanContext?.();
+            const taskId = this.getCurrentTaskId();
             this.otelLogger.emit({
                 severityNumber: OTEL_SEVERITY[level] || 9,
                 severityText: level.toUpperCase(),
                 body: msg,
                 attributes: {
                     'visor.logger': true,
+                    ...(taskId ? { task_id: taskId } : {}),
                     ...(spanCtx?.traceId ? { trace_id: spanCtx.traceId, span_id: spanCtx.spanId } : {}),
                 },
             });
@@ -322655,7 +323849,7 @@ class Logger {
     }
     write(msg, level) {
         // Always route to stderr to keep stdout clean for results
-        const suffix = this.getTraceSuffix(msg);
+        const suffix = this.getContextSuffix(msg);
         const decoratedMsg = suffix ? `${msg}${suffix}` : msg;
         const lvl = level || 'info';
         // Emit to OTel Logs pipeline (non-blocking, best-effort)
@@ -322781,6 +323975,337 @@ function configureLoggerFromCli(options) {
 }
 
 
+/***/ }),
+
+/***/ 70279:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+/**
+ * MCP Job Manager — async job pattern for long-running MCP tool calls.
+ *
+ * Claude Code and other MCP clients have timeout issues with long-running tools.
+ * This module provides a `start_job` / `get_job` pattern: the tool call returns
+ * immediately with a job_id, and the client polls `get_job` until done.
+ *
+ * This is a thin wrapper over the existing TaskStore — jobs are persisted as
+ * regular Visor tasks (visible via `visor tasks list`, `visor tasks show`).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.JobManager = void 0;
+const crypto_1 = __importDefault(__nccwpck_require__(76982));
+const logger_1 = __nccwpck_require__(86999);
+/** Map TaskState → JobStatus for the MCP response. */
+function taskStateToJobStatus(state) {
+    switch (state) {
+        case 'submitted':
+            return 'queued';
+        case 'working':
+        case 'input_required':
+        case 'auth_required':
+            return 'running';
+        case 'completed':
+            return 'completed';
+        case 'failed':
+        case 'canceled':
+        case 'rejected':
+            return 'failed';
+        default:
+            return 'running';
+    }
+}
+/**
+ * Build the standardized MCP job response from an AgentTask.
+ */
+function buildResponse(task) {
+    const status = taskStateToJobStatus(task.status.state);
+    const done = status === 'completed' || status === 'failed';
+    const polling = done
+        ? { recommended_next_action: 'none', recommended_delay_seconds: 0 }
+        : { recommended_next_action: 'get_job', recommended_delay_seconds: 0 };
+    // Extract result text from task status message or artifacts
+    let result = null;
+    if (status === 'completed') {
+        // The completed status message contains the AI response text
+        const statusText = task.status.message?.parts?.[0]?.text;
+        if (statusText) {
+            result = statusText;
+        }
+        // Also check artifacts for richer output
+        if (task.artifacts.length > 0) {
+            const artifactTexts = task.artifacts
+                .flatMap(a => a.parts)
+                .filter(p => p.text)
+                .map(p => p.text);
+            if (artifactTexts.length > 0 && !result) {
+                result = artifactTexts.join('\n');
+            }
+        }
+    }
+    // Extract error from failed status message
+    let error = null;
+    if (status === 'failed' && task.status.message) {
+        const errorText = task.status.message.parts?.[0]?.text || 'Unknown error';
+        error = {
+            code: 'EXECUTION_ERROR',
+            message: errorText,
+            retryable: true,
+        };
+    }
+    // Build progress
+    let progress;
+    switch (status) {
+        case 'queued':
+            progress = { percent: 0, step: 'queued', message: 'Job accepted and queued' };
+            break;
+        case 'running':
+            progress = { percent: null, step: 'running', message: 'Job is executing' };
+            break;
+        case 'completed':
+            progress = { percent: 100, step: 'completed', message: 'Job finished successfully' };
+            break;
+        case 'failed':
+            progress = { percent: null, step: 'failed', message: 'The job failed before completion' };
+            break;
+        default:
+            progress = { percent: null, step: status, message: `Job is ${status}` };
+    }
+    // Instructions for the model
+    let userMessage;
+    let nextInstruction;
+    switch (status) {
+        case 'queued':
+            userMessage = 'The job has been queued.';
+            nextInstruction =
+                'Call get_job with this job_id. It will wait up to 59 seconds for the result. If it returns with done still false, call get_job again.';
+            break;
+        case 'running':
+            userMessage = 'The job is still running.';
+            nextInstruction =
+                'Call get_job again with this job_id. It will wait up to 59 seconds for the result. If it returns with done still false, call get_job again.';
+            break;
+        case 'completed':
+            userMessage = 'The result is ready.';
+            nextInstruction = 'Use the result to answer the user.';
+            break;
+        case 'failed':
+            userMessage = 'The job failed.';
+            nextInstruction =
+                'Explain the failure briefly. If the user still wants the result, start a new job.';
+            break;
+        default:
+            userMessage = `Job status: ${status}`;
+            nextInstruction = 'Call get_job again after 10 seconds.';
+    }
+    return {
+        job_id: task.id.slice(0, 8),
+        status,
+        done,
+        progress,
+        polling,
+        result,
+        error,
+        user_message: userMessage,
+        next_instruction_for_model: nextInstruction,
+    };
+}
+/** Build an "expired/not found" response. */
+function buildExpiredResponse(jobId) {
+    return {
+        job_id: jobId,
+        status: 'expired',
+        done: true,
+        progress: { percent: null, step: 'expired', message: 'This job is no longer available' },
+        polling: { recommended_next_action: 'none', recommended_delay_seconds: 0 },
+        result: null,
+        error: { code: 'JOB_EXPIRED', message: 'The job is no longer available', retryable: true },
+        user_message: 'The previous job expired.',
+        next_instruction_for_model: 'If the user still wants the result, start a new job.',
+    };
+}
+/**
+ * Manages async jobs for MCP tool calls, backed by the existing TaskStore.
+ *
+ * Jobs created here are visible via `visor tasks list` and `visor tasks show`.
+ */
+class JobManager {
+    taskStore;
+    longPollTimeoutMs;
+    constructor(taskStore, opts) {
+        this.taskStore = taskStore;
+        this.longPollTimeoutMs = opts?.longPollTimeoutMs ?? 59_000;
+    }
+    /**
+     * Start a new async job. Creates a task, runs the handler in the background,
+     * and returns immediately with the task ID.
+     */
+    startJob(handler, opts) {
+        // Create task via trackExecution pattern (inline, since we need non-blocking)
+        const { getInstanceId } = __nccwpck_require__(89942);
+        const requestMessage = {
+            message_id: crypto_1.default.randomUUID(),
+            role: 'user',
+            parts: [{ text: opts.messageText }],
+        };
+        const task = this.taskStore.createTask({
+            contextId: crypto_1.default.randomUUID(),
+            requestMessage,
+            workflowId: opts.workflowId,
+            requestMetadata: {
+                source: 'mcp',
+                instance_id: getInstanceId(),
+                async_job: true,
+                ...opts.metadata,
+            },
+        });
+        // Transition to working
+        this.taskStore.updateTaskState(task.id, 'working');
+        this.taskStore.claimTask(task.id, getInstanceId());
+        logger_1.logger.info(`[MCP-AsyncJob] Job ${task.id.slice(0, 8)} started (workflow=${opts.workflowId || '-'})`);
+        // Heartbeat timer
+        const heartbeatTimer = setInterval(() => {
+            try {
+                this.taskStore.heartbeat(task.id);
+            }
+            catch {
+                // best-effort
+            }
+        }, 60_000);
+        if (heartbeatTimer.unref)
+            heartbeatTimer.unref();
+        // Run handler in background
+        handler()
+            .then(result => {
+            clearInterval(heartbeatTimer);
+            // Extract response text from the result (same logic as track-execution.ts)
+            let responseText = 'Execution completed';
+            try {
+                // If result is an MCP content response, extract the text
+                const content = result?.content;
+                if (Array.isArray(content)) {
+                    const texts = content.filter((c) => c.type === 'text').map((c) => c.text);
+                    if (texts.length > 0)
+                        responseText = texts.join('\n');
+                }
+                else if (typeof result === 'string') {
+                    responseText = result;
+                }
+                else {
+                    // Try engine result format
+                    const history = result?.reviewSummary?.history;
+                    if (history) {
+                        const entries = Object.values(history);
+                        for (let i = entries.length - 1; i >= 0; i--) {
+                            const outputs = entries[i];
+                            if (!Array.isArray(outputs))
+                                continue;
+                            for (let j = outputs.length - 1; j >= 0; j--) {
+                                const text = outputs[j]?.text;
+                                if (typeof text === 'string' && text.trim().length > 0) {
+                                    responseText = text.trim();
+                                    break;
+                                }
+                            }
+                            if (responseText !== 'Execution completed')
+                                break;
+                        }
+                    }
+                }
+            }
+            catch {
+                // ignore extraction errors
+            }
+            const completedMsg = {
+                message_id: crypto_1.default.randomUUID(),
+                role: 'agent',
+                parts: [{ text: responseText }],
+            };
+            try {
+                this.taskStore.updateTaskState(task.id, 'completed', completedMsg);
+                logger_1.logger.info(`[MCP-AsyncJob] Job ${task.id.slice(0, 8)} completed`);
+            }
+            catch (stateErr) {
+                logger_1.logger.warn(`[MCP-AsyncJob] Job ${task.id.slice(0, 8)} completed but state transition failed: ${stateErr}`);
+            }
+        })
+            .catch(err => {
+            clearInterval(heartbeatTimer);
+            const errorText = err instanceof Error ? err.message : String(err);
+            const failMsg = {
+                message_id: crypto_1.default.randomUUID(),
+                role: 'agent',
+                parts: [{ text: errorText }],
+            };
+            try {
+                this.taskStore.updateTaskState(task.id, 'failed', failMsg);
+                logger_1.logger.info(`[MCP-AsyncJob] Job ${task.id.slice(0, 8)} failed: ${errorText}`);
+            }
+            catch (stateErr) {
+                logger_1.logger.warn(`[MCP-AsyncJob] Job ${task.id.slice(0, 8)} failed but could not update task state: ${stateErr}`);
+            }
+        });
+        return buildResponse(task);
+    }
+    /**
+     * Get the current state of a job by ID (supports both short and full IDs).
+     *
+     * Uses long polling: if the job is still running, waits up to 59 seconds
+     * for it to finish before responding. Returns immediately if the job is
+     * already in a terminal state (completed/failed).
+     */
+    async getJob(jobId) {
+        const resolvedTask = this.resolveTask(jobId);
+        if (!resolvedTask) {
+            return buildExpiredResponse(jobId);
+        }
+        // If already done, return immediately
+        const initialStatus = taskStateToJobStatus(resolvedTask.status.state);
+        if (initialStatus === 'completed' || initialStatus === 'failed') {
+            return buildResponse(resolvedTask);
+        }
+        // Long poll: check every 500ms for up to the configured timeout
+        const POLL_INTERVAL_MS = 500;
+        const MAX_WAIT_MS = this.longPollTimeoutMs;
+        const deadline = Date.now() + MAX_WAIT_MS;
+        while (Date.now() < deadline) {
+            await new Promise(resolve => setTimeout(resolve, POLL_INTERVAL_MS));
+            const task = this.resolveTask(jobId);
+            if (!task) {
+                return buildExpiredResponse(jobId);
+            }
+            const status = taskStateToJobStatus(task.status.state);
+            if (status === 'completed' || status === 'failed') {
+                return buildResponse(task);
+            }
+        }
+        // Timeout — return current state (still running)
+        const finalTask = this.resolveTask(jobId);
+        if (!finalTask) {
+            return buildExpiredResponse(jobId);
+        }
+        return buildResponse(finalTask);
+    }
+    /**
+     * Resolve a task by full UUID or short ID prefix.
+     */
+    resolveTask(jobId) {
+        // Try direct lookup first (full UUID)
+        let task = this.taskStore.getTask(jobId);
+        // If not found and looks like a short ID, search by prefix
+        if (!task && jobId.length < 36) {
+            const { tasks } = this.taskStore.listTasks({ limit: 200 });
+            task = tasks.find(t => t.id.startsWith(jobId)) || null;
+        }
+        return task;
+    }
+}
+exports.JobManager = JobManager;
+
+
 /***/ }),
 
 /***/ 93143:
@@ -323156,75 +324681,143 @@ async function executeWorkflow(args) {
     }
 }
 /**
- * Zod schema for fixed workflow tool parameters (no workflow parameter).
+ * Zod schema for fixed workflow tool parameters (no workflow parameter).
+ */
+exports.FixedWorkflowSchema = zod_1.z.object({
+    message: zod_1.z
+        .string()
+        .optional()
+        .describe('Optional human input message for workflows that include human-input checks. ' +
+        'This is equivalent to the --message CLI argument. Use this to provide context, ' +
+        'instructions, or answers to prompts that the workflow may request.'),
+    checks: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .describe('Optional list of specific check IDs to run from the workflow. ' +
+        'If not provided, all checks defined in the workflow will be executed. ' +
+        'Check IDs are the keys defined under the "checks:" section in the workflow YAML.'),
+    format: zod_1.z
+        .enum(['json', 'markdown', 'table'])
+        .optional()
+        .default('json')
+        .describe('Output format for the results. "json" (default) returns structured data suitable for ' +
+        'programmatic processing. "markdown" returns human-readable formatted output with ' +
+        'severity icons. "table" returns a simple text table format.'),
+});
+/**
+ * Execute a fixed workflow and return formatted results.
+ *
+ * @param args - The tool arguments (without workflow)
+ * @param workflowPath - The pre-resolved workflow path
+ * @returns MCP tool result with content
+ */
+async function executeFixedWorkflow(args, workflowPath) {
+    try {
+        // Build execution context with message for human-input checks
+        const executionContext = {};
+        if (args.message) {
+            executionContext.cliMessage = args.message;
+        }
+        // Call runChecks() from SDK
+        const result = await (0, sdk_1.runChecks)({
+            configPath: workflowPath,
+            checks: args.checks,
+            output: { format: args.format || 'json' },
+            executionContext,
+            cwd: process.cwd(),
+        });
+        // Format output based on requested format
+        const groupedResults = result;
+        const formattedOutput = formatResults(groupedResults, args.format || 'json');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: formattedOutput,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error executing workflow: ${errorMessage}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Get or create a TaskStore for async job mode.
+ * If one is provided in options, use it. Otherwise create a SQLite-backed store.
  */
-exports.FixedWorkflowSchema = zod_1.z.object({
-    message: zod_1.z
-        .string()
-        .optional()
-        .describe('Optional human input message for workflows that include human-input checks. ' +
-        'This is equivalent to the --message CLI argument. Use this to provide context, ' +
-        'instructions, or answers to prompts that the workflow may request.'),
-    checks: zod_1.z
-        .array(zod_1.z.string())
-        .optional()
-        .describe('Optional list of specific check IDs to run from the workflow. ' +
-        'If not provided, all checks defined in the workflow will be executed. ' +
-        'Check IDs are the keys defined under the "checks:" section in the workflow YAML.'),
-    format: zod_1.z
-        .enum(['json', 'markdown', 'table'])
-        .optional()
-        .default('json')
-        .describe('Output format for the results. "json" (default) returns structured data suitable for ' +
-        'programmatic processing. "markdown" returns human-readable formatted output with ' +
-        'severity icons. "table" returns a simple text table format.'),
-});
+async function getOrCreateTaskStore(options) {
+    if (options.taskStore)
+        return options.taskStore;
+    const { SqliteTaskStore } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(24711)));
+    const store = new SqliteTaskStore();
+    await store.initialize();
+    return store;
+}
 /**
- * Execute a fixed workflow and return formatted results.
+ * Register async job tools (start_job / get_job) on an MCP server instance.
+ * Used by both standalone and createHttpMcpServer when asyncMode is enabled.
  *
- * @param args - The tool arguments (without workflow)
- * @param workflowPath - The pre-resolved workflow path
- * @returns MCP tool result with content
+ * Requires a TaskStore for persistence — jobs are stored as regular Visor tasks,
+ * visible via `visor tasks list` and `visor tasks show`.
  */
-async function executeFixedWorkflow(args, workflowPath) {
-    try {
-        // Build execution context with message for human-input checks
-        const executionContext = {};
-        if (args.message) {
-            executionContext.cliMessage = args.message;
-        }
-        // Call runChecks() from SDK
-        const result = await (0, sdk_1.runChecks)({
-            configPath: workflowPath,
-            checks: args.checks,
-            output: { format: args.format || 'json' },
-            executionContext,
-            cwd: process.cwd(),
+async function registerAsyncJobTools(server, resolvedWorkflowPath, toolName, taskStore, longPollTimeoutMs) {
+    const { JobManager } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(70279)));
+    const jobManager = new JobManager(taskStore, { longPollTimeoutMs });
+    const startJobName = toolName === 'run_workflow' || toolName === 'send_message' ? 'start_job' : `start_${toolName}`;
+    const getJobName = 'get_job';
+    const workflowId = resolvedWorkflowPath
+        ? path.basename(resolvedWorkflowPath, path.extname(resolvedWorkflowPath))
+        : undefined;
+    // Build start_job schema based on whether we have a fixed workflow
+    if (resolvedWorkflowPath) {
+        server.tool(startJobName, 'Start a long-running job. Returns immediately with a job_id. ' +
+            'You MUST then call get_job with this job_id. get_job uses long polling (waits up to 59s). ' +
+            'If done is still false, call get_job again.', {
+            message: exports.FixedWorkflowSchema.shape.message,
+            checks: exports.FixedWorkflowSchema.shape.checks,
+            format: exports.FixedWorkflowSchema.shape.format,
+        }, async (args) => {
+            const response = jobManager.startJob(async () => executeFixedWorkflow(args, resolvedWorkflowPath), {
+                messageText: args.message || `Run workflow: ${workflowId}`,
+                workflowId,
+            });
+            return { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] };
         });
-        // Format output based on requested format
-        const groupedResults = result;
-        const formattedOutput = formatResults(groupedResults, args.format || 'json');
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: formattedOutput,
-                },
-            ],
-        };
     }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error executing workflow: ${errorMessage}`,
-                },
-            ],
-            isError: true,
-        };
+    else {
+        server.tool(startJobName, 'Start a long-running job. Returns immediately with a job_id. ' +
+            'You MUST then call get_job with this job_id. get_job uses long polling (waits up to 59s). ' +
+            'If done is still false, call get_job again.', {
+            workflow: exports.RunWorkflowSchema.shape.workflow,
+            message: exports.RunWorkflowSchema.shape.message,
+            checks: exports.RunWorkflowSchema.shape.checks,
+            format: exports.RunWorkflowSchema.shape.format,
+        }, async (args) => {
+            const response = jobManager.startJob(async () => executeWorkflow(args), {
+                messageText: args.message || `Run workflow: ${args.workflow}`,
+                workflowId: args.workflow,
+            });
+            return { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] };
+        });
     }
+    // Register get_job tool
+    server.tool(getJobName, 'Check the status of a running job using long polling. Waits up to 59 seconds for the job to finish. ' +
+        'Returns immediately if the job is already done. If done is still false after the wait, call again.', {
+        job_id: zod_1.z.string().describe('The job ID returned by start_job.'),
+    }, async (args) => {
+        const response = await jobManager.getJob(args.job_id);
+        return { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] };
+    });
 }
 /**
  * Validate a Bearer token from an HTTP request using timing-safe comparison.
@@ -323281,7 +324874,12 @@ async function createHttpMcpServer(options) {
     const server = new mcp_js_1.McpServer({ name: exports.SERVER_INFO.name, version: exports.SERVER_INFO.version }, { capabilities: { tools: {} } });
     const toolName = options.toolName || 'run_workflow';
     const toolDescription = options.toolDescription || exports.RUN_WORKFLOW_DESCRIPTION;
-    if (resolvedWorkflowPath) {
+    if (options.asyncMode) {
+        const taskStore = await getOrCreateTaskStore(options);
+        const longPollMs = options.longPollTimeout ? options.longPollTimeout * 1000 : undefined;
+        await registerAsyncJobTools(server, resolvedWorkflowPath, toolName, taskStore, longPollMs);
+    }
+    else if (resolvedWorkflowPath) {
         server.tool(toolName, toolDescription, {
             message: exports.FixedWorkflowSchema.shape.message,
             checks: exports.FixedWorkflowSchema.shape.checks,
@@ -323472,9 +325070,15 @@ async function startMcpServer(options = {}) {
         // Determine tool name and description
         const toolName = options.toolName || 'run_workflow';
         const toolDescription = options.toolDescription || exports.RUN_WORKFLOW_DESCRIPTION;
-        // Check if we're in fixed workflow mode
-        if (resolvedWorkflowPath) {
-            // Register the tool without workflow parameter
+        // Register tools based on mode
+        if (options.asyncMode) {
+            const taskStore = await getOrCreateTaskStore(options);
+            const longPollMs = options.longPollTimeout ? options.longPollTimeout * 1000 : undefined;
+            await registerAsyncJobTools(server, resolvedWorkflowPath, toolName, taskStore, longPollMs);
+            console.error(`Visor MCP server started in async mode${resolvedWorkflowPath ? ` with fixed workflow: ${resolvedWorkflowPath}` : ''}`);
+        }
+        else if (resolvedWorkflowPath) {
+            // Fixed workflow mode - tool without workflow parameter
             server.tool(toolName, toolDescription, {
                 message: exports.FixedWorkflowSchema.shape.message,
                 checks: exports.FixedWorkflowSchema.shape.checks,
@@ -338660,9 +340264,9 @@ class WorkflowCheckProvider extends check_provider_interface_1.CheckProvider {
         }
         // Log final outputs
         const outputKeys = Object.keys(outputs);
-        const nullOutputs = outputKeys.filter(k => outputs[k] === null || outputs[k] === undefined);
-        if (nullOutputs.length > 0) {
-            logger_1.logger.warn(`[WorkflowProvider] Workflow '${workflow.id}' has null/undefined outputs: [${nullOutputs.join(', ')}]. ` +
+        const undefinedOutputs = outputKeys.filter(k => outputs[k] === undefined);
+        if (undefinedOutputs.length > 0) {
+            logger_1.logger.warn(`[WorkflowProvider] Workflow '${workflow.id}' has undefined outputs: [${undefinedOutputs.join(', ')}]. ` +
                 `This may indicate value_js expressions are not finding expected data.`);
         }
         // Propagate _rawOutput from any step — this carries DSL output() content
@@ -339781,16 +341385,58 @@ class McpServerRunner {
             'Send a message to the Visor assistant. The assistant will process your message ' +
                 'through the configured workflow and return a response. Use this for conversations, ' +
                 'questions, task requests, and any interaction with the assistant.';
-        mcpServer.tool(toolName, toolDescription, {
-            message: zod_1.z.string().describe('The message to send to the assistant.'),
-            session_id: zod_1.z
-                .string()
-                .optional()
-                .describe('Optional conversation session ID for maintaining context across messages. ' +
-                'If omitted, a new session is created. Re-use the same session_id for follow-up messages.'),
-        }, async (args) => {
-            return this.handleMessage(args.message, args.session_id);
-        });
+        if (this.options.asyncMode) {
+            // Async job mode: register start_job and get_job instead of blocking tool
+            // Requires a TaskStore — jobs are stored as regular Visor tasks
+            if (!this.taskStore) {
+                const { SqliteTaskStore } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(24711)));
+                this.taskStore = new SqliteTaskStore();
+                await this.taskStore.initialize();
+            }
+            const { JobManager } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(70279)));
+            const longPollMs = this.options.longPollTimeout
+                ? this.options.longPollTimeout * 1000
+                : undefined;
+            const jobManager = new JobManager(this.taskStore, { longPollTimeoutMs: longPollMs });
+            const startJobName = toolName === 'send_message' ? 'start_job' : `start_${toolName}`;
+            const allChecks = Object.keys(this.cfg.checks || {});
+            mcpServer.tool(startJobName, 'Start a long-running job. Returns immediately with a job_id. ' +
+                'You MUST then call get_job with this job_id. get_job uses long polling (waits up to 59s). ' +
+                'If done is still false, call get_job again.', {
+                message: zod_1.z.string().describe('The message to send to the assistant.'),
+                session_id: zod_1.z
+                    .string()
+                    .optional()
+                    .describe('Optional conversation session ID for maintaining context across messages. ' +
+                    'If omitted, a new session is created.'),
+            }, async (args) => {
+                const response = jobManager.startJob(async () => this.handleMessage(args.message, args.session_id), {
+                    messageText: args.message,
+                    workflowId: allChecks.join(','),
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] };
+            });
+            mcpServer.tool('get_job', 'Check the status of a running job using long polling. Waits up to 59 seconds for the job to finish. ' +
+                'Returns immediately if the job is already done. If done is still false after the wait, call again.', {
+                job_id: zod_1.z.string().describe('The job ID returned by start_job.'),
+            }, async (args) => {
+                const response = await jobManager.getJob(args.job_id);
+                return { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] };
+            });
+            console.error(`Visor MCP frontend started in async job mode`);
+        }
+        else {
+            mcpServer.tool(toolName, toolDescription, {
+                message: zod_1.z.string().describe('The message to send to the assistant.'),
+                session_id: zod_1.z
+                    .string()
+                    .optional()
+                    .describe('Optional conversation session ID for maintaining context across messages. ' +
+                    'If omitted, a new session is created. Re-use the same session_id for follow-up messages.'),
+            }, async (args) => {
+                return this.handleMessage(args.message, args.session_id);
+            });
+        }
         const { transports } = this;
         const handleRequest = async (req, res) => {
             try {
@@ -340814,6 +342460,11 @@ async function createRunner(name, engine, config, options) {
                 tlsKey: mcpAny.tls_key || process.env.VISOR_MCP_TLS_KEY,
                 toolName: mcpAny.tool_name || process.env.VISOR_MCP_TOOL_NAME,
                 toolDescription: mcpAny.tool_description || process.env.VISOR_MCP_TOOL_DESCRIPTION,
+                asyncMode: options.mcpAsync || mcpAny.async_mode || process.env.VISOR_MCP_ASYNC === 'true',
+                longPollTimeout: mcpAny.long_poll_timeout ||
+                    (process.env.VISOR_MCP_POLL_TIMEOUT
+                        ? parseInt(process.env.VISOR_MCP_POLL_TIMEOUT)
+                        : undefined),
             });
         }
         default:
@@ -347987,6 +349638,26 @@ class SlackClient {
                 };
             }
         },
+        delete: async ({ channel, ts }) => {
+            try {
+                const resp = await this.api('chat.delete', { channel, ts });
+                if (!resp || resp.ok !== true) {
+                    const err = (resp && resp.error) || 'unknown_error';
+                    console.warn(`Slack chat.delete failed (non-fatal): error=${err} channel=${channel} ts=${ts}`);
+                    return { ok: false, ts, error: err, data: resp };
+                }
+                return { ok: true, ts: resp.ts || ts, error: undefined, data: resp };
+            }
+            catch (e) {
+                console.warn(`Slack chat.delete threw (non-fatal): channel=${channel} ts=${ts} error=${e instanceof Error ? e.message : String(e)}`);
+                return {
+                    ok: false,
+                    ts,
+                    error: e instanceof Error ? e.message : String(e),
+                    data: undefined,
+                };
+            }
+        },
     };
     async getBotUserId() {
         const resp = await this.api('auth.test', {});
@@ -350110,6 +351781,13 @@ class SlackSocketRunner {
                     });
                     if (this.taskStore) {
                         const { trackExecution } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(7628)));
+                        const { isFrontendLiveUpdatesEnabled } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(5893)));
+                        const { SlackTaskLiveUpdateSink } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(90535)));
+                        const slackTelemetryCfg = cfgForRun?.slack?.telemetry ?? cfgForRun?.telemetry;
+                        const includeTraceId = slackTelemetryCfg === true ||
+                            (slackTelemetryCfg &&
+                                typeof slackTelemetryCfg === 'object' &&
+                                slackTelemetryCfg.enabled === true);
                         await trackExecution({
                             taskStore: this.taskStore,
                             source: 'slack',
@@ -350122,6 +351800,14 @@ class SlackSocketRunner {
                                 slack_user: userId,
                                 slack_trigger_text: String(ev.text || '').slice(0, 500),
                             },
+                            liveUpdates: {
+                                config: cfgForRun.task_live_updates,
+                                includeTraceId,
+                                sink: this.client &&
+                                    isFrontendLiveUpdatesEnabled(cfgForRun.task_live_updates, 'slack')
+                                    ? new SlackTaskLiveUpdateSink(this.client, channelId, threadTs)
+                                    : undefined,
+                            },
                         }, execFn);
                     }
                     else {
@@ -350322,6 +352008,13 @@ class SlackSocketRunner {
                 });
                 if (this.taskStore) {
                     const { trackExecution } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(7628)));
+                    const { isFrontendLiveUpdatesEnabled } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(5893)));
+                    const { SlackTaskLiveUpdateSink } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(90535)));
+                    const slackTelemetryCfg = cfgForRun?.slack?.telemetry ?? cfgForRun?.telemetry;
+                    const includeTraceId = slackTelemetryCfg === true ||
+                        (slackTelemetryCfg &&
+                            typeof slackTelemetryCfg === 'object' &&
+                            slackTelemetryCfg.enabled === true);
                     await trackExecution({
                         taskStore: this.taskStore,
                         source: 'slack',
@@ -350335,6 +352028,14 @@ class SlackSocketRunner {
                             slack_trigger_text: String(ev.text || '').slice(0, 500),
                             trigger_id: id,
                         },
+                        liveUpdates: {
+                            config: cfgForRun.task_live_updates,
+                            includeTraceId,
+                            sink: this.client &&
+                                isFrontendLiveUpdatesEnabled(cfgForRun.task_live_updates, 'slack')
+                                ? new SlackTaskLiveUpdateSink(this.client, channel, threadTs || ts)
+                                : undefined,
+                        },
                     }, triggerExecFn);
                 }
                 else {
@@ -361373,6 +363074,44 @@ class TeamsClient {
         }
         return { ok: true, activityId: lastActivityId };
     }
+    /**
+     * Update an existing bot message.
+     * For safety, only supports single-activity payloads. Oversized content returns msg_too_long.
+     */
+    async updateMessage(opts) {
+        const chunks = (0, markdown_1.chunkText)(opts.text, 28000);
+        if (chunks.length > 1) {
+            return { ok: false, error: 'msg_too_long' };
+        }
+        try {
+            await this.adapter.continueConversationAsync(this.appId, opts.conversationReference, async (turnContext) => {
+                const activity = botbuilder_1.MessageFactory.text(chunks[0] || '');
+                activity.id = opts.activityId;
+                await turnContext.updateActivity(activity);
+            });
+            return { ok: true, activityId: opts.activityId };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    /**
+     * Delete a previously sent bot message.
+     */
+    async deleteMessage(opts) {
+        try {
+            await this.adapter.continueConversationAsync(this.appId, opts.conversationReference, async (turnContext) => {
+                await turnContext.deleteActivity(opts.activityId);
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
 }
 exports.TeamsClient = TeamsClient;
 
@@ -361726,6 +363465,8 @@ class TeamsWebhookRunner {
             });
             if (this.taskStore) {
                 const { trackExecution } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(7628)));
+                const { isFrontendLiveUpdatesEnabled } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(5893)));
+                const { TeamsTaskLiveUpdateSink } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(82309)));
                 await trackExecution({
                     taskStore: this.taskStore,
                     source: 'teams',
@@ -361737,6 +363478,12 @@ class TeamsWebhookRunner {
                         teams_conversation_type: msg.conversationType,
                         teams_from: msg.from.id,
                     },
+                    liveUpdates: {
+                        config: cfgForRun.task_live_updates,
+                        sink: isFrontendLiveUpdatesEnabled(cfgForRun.task_live_updates, 'teams')
+                            ? new TeamsTaskLiveUpdateSink(this.client, msg.conversationReference, msg.activityId)
+                            : undefined,
+                    },
                 }, execFn);
             }
             else {
@@ -361994,6 +363741,40 @@ class TelegramClient {
             return { ok: false, error: errMsg };
         }
     }
+    /**
+     * Edit an existing text message.
+     * Returns ok=false if Telegram rejects the edit (e.g. message too old or unchanged).
+     */
+    async editMessageText(opts) {
+        try {
+            const params = {
+                link_preview_options: { is_disabled: true },
+            };
+            if (opts.parse_mode)
+                params.parse_mode = opts.parse_mode;
+            const msg = await this.bot.api.editMessageText(opts.chat_id, opts.message_id, opts.text, params);
+            const messageId = msg?.message_id || opts.message_id;
+            return { ok: true, message_id: messageId };
+        }
+        catch (err) {
+            const errMsg = err?.description || err?.message || String(err);
+            console.warn(`Telegram editMessageText failed (non-fatal): ${errMsg}`);
+            return { ok: false, error: errMsg };
+        }
+    }
+    /**
+     * Delete a message.
+     */
+    async deleteMessage(opts) {
+        try {
+            await this.bot.api.deleteMessage(opts.chat_id, opts.message_id);
+            return true;
+        }
+        catch (err) {
+            console.warn(`Telegram deleteMessage failed (non-fatal): ${err?.description || err?.message || String(err)}`);
+            return false;
+        }
+    }
     /**
      * Send a document/file.
      */
@@ -362493,6 +364274,8 @@ class TelegramPollingRunner {
             });
             if (this.taskStore) {
                 const { trackExecution } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(7628)));
+                const { isFrontendLiveUpdatesEnabled } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(5893)));
+                const { TelegramTaskLiveUpdateSink } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(71872)));
                 await trackExecution({
                     taskStore: this.taskStore,
                     source: 'telegram',
@@ -362504,6 +364287,12 @@ class TelegramPollingRunner {
                         telegram_chat_type: msg.chat.type,
                         telegram_user: msg.from ? String(msg.from.id) : 'unknown',
                     },
+                    liveUpdates: {
+                        config: cfgForRun.task_live_updates,
+                        sink: isFrontendLiveUpdatesEnabled(cfgForRun.task_live_updates, 'telegram')
+                            ? new TelegramTaskLiveUpdateSink(this.client, msg.chat.id, msg.message_id, msg.message_thread_id)
+                            : undefined,
+                    },
                 }, execFn);
             }
             else {
@@ -381344,6 +383133,14 @@ module.exports = require("net");
 
 /***/ }),
 
+/***/ 16698:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:async_hooks");
+
+/***/ }),
+
 /***/ 4573:
 /***/ ((module) => {
 
@@ -455959,6 +457756,70 @@ var init_extract = __esm({
   }
 });
 
+// src/symbols.js
+async function symbols(options) {
+  if (!options) {
+    throw new Error("Options object is required");
+  }
+  if (!options.files || !Array.isArray(options.files) || options.files.length === 0) {
+    throw new Error("At least one file path is required");
+  }
+  const binaryPath = await getBinaryPath(options.binaryOptions || {});
+  const cwd = await validateCwdPath(options.cwd);
+  const args = ["symbols", "--format", "json"];
+  if (options.allowTests) {
+    args.push("--allow-tests");
+  }
+  for (const file2 of options.files) {
+    args.push(escapeString(file2));
+  }
+  if (process.env.DEBUG === "1") {
+    console.error(`
+Symbols: files="${options.files.join(", ")}" cwd="${cwd}"`);
+  }
+  return new Promise((resolve9, reject2) => {
+    const childProcess = (0, import_child_process5.spawn)(binaryPath, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd
+    });
+    let stdout = "";
+    let stderr = "";
+    childProcess.stdout.on("data", (data2) => {
+      stdout += data2.toString();
+    });
+    childProcess.stderr.on("data", (data2) => {
+      stderr += data2.toString();
+    });
+    childProcess.on("close", (code) => {
+      if (stderr && process.env.DEBUG === "1") {
+        console.error(`stderr: ${stderr}`);
+      }
+      if (code !== 0) {
+        reject2(new Error(`Symbols command failed with exit code ${code}: ${stderr}`));
+        return;
+      }
+      try {
+        const result = JSON.parse(stdout);
+        resolve9(result);
+      } catch (error40) {
+        reject2(new Error(`Failed to parse symbols output: ${error40.message}. Output: ${stdout.substring(0, 200)}`));
+      }
+    });
+    childProcess.on("error", (error40) => {
+      reject2(new Error(`Failed to spawn symbols process: ${error40.message}`));
+    });
+  });
+}
+var import_child_process5;
+var init_symbols = __esm({
+  "src/symbols.js"() {
+    "use strict";
+    import_child_process5 = __nccwpck_require__(35317);
+    init_utils();
+    init_path_validation();
+  }
+});
+
 // src/grep.js
 async function grep(options) {
   if (!options || !options.pattern) {
@@ -456002,14 +457863,14 @@ async function grep(options) {
     throw new Error(`Grep failed: ${errorMessage}`);
   }
 }
-var import_child_process5, import_util5, execFileAsync2, GREP_FLAG_MAP;
+var import_child_process6, import_util5, execFileAsync2, GREP_FLAG_MAP;
 var init_grep = __esm({
   "src/grep.js"() {
     "use strict";
-    import_child_process5 = __nccwpck_require__(35317);
+    import_child_process6 = __nccwpck_require__(35317);
     import_util5 = __nccwpck_require__(39023);
     init_utils();
-    execFileAsync2 = (0, import_util5.promisify)(import_child_process5.execFile);
+    execFileAsync2 = (0, import_util5.promisify)(import_child_process6.execFile);
     GREP_FLAG_MAP = {
       ignoreCase: "-i",
       lineNumbers: "-n",
@@ -481417,6 +483278,9 @@ function createTools(configOptions) {
   if (isToolAllowed("extract")) {
     tools2.extractTool = extractTool(configOptions);
   }
+  if (isToolAllowed("symbols")) {
+    tools2.symbolsTool = symbolsTool(configOptions);
+  }
   if (configOptions.enableDelegate && isToolAllowed("delegate")) {
     tools2.delegateTool = delegateTool(configOptions);
   }
@@ -481585,7 +483449,7 @@ function resolveTargetPath(target, cwd) {
   }
   return filePart + suffix;
 }
-var import_path6, searchDelegateSchema, searchSchema, searchAllSchema, querySchema, extractSchema, delegateSchema, listSkillsSchema, useSkillSchema, listFilesSchema, searchFilesSchema, readImageSchema, readMediaSchema, bashSchema, analyzeAllSchema, executePlanSchema, cleanupExecutePlanSchema, searchDescription, searchDelegateDescription, queryDescription, extractDescription, delegateDescription, bashDescription, analyzeAllDescription;
+var import_path6, searchDelegateSchema, searchSchema, searchAllSchema, querySchema, extractSchema, delegateSchema, listSkillsSchema, useSkillSchema, listFilesSchema, searchFilesSchema, readImageSchema, readMediaSchema, symbolsSchema, bashSchema, analyzeAllSchema, executePlanSchema, cleanupExecutePlanSchema, searchDescription, searchDelegateDescription, queryDescription, extractDescription, delegateDescription, bashDescription, analyzeAllDescription;
 var init_common = __esm({
   "src/tools/common.js"() {
     "use strict";
@@ -481644,6 +483508,9 @@ var init_common = __esm({
     readMediaSchema = external_exports2.object({
       path: external_exports2.string().describe("Path to the media file to read. Supports images (png, jpg, jpeg, webp, bmp, svg) and documents (pdf).")
     });
+    symbolsSchema = external_exports2.object({
+      file: external_exports2.string().describe("Path to the file to list symbols from. Returns a hierarchical tree of functions, classes, structs, constants, etc. with line numbers and nesting (e.g., methods inside classes/impl blocks).")
+    });
     bashSchema = external_exports2.object({
       command: external_exports2.string().describe("The bash command to execute"),
       workingDirectory: external_exports2.string().optional().describe("Directory to execute the command in (optional)"),
@@ -489053,14 +490920,21 @@ function createWrappedTools(baseTools) {
       baseTools.multiEditTool.execute
     );
   }
+  if (baseTools.symbolsTool) {
+    wrappedTools.symbolsToolInstance = wrapToolWithEmitter(
+      baseTools.symbolsTool,
+      "symbols",
+      baseTools.symbolsTool.execute
+    );
+  }
   return wrappedTools;
 }
-var import_child_process6, import_util13, import_crypto3, import_events, import_fs6, import_fs7, import_path8, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
+var import_child_process7, import_util13, import_crypto3, import_events, import_fs6, import_fs7, import_path8, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
 var init_probeTool = __esm({
   "src/agent/probeTool.js"() {
     "use strict";
     init_index();
-    import_child_process6 = __nccwpck_require__(35317);
+    import_child_process7 = __nccwpck_require__(35317);
     import_util13 = __nccwpck_require__(39023);
     import_crypto3 = __nccwpck_require__(76982);
     import_events = __nccwpck_require__(24434);
@@ -527710,6 +529584,7 @@ CRITICAL - ALWAYS search before answering:
 You must NEVER answer questions about the codebase from memory or general knowledge. ALWAYS use the search and extract tools first to find the actual code, then base your answer ONLY on what you found. Even if you think you know the answer, you MUST verify it against the actual code. Your answers must be grounded in code evidence, not assumptions.
 
 When exploring code:
+- Use the symbols tool to get a quick overview of a file's structure (functions, classes, constants) before diving into details with extract
 - Provide clear, concise explanations based on user request
 - Find and highlight the most relevant code snippets, if required
 - Trace function calls and data flow through the system \u2014 follow the FULL call chain, not just the entry point
@@ -527740,6 +529615,7 @@ You think like a code explorer \u2014 you understand that codebases have layers:
 
 When searching:
 - Search for the MAIN concept first, then think: "what RELATED subsystems would a real codebase have?"
+- Use symbols to get a file's table of contents (functions, classes, constants with line numbers) before extracting \u2014 it helps you pick the right symbols to extract
 - Use extract to READ the code you find \u2014 look for function calls, type references, and imports that point to OTHER relevant code
 - If you find middleware, check: are there org-level or tenant-level variants?
 - If you find algorithms, check: are there different storage backends?
@@ -527783,6 +529659,7 @@ If the solution is clear, you can jump to implementation right away. If not, ask
 - Do not add code comments unless the logic is genuinely complex and non-obvious.
 
 # Before Implementation
+- Use symbols to get a quick overview of file structure (functions, classes, constants with line numbers) before reading or editing files.
 - Read tests first \u2014 find existing test files for the module you're changing. They reveal expected behavior, edge cases, and the project's testing patterns.
 - Read neighboring files \u2014 understand naming conventions, error handling patterns, import style, and existing utilities before creating new ones.
 - Trace the call chain \u2014 follow how the code you're changing is called and what depends on it. Check interfaces, types, and consumers.
@@ -527819,7 +529696,7 @@ Use the right tool:
 1. To MODIFY existing code \u2192 \`edit\` tool (old_string \u2192 new_string, or start_line/end_line)
 2. To CREATE a new file \u2192 \`create\` tool
 3. To CHANGE multiple files at once \u2192 \`multi_edit\` tool
-4. To READ code \u2192 \`extract\` or \`search\` tools
+4. To READ code \u2192 \`extract\` or \`search\` tools. Use \`symbols\` to get a file's table of contents (functions, classes, constants with line numbers) before extracting.
 5. If \`edit\` fails with "file has not been read yet" \u2192 use \`extract\` with the EXACT same file path you will pass to \`edit\`. Relative vs absolute path mismatch causes this error. Use the same path format consistently. If it still fails, use bash \`cat\` to read the file, then use \`create\` to write the entire modified file. Do NOT fall back to sed.
 
 Bash is fine for: formatters (gofmt, prettier, black), build/test/lint commands, git operations, and read-only file inspection (cat, head, tail). sed/awk should ONLY be used for trivial non-code tasks (e.g., config file tweaks) where the replacement is a simple literal string swap.
@@ -527831,6 +529708,8 @@ Bash is fine for: formatters (gofmt, prettier, black), build/test/lint commands,
 - Never expose secrets, API keys, or credentials in generated code. Never log sensitive information.
 - Do not surprise the user with unrequested changes. Do what was asked, including reasonable follow-up actions, but do not refactor surrounding code or add features that were not requested.
 - When editing files, keep edits focused and minimal. For changes spanning more than a few lines, prefer line-targeted editing (start_line/end_line) over text replacement (old_string) \u2014 it constrains scope and prevents accidental removal of adjacent content. Never include unrelated sections in an edit operation.
+- In line-targeted mode, omitting position means replace/update the addressed lines. To insert code near an existing line, you MUST use position="before" or position="after". Never express insertion as end_line < start_line.
+- To remove lines with line-targeted mode, target the exact start_line/end_line range and set new_string to the empty string "".
 - After every significant change, verify the project still builds and passes linting. Do not wait until the end to discover breakage.
 
 # Writing Tests
@@ -530273,6 +532152,7 @@ var require_stringify = __commonJS({
         nullStr: "null",
         simpleKeys: false,
         singleQuote: null,
+        trailingComma: false,
         trueStr: "true",
         verifyAliasOrder: true
       }, doc.schema.toStringOptions, options);
@@ -530790,12 +532670,19 @@ ${indent}${line}` : "\n";
         if (comment)
           reqNewline = true;
         let str = stringify.stringify(item, itemCtx, () => comment = null);
-        if (i < items.length - 1)
+        reqNewline || (reqNewline = lines.length > linesAtValue || str.includes("\n"));
+        if (i < items.length - 1) {
           str += ",";
+        } else if (ctx.options.trailingComma) {
+          if (ctx.options.lineWidth > 0) {
+            reqNewline || (reqNewline = lines.reduce((sum, line) => sum + line.length + 2, 2) + (str.length + 2) > ctx.options.lineWidth);
+          }
+          if (reqNewline) {
+            str += ",";
+          }
+        }
         if (comment)
           str += stringifyComment.lineComment(str, itemIndent, commentString(comment));
-        if (!reqNewline && (lines.length > linesAtValue || str.includes("\n")))
-          reqNewline = true;
         lines.push(str);
         linesAtValue = lines.length;
       }
@@ -533809,17 +535696,22 @@ var require_compose_node = __commonJS({
         case "block-map":
         case "block-seq":
         case "flow-collection":
-          node = composeCollection.composeCollection(CN, ctx, token, props, onError);
-          if (anchor)
-            node.anchor = anchor.source.substring(1);
+          try {
+            node = composeCollection.composeCollection(CN, ctx, token, props, onError);
+            if (anchor)
+              node.anchor = anchor.source.substring(1);
+          } catch (error40) {
+            const message = error40 instanceof Error ? error40.message : String(error40);
+            onError(token, "RESOURCE_EXHAUSTION", message);
+          }
           break;
         default: {
           const message = token.type === "error" ? token.message : `Unsupported token (type: ${token.type})`;
           onError(token, "UNEXPECTED_TOKEN", message);
-          node = composeEmptyNode(ctx, token.offset, void 0, null, props, onError);
           isSrcToken = false;
         }
       }
+      node ?? (node = composeEmptyNode(ctx, token.offset, void 0, null, props, onError));
       if (anchor && node.anchor === "")
         onError(anchor, "BAD_ALIAS", "Anchor cannot be an empty string");
       if (atKey && ctx.options.stringKeys && (!identity2.isScalar(node) || typeof node.value !== "string" || node.tag && node.tag !== "tag:yaml.org,2002:str")) {
@@ -548808,7 +550700,7 @@ async function executeBashCommand(command, options = {}) {
       [cmd, ...cmdArgs] = args;
       useShell = false;
     }
-    const child = (0, import_child_process7.spawn)(cmd, cmdArgs, {
+    const child = (0, import_child_process8.spawn)(cmd, cmdArgs, {
       cwd,
       env: processEnv,
       stdio: ["ignore", "pipe", "pipe"],
@@ -549004,11 +550896,11 @@ function validateExecutionOptions(options = {}) {
     warnings
   };
 }
-var import_child_process7, import_path13, import_fs10;
+var import_child_process8, import_path13, import_fs10;
 var init_bashExecutor = __esm({
   "src/agent/bashExecutor.js"() {
     "use strict";
-    import_child_process7 = __nccwpck_require__(35317);
+    import_child_process8 = __nccwpck_require__(35317);
     import_path13 = __nccwpck_require__(16928);
     import_fs10 = __nccwpck_require__(79896);
     init_bashCommandUtils();
@@ -550534,7 +552426,7 @@ ${opts.schema}`;
         }
       }
       const toolCollector = [];
-      const proc2 = (0, import_child_process8.spawn)("sh", ["-c", shellCmd], {
+      const proc2 = (0, import_child_process9.spawn)("sh", ["-c", shellCmd], {
         env: { ...process.env, FORCE_COLOR: "0" },
         stdio: ["ignore", "pipe", "pipe"]
         // Ignore stdin since echo handles it
@@ -550889,11 +552781,11 @@ function combinePrompts(systemPrompt, customPrompt, agent) {
   }
   return systemPrompt || "";
 }
-var import_child_process8, import_crypto6, import_promises5, import_path15, import_os5, import_events3;
+var import_child_process9, import_crypto6, import_promises5, import_path15, import_os5, import_events3;
 var init_enhanced_claude_code = __esm({
   "src/agent/engines/enhanced-claude-code.js"() {
     "use strict";
-    import_child_process8 = __nccwpck_require__(35317);
+    import_child_process9 = __nccwpck_require__(35317);
     import_crypto6 = __nccwpck_require__(76982);
     import_promises5 = __toESM(__nccwpck_require__(91943), 1);
     import_path15 = __toESM(__nccwpck_require__(16928), 1);
@@ -550935,7 +552827,7 @@ async function createCodexEngine(options = {}) {
   if (debug) {
     console.log("[DEBUG] Starting Codex MCP server...");
   }
-  const codexProcess = (0, import_child_process9.spawn)("codex", ["mcp-server"], {
+  const codexProcess = (0, import_child_process10.spawn)("codex", ["mcp-server"], {
     stdio: ["pipe", "pipe", "pipe"]
   });
   let requestId = 0;
@@ -551167,11 +553059,11 @@ function combinePrompts2(systemPrompt, customPrompt, agent) {
   }
   return systemPrompt || "";
 }
-var import_child_process9, import_crypto7, import_readline;
+var import_child_process10, import_crypto7, import_readline;
 var init_codex = __esm({
   "src/agent/engines/codex.js"() {
     "use strict";
-    import_child_process9 = __nccwpck_require__(35317);
+    import_child_process10 = __nccwpck_require__(35317);
     import_crypto7 = __nccwpck_require__(76982);
     import_readline = __nccwpck_require__(23785);
     init_built_in_server();
@@ -551937,6 +553829,9 @@ var init_ProbeAgent = __esm({
         if (isToolAllowed("searchFiles")) {
           this.toolImplementations.searchFiles = searchFilesToolInstance;
         }
+        if (wrappedTools.symbolsToolInstance && isToolAllowed("symbols")) {
+          this.toolImplementations.symbols = wrappedTools.symbolsToolInstance;
+        }
         if (this.enableSkills) {
           const registry2 = this._getSkillsRegistry();
           const { listSkillsToolInstance, useSkillToolInstance } = createSkillToolInstances({
@@ -552968,6 +554863,10 @@ var init_ProbeAgent = __esm({
             schema: searchFilesSchema,
             description: "Find files matching a glob pattern with recursive search capability."
           },
+          symbols: {
+            schema: symbolsSchema,
+            description: "List all symbols (functions, classes, structs, constants, etc.) in a file. Returns a hierarchical tree with line numbers \u2014 like a table of contents for code."
+          },
           readMedia: {
             schema: readMediaSchema,
             description: "Read and load a media file (image or PDF document) for AI analysis. Supports: png, jpg, jpeg, webp, bmp, svg, pdf."
@@ -553623,7 +555522,8 @@ ${this.architectureContext.content}
 ${searchToolDesc1}
 - extract: Extract specific code sections with context
 - listFiles: Browse directory contents
-- searchFiles: Find files by name patterns`;
+- searchFiles: Find files by name patterns
+- symbols: List all symbols in a file (functions, classes, constants, etc.) with line numbers`;
         if (this.enableBash) {
           systemPrompt += `
 - bash: Execute bash commands for system operations (building, running tests, git, etc.). NEVER use bash for code exploration (no grep, cat, find, head, tail) \u2014 always use search and extract tools instead, they are faster and more accurate.`;
@@ -553678,7 +555578,8 @@ Workspace: ${this.allowedFolders.join(", ")}`;
 ${searchToolDesc2}
 - extract: Extract specific code sections with context
 - listFiles: Browse directory contents
-- searchFiles: Find files by name patterns`;
+- searchFiles: Find files by name patterns
+- symbols: List all symbols in a file (functions, classes, constants, etc.) with line numbers`;
         if (this.enableBash) {
           systemPrompt += `
 - bash: Execute bash commands for system operations (building, running tests, git, etc.). NEVER use bash for code exploration (no grep, cat, find, head, tail) \u2014 always use search and extract tools instead, they are faster and more accurate.`;
@@ -553752,6 +555653,8 @@ Follow these instructions carefully:
 7. When modifying files, choose the appropriate tool:
     - Use 'edit' for all code modifications:
       * PREFERRED: Use start_line (and optionally end_line) for line-targeted editing \u2014 this is the safest and most precise approach.${this.hashLines ? ' Use the line:hash references from extract/search output (e.g. "42:ab") for integrity verification.' : ""} Always use extract first to see line numbers${this.hashLines ? " and hashes" : ""}, then edit by line reference.
+      * In line-targeted mode, omitting position means replace/update the addressed lines. To insert new code near a line, you MUST set position="before" or position="after". Never express insertion as end_line < start_line.
+      * To delete lines in line-targeted mode, target the exact start_line/end_line range and set new_string to the empty string "".
       * For editing inside large functions: first use extract with the symbol target (e.g. "file.js#myFunction") to see the function with line numbers${this.hashLines ? " and hashes" : ""}, then use start_line/end_line to surgically edit specific lines within it.
       * For rewriting entire functions/classes/methods, use the symbol parameter instead (no exact text matching needed).
       * FALLBACK ONLY: Use old_string + new_string for simple single-line changes where the text is unique. Copy old_string verbatim from the file. Keep old_string as small as possible.
@@ -557123,7 +559026,7 @@ The "searches" field helps the caller understand what was attempted.
 - Deduplicate files across groups.
 </output-rules>`;
 }
-var import_ai5, import_fs12, CODE_SEARCH_SCHEMA, searchTool, queryTool, extractTool, delegateTool, analyzeAllTool;
+var import_ai5, import_fs12, CODE_SEARCH_SCHEMA, searchTool, queryTool, extractTool, delegateTool, analyzeAllTool, symbolsTool;
 var init_vercel = __esm({
   "src/tools/vercel.js"() {
     "use strict";
@@ -557131,6 +559034,7 @@ var init_vercel = __esm({
     init_search();
     init_query();
     init_extract();
+    init_symbols();
     init_delegate();
     init_analyzeAll();
     init_common();
@@ -557853,6 +559757,36 @@ Do NOT search for analogies or loosely related concepts. If the feature does not
         }
       });
     };
+    symbolsTool = (options = {}) => {
+      return (0, import_ai5.tool)({
+        name: "symbols",
+        description: "List all symbols (functions, classes, structs, constants, etc.) in a file. Returns a hierarchical tree with line numbers \u2014 like a table of contents for code files.",
+        inputSchema: symbolsSchema,
+        execute: async ({ file: file2 }) => {
+          try {
+            let filePath = file2;
+            if (options.cwd) {
+              const resolvedPaths = parseAndResolvePaths(file2, options.cwd);
+              if (resolvedPaths.length > 0) {
+                filePath = resolvedPaths[0];
+              }
+            }
+            const result = await symbols({
+              files: [filePath],
+              cwd: options.cwd,
+              binaryOptions: options.binaryOptions
+            });
+            if (result && result.length > 0) {
+              return JSON.stringify(result[0], null, 2);
+            }
+            return JSON.stringify({ file: file2, symbols: [] }, null, 2);
+          } catch (error40) {
+            console.error("Error executing symbols:", error40);
+            return formatErrorForAI(error40);
+          }
+        }
+      });
+    };
   }
 });
 
@@ -558253,10 +560187,11 @@ async function handleLineEdit({ resolvedPath, file_path, start_line, end_line, n
   const startLine = startRef.line;
   const endLine = endRef ? endRef.line : startLine;
   if (endLine < startLine) {
-    return `Error editing file: end_line (${endLine}) must be >= start_line (${startLine}).`;
+    const insertionHint = endLine === startLine - 1 ? ` This looks like an insertion between lines ${endLine} and ${startLine}. To insert there without replacing existing code, use start_line="${startLine}" with position="before" or start_line="${endLine}" with position="after".` : ' To insert new code, choose a single anchor line in start_line and set position to "before" or "after" instead of using an inverted range.';
+    return `Error editing file: end_line (${endLine}) must be >= start_line (${startLine}). Omitting position means replace/update the addressed lines, not insert.${insertionHint} To delete lines, use new_string as the empty string "" with a valid non-inverted range.`;
   }
   if (position !== void 0 && position !== null && position !== "before" && position !== "after") {
-    return 'Error editing file: Invalid position - must be "before" or "after". Use position="before" to insert before the line, or position="after" to insert after it.';
+    return 'Error editing file: Invalid position - must be "before" or "after". Use position="before" to insert before start_line, position="after" to insert after start_line, or omit position to replace/update the addressed lines.';
   }
   const content = await import_fs13.promises.readFile(resolvedPath, "utf-8");
   const fileLines = content.split("\n");
@@ -558313,7 +560248,7 @@ async function handleLineEdit({ resolvedPath, file_path, start_line, end_line, n
     return buildLineEditResponse(file_path, startLine, endLine, newLines.length, fileLines, startLine - 1, action, modifications);
   }
 }
-var import_ai6, import_fs13, import_path17, import_fs14, editTool, createTool, multiEditTool, editSchema, createSchema, multiEditSchema, editDescription, createDescription, multiEditDescription, editToolDefinition, createToolDefinition, multiEditToolDefinition;
+var import_ai6, import_fs13, import_path17, import_fs14, lineTargetedModeGuidance, editTool, createTool, multiEditTool, editSchema, createSchema, multiEditSchema, editDescription, createDescription, multiEditDescription, editToolDefinition, createToolDefinition, multiEditToolDefinition;
 var init_edit = __esm({
   "src/tools/edit.js"() {
     "use strict";
@@ -558326,27 +560261,35 @@ var init_edit = __esm({
     init_symbolEdit();
     init_hashline();
     init_lineEditHeuristics();
+    lineTargetedModeGuidance = `Line-targeted mode has three explicit behaviors:
+- Replace/update lines: provide start_line and optionally end_line, and omit position
+- Insert near a line: provide start_line and set position to "before" or "after"
+- Delete lines: provide start_line/end_line for the exact range and set new_string to empty string ""
+
+Inverted ranges (end_line < start_line) are always invalid and are never treated as insertion.`;
     editTool = (options = {}) => {
       const { debug, allowedFolders, cwd, workspaceRoot } = parseFileToolOptions(options);
       return (0, import_ai6.tool)({
         name: "edit",
-        description: `Edit files using text replacement, AST-aware symbol operations, or line-targeted editing.
+        description: `Edit files using text replacement, AST-aware symbol operations, or line-targeted line replacement/insertion/deletion.
 
 Modes:
 1. Text edit: Provide old_string + new_string to find and replace text (with fuzzy matching fallback)
 2. Symbol replace: Provide symbol + new_string to replace an entire function/class/method by name
 3. Symbol insert: Provide symbol + new_string + position to insert code before/after a symbol
-4. Line-targeted edit: Provide start_line + new_string to edit by line number (from extract/search output)
+4. Line-targeted edit: Provide start_line + new_string to replace/update, insert, or delete lines by line number (from extract/search output)
+
+${lineTargetedModeGuidance}
 
 Parameters:
 - file_path: Path to the file to edit (absolute or relative)
-- new_string: Replacement text or new code content
+- new_string: Replacement text or new code content. Use empty string "" to delete the targeted line range.
 - old_string: (optional) Text to find and replace. If omitted, symbol or start_line must be provided.
 - replace_all: (optional) Replace all occurrences (text mode only)
 - symbol: (optional) Symbol name for AST-aware editing (e.g. "myFunction", "MyClass.myMethod")
-- position: (optional) "before" or "after" \u2014 insert code near a symbol or line instead of replacing it
-- start_line: (optional) Line reference (e.g. "42" or "42:ab") for line-targeted editing
-- end_line: (optional) End of line range, inclusive (e.g. "55" or "55:cd")`,
+- position: (optional) "before" or "after" \u2014 insert code near a symbol or line instead of replacing it. Omit position to replace/update.
+- start_line: (optional) Line reference (e.g. "42" or "42:ab") for line-targeted editing. With position, this is the insertion anchor. Without position, this is the first line to replace/update/delete.
+- end_line: (optional) End of line range, inclusive (e.g. "55" or "55:cd"). Must be >= start_line. Omit for single-line updates. Do not use inverted ranges for insertion.`,
         inputSchema: {
           type: "object",
           properties: {
@@ -558360,7 +560303,7 @@ Parameters:
             },
             new_string: {
               type: "string",
-              description: "Replacement text or new code content"
+              description: 'Replacement text or new code content. Use empty string "" to delete the targeted line range.'
             },
             replace_all: {
               type: "boolean",
@@ -558374,15 +560317,15 @@ Parameters:
             position: {
               type: "string",
               enum: ["before", "after"],
-              description: "Insert before/after symbol or line (requires symbol or start_line, omit to replace)"
+              description: "Insert before/after the target symbol or start_line anchor. Omit position to replace/update the addressed symbol or line range."
             },
             start_line: {
               type: "string",
-              description: 'Line reference for line-targeted editing (e.g. "42" or "42:ab" with hash)'
+              description: 'Line reference for line-targeted editing (e.g. "42" or "42:ab" with hash). With position, this is the insertion anchor. Without position, this is the first line to replace/update/delete.'
             },
             end_line: {
               type: "string",
-              description: 'End of line range, inclusive (e.g. "55" or "55:cd"). Defaults to start_line.'
+              description: 'Inclusive end of the line range to replace/delete (e.g. "55" or "55:cd"). Must be >= start_line. Defaults to start_line.'
             }
           },
           required: ["file_path", "new_string"]
@@ -558633,7 +560576,7 @@ Important:
         },
         new_string: {
           type: "string",
-          description: "Replacement text or new code content"
+          description: 'Replacement text or new code content. Use empty string "" to delete the targeted line range.'
         },
         replace_all: {
           type: "boolean",
@@ -558646,15 +560589,15 @@ Important:
         position: {
           type: "string",
           enum: ["before", "after"],
-          description: "Insert before/after symbol or line (requires symbol or start_line, omit to replace)"
+          description: "Insert before/after the target symbol or start_line anchor. Omit position to replace/update the addressed symbol or line range."
         },
         start_line: {
           type: "string",
-          description: 'Line reference for line-targeted editing (e.g. "42" or "42:ab" with hash)'
+          description: 'Line reference for line-targeted editing (e.g. "42" or "42:ab" with hash). With position, this is the insertion anchor. Without position, this is the first line to replace/update/delete.'
         },
         end_line: {
           type: "string",
-          description: 'End of line range, inclusive (e.g. "55" or "55:cd"). Defaults to start_line.'
+          description: 'Inclusive end of the line range to replace/delete (e.g. "55" or "55:cd"). Must be >= start_line. Defaults to start_line.'
         }
       },
       required: ["file_path", "new_string"]
@@ -558687,7 +560630,7 @@ Important:
       },
       required: ["edits"]
     };
-    editDescription = "Edit files using text replacement, AST-aware symbol operations, or line-targeted editing. Supports fuzzy matching for text edits and optional hash-based integrity verification for line edits.";
+    editDescription = "Edit files using text replacement, AST-aware symbol operations, or line-targeted replacement/insertion/deletion. Supports fuzzy matching for text edits and optional hash-based integrity verification for line edits.";
     createDescription = "Create new files with specified content. Will create parent directories if needed.";
     multiEditDescription = "Apply multiple file edits in a single tool call. Accepts a JSON array of edit operations, each supporting the same modes as the edit tool.";
     editToolDefinition = `
@@ -558704,15 +560647,21 @@ Four editing modes \u2014 choose based on the scope of your change:
 
 4. **Line-targeted edit** (start_line + new_string): For precise edits using line numbers from extract/search output. Use start_line with a line number (e.g. "42") or line:hash (e.g. "42:ab") for integrity verification. Add end_line for multi-line ranges. Use position="before" or "after" to insert instead of replace.
 
+How line-targeted mode behaves:
+- Replace/update lines: provide start_line and optionally end_line, and omit position
+- Insert near a line: provide start_line and set position to "before" or "after"
+- Delete lines: provide start_line/end_line for the exact range and set new_string to empty string ""
+- Inverted ranges are invalid: end_line must be >= start_line and is never treated as insertion
+
 Parameters:
 - file_path: (required) Path to the file to edit
-- new_string: (required) Replacement text or new code content
+- new_string: (required) Replacement text or new code content. Use empty string "" to delete the targeted line range.
 - old_string: (optional) Text to find and replace \u2014 copy verbatim from the file, do not paraphrase or reformat
 - replace_all: (optional, default: false) Replace all occurrences of old_string (text mode only)
 - symbol: (optional) Name of a code symbol (e.g. "myFunction", "MyClass.myMethod") \u2014 must match a function, class, or method definition
-- position: (optional) "before" or "after" \u2014 insert new_string near the symbol or line instead of replacing it
-- start_line: (optional) Line reference for line-targeted editing (e.g. "42" or "42:ab")
-- end_line: (optional) End of line range, inclusive (e.g. "55" or "55:cd"). Defaults to start_line.
+- position: (optional) "before" or "after" \u2014 insert new_string near the symbol or line instead of replacing it. Omit position to replace/update.
+- start_line: (optional) Line reference for line-targeted editing (e.g. "42" or "42:ab"). With position, this is the insertion anchor. Without position, this is the first line to replace/update/delete.
+- end_line: (optional) End of line range, inclusive (e.g. "55" or "55:cd"). Defaults to start_line. Must be >= start_line. Use it for replace/update/delete ranges, not insertion.
 
 Mode selection rules (priority order):
 - If symbol is provided, symbol mode is used (old_string and start_line are ignored)
@@ -558724,12 +560673,15 @@ When to use each mode:
 - Small edits (a line or a few lines): use text mode with old_string
 - Replacing entire functions/classes/methods: use symbol mode \u2014 no exact text matching needed
 - Editing specific lines from extract/search output: use line-targeted mode with start_line
+- Adding a new block near an existing line: use line-targeted mode with start_line plus position="before" or position="after"
+- Removing lines entirely: use line-targeted mode with start_line/end_line and new_string=""
 - Editing inside large functions without rewriting them entirely: first use extract with the symbol target (e.g. "file.js#myFunction") to see the function with line numbers, then use start_line/end_line to edit specific lines within it
 
 Error handling:
 - If an edit fails, read the error message carefully \u2014 it contains specific instructions for how to fix the call and retry
 - Common fixes: use 'search'/'extract' to get exact file content, add more context to old_string, switch between text and symbol modes
 - Line-targeted hash mismatch: the file changed since last read; the error provides updated line:hash references
+- Inverted line ranges are invalid; the error explains how to express insertion with position="before"/"after"
 
 Examples:
 
@@ -558783,6 +560735,22 @@ Line-targeted edit (replace a range of lines):
   return processItems(order.items);</new_string>
 </edit>
 
+Line-targeted edit (insert before a line without replacing it):
+<edit>
+<file_path>src/main.js</file_path>
+<start_line>42</start_line>
+<position>before</position>
+<new_string>  logger.debug("starting process");</new_string>
+</edit>
+
+Line-targeted edit (delete a range of lines):
+<edit>
+<file_path>src/main.js</file_path>
+<start_line>42</start_line>
+<end_line>45</end_line>
+<new_string></new_string>
+</edit>
+
 Line-targeted edit with hash verification:
 <edit>
 <file_path>src/main.js</file_path>
@@ -559013,6 +560981,10 @@ You are Probe, a specialized code intelligence assistant. Your objective is to a
     *   **Purpose:** Retrieve specific code blocks or entire files *after* \`search\` or \`query\` identifies the target.
     *   **Syntax:** Optional \`#symbol\` (e.g., \`#MyClass\`), \`#Lstart-Lend\` (e.g., \`#L50-L75\`).
     *   **Mandatory Argument:** \`path\` (specific file path, e.g., \`"src/utils/helpers.go"\`, or dependency file like \`"go:github.com/gin-gonic/gin/context.go"\`).
+*   \`symbols\`
+    *   **Purpose:** List all symbols (functions, classes, structs, constants, etc.) in a file \u2014 a table of contents with line numbers and nesting.
+    *   **Syntax:** \`file\` (path to the file to list symbols from).
+    *   **Use When:** You need to understand a file's structure before extracting specific parts, or to find the right symbol name/line number for \`extract\`.
 
 [Examples]
 
@@ -559147,6 +561119,8 @@ __export(tools_exports, {
   searchFilesSchema: () => searchFilesSchema,
   searchSchema: () => searchSchema,
   searchTool: () => searchTool,
+  symbolsSchema: () => symbolsSchema,
+  symbolsTool: () => symbolsTool,
   tools: () => tools,
   useSkillSchema: () => useSkillSchema
 });
@@ -559270,16 +561244,16 @@ function shouldIgnore(filePath, ignorePatterns) {
   }
   return false;
 }
-var import_fs15, import_path18, import_util14, import_child_process10, execAsync3;
+var import_fs15, import_path18, import_util14, import_child_process11, execAsync3;
 var init_file_lister = __esm({
   "src/utils/file-lister.js"() {
     "use strict";
     import_fs15 = __toESM(__nccwpck_require__(79896), 1);
     import_path18 = __toESM(__nccwpck_require__(16928), 1);
     import_util14 = __nccwpck_require__(39023);
-    import_child_process10 = __nccwpck_require__(35317);
+    import_child_process11 = __nccwpck_require__(35317);
     init_symlink_utils();
-    execAsync3 = (0, import_util14.promisify)(import_child_process10.exec);
+    execAsync3 = (0, import_util14.promisify)(import_child_process11.exec);
   }
 });
 
@@ -559355,6 +561329,9 @@ __export(index_exports, {
   searchSchema: () => searchSchema,
   searchTool: () => searchTool,
   setBinaryPath: () => setBinaryPath,
+  symbols: () => symbols,
+  symbolsSchema: () => symbolsSchema,
+  symbolsTool: () => symbolsTool,
   taskSchema: () => taskSchema,
   taskSystemPrompt: () => taskSystemPrompt,
   tools: () => tools_exports,
@@ -559368,6 +561345,7 @@ var init_index = __esm({
     init_search();
     init_query();
     init_extract();
+    init_symbols();
     init_grep();
     init_delegate();
     init_utils();
@@ -627561,7 +629539,7 @@ module.exports = /*#__PURE__*/JSON.parse('["aaa","aarp","abb","abbott","abbvie",
 /***/ ((module) => {
 
 "use strict";
-module.exports = /*#__PURE__*/JSON.parse('{"name":"@probelabs/visor","version":"0.1.42","main":"dist/index.js","bin":{"visor":"./dist/index.js"},"exports":{".":{"require":"./dist/index.js","import":"./dist/index.js"},"./sdk":{"types":"./dist/sdk/sdk.d.ts","import":"./dist/sdk/sdk.mjs","require":"./dist/sdk/sdk.js"},"./cli":{"require":"./dist/index.js"}},"files":["dist/","defaults/","action.yml","README.md","LICENSE"],"publishConfig":{"access":"public","registry":"https://registry.npmjs.org/"},"scripts":{"build:cli":"ncc build src/index.ts -o dist && cp -r defaults dist/ && cp -r output dist/ && cp -r docs dist/ && cp -r examples dist/ && cp -r src/debug-visualizer/ui dist/debug-visualizer/ && node scripts/inject-version.js && echo \'#!/usr/bin/env node\' | cat - dist/index.js > temp && mv temp dist/index.js && chmod +x dist/index.js","build:sdk":"tsup src/sdk.ts --dts --sourcemap --format esm,cjs --out-dir dist/sdk","build":"./scripts/build-oss.sh","build:ee":"npm run build:cli && npm run build:sdk","test":"jest && npm run test:yaml","test:unit":"jest","prepublishOnly":"npm run build","test:watch":"jest --watch","test:coverage":"jest --coverage","test:ee":"jest --testPathPatterns=\'tests/ee\' --testPathIgnorePatterns=\'/node_modules/\' --no-coverage","test:manual:bash":"RUN_MANUAL_TESTS=true jest tests/manual/bash-config-manual.test.ts","lint":"eslint src tests --ext .ts","lint:fix":"eslint src tests --ext .ts --fix","format":"prettier --write src tests","format:check":"prettier --check src tests","clean":"","clean:traces":"node scripts/clean-traces.js","prebuild":"npm run clean && node scripts/generate-config-schema.js","pretest":"npm run clean:traces && node scripts/generate-config-schema.js && npm run build:cli","pretest:unit":"npm run clean:traces && node scripts/generate-config-schema.js && npm run build:cli","test:with-build":"npm run build:cli && jest","test:yaml":"node dist/index.js test --progress compact","test:yaml:parallel":"node dist/index.js test --progress compact --max-parallel 4","prepare":"husky","pre-commit":"lint-staged","deploy:site":"cd site && npx wrangler pages deploy . --project-name=visor-site --commit-dirty=true","deploy:worker":"npx wrangler deploy","deploy":"npm run deploy:site && npm run deploy:worker","publish:ee":"./scripts/publish-ee.sh","release":"./scripts/release.sh","release:patch":"./scripts/release.sh patch","release:minor":"./scripts/release.sh minor","release:major":"./scripts/release.sh major","release:prerelease":"./scripts/release.sh prerelease","docs:validate":"node scripts/validate-readme-links.js","workshop:setup":"npm install -D reveal-md@6.1.2","workshop:serve":"cd workshop && reveal-md slides.md -w","workshop:export":"reveal-md workshop/slides.md --static workshop/build","workshop:pdf":"reveal-md workshop/slides.md --print workshop/Visor-Workshop.pdf --print-size letter","workshop:pdf:ci":"reveal-md workshop/slides.md --print workshop/Visor-Workshop.pdf --print-size letter --puppeteer-launch-args=\\"--no-sandbox --disable-dev-shm-usage\\"","workshop:pdf:a4":"reveal-md workshop/slides.md --print workshop/Visor-Workshop-A4.pdf --print-size A4","workshop:build":"npm run workshop:export && npm run workshop:pdf","simulate:issue":"TS_NODE_TRANSPILE_ONLY=1 ts-node scripts/simulate-gh-run.ts --event issues --action opened --debug","simulate:comment":"TS_NODE_TRANSPILE_ONLY=1 ts-node scripts/simulate-gh-run.ts --event issue_comment --action created --debug"},"keywords":["code-review","ai","github-action","cli","pr-review","visor"],"author":"Probe Labs","license":"MIT","description":"AI workflow engine for code review, assistants, and automation — orchestrate checks, MCP tools, and AI providers with YAML-driven pipelines","repository":{"type":"git","url":"git+https://github.com/probelabs/visor.git"},"bugs":{"url":"https://github.com/probelabs/visor/issues"},"homepage":"https://github.com/probelabs/visor#readme","dependencies":{"@actions/core":"^1.11.1","@apidevtools/swagger-parser":"^12.1.0","@grammyjs/runner":"^2.0.3","@modelcontextprotocol/sdk":"^1.25.3","@nyariv/sandboxjs":"github:probelabs/SandboxJS#23c4bb611f7d05f3cb8c523917b5f57103e48108","@octokit/action":"^8.0.2","@octokit/auth-app":"^8.1.0","@octokit/core":"^7.0.3","@octokit/rest":"^22.0.0","@opentelemetry/api":"^1.9.0","@opentelemetry/api-logs":"^0.203.0","@opentelemetry/core":"^1.30.1","@opentelemetry/exporter-logs-otlp-http":"^0.203.0","@opentelemetry/exporter-metrics-otlp-http":"^0.203.0","@opentelemetry/exporter-trace-otlp-grpc":"^0.203.0","@opentelemetry/exporter-trace-otlp-http":"^0.203.0","@opentelemetry/instrumentation":"^0.203.0","@opentelemetry/resources":"^1.30.1","@opentelemetry/sdk-logs":"^0.203.0","@opentelemetry/sdk-metrics":"^1.30.1","@opentelemetry/sdk-node":"^0.203.0","@opentelemetry/sdk-trace-base":"^1.30.1","@opentelemetry/semantic-conventions":"^1.30.1","@probelabs/probe":"^0.6.0-rc308","@types/commander":"^2.12.0","@types/uuid":"^10.0.0","@utcp/file":"^1.1.0","@utcp/http":"^1.1.0","@utcp/sdk":"^1.1.0","@utcp/text":"^1.1.0","acorn":"^8.16.0","acorn-walk":"^8.3.5","ajv":"^8.17.1","ajv-formats":"^3.0.1","better-sqlite3":"^11.0.0","blessed":"^0.1.81","botbuilder":"^4.23.3","botframework-connector":"^4.23.3","cli-table3":"^0.6.5","commander":"^14.0.0","deepmerge":"^4.3.1","dotenv":"^17.2.3","grammy":"^1.41.1","ignore":"^7.0.5","imapflow":"^1.2.12","js-yaml":"^4.1.0","jsonpath-plus":"^10.4.0","liquidjs":"^10.21.1","mailparser":"^3.9.3","minimatch":"^10.2.2","node-cron":"^3.0.3","nodemailer":"^8.0.1","open":"^9.1.0","resend":"^6.9.3","simple-git":"^3.28.0","uuid":"^11.1.0","ws":"^8.18.3"},"optionalDependencies":{"@anthropic/claude-code-sdk":"npm:null@*","@open-policy-agent/opa-wasm":"^1.10.0","knex":"^3.1.0","mysql2":"^3.11.0","pg":"^8.13.0","tedious":"^19.0.0"},"devDependencies":{"@eslint/js":"^9.34.0","@kie/act-js":"^2.6.2","@kie/mock-github":"^2.0.1","@swc/core":"^1.13.2","@swc/jest":"^0.2.37","@types/better-sqlite3":"^7.6.0","@types/blessed":"^0.1.27","@types/jest":"^30.0.0","@types/js-yaml":"^4.0.9","@types/mailparser":"^3.4.6","@types/node":"^24.3.0","@types/node-cron":"^3.0.11","@types/nodemailer":"^7.0.11","@types/ws":"^8.18.1","@typescript-eslint/eslint-plugin":"^8.42.0","@typescript-eslint/parser":"^8.42.0","@vercel/ncc":"^0.38.4","eslint":"^9.34.0","eslint-config-prettier":"^10.1.8","eslint-plugin-prettier":"^5.5.4","husky":"^9.1.7","jest":"^30.1.3","lint-staged":"^16.1.6","prettier":"^3.6.2","reveal-md":"^6.1.2","ts-json-schema-generator":"^1.5.1","ts-node":"^10.9.2","tsup":"^8.5.0","typescript":"^5.9.2","wrangler":"^3.0.0"},"peerDependenciesMeta":{"@anthropic/claude-code-sdk":{"optional":true}},"directories":{"test":"tests"},"lint-staged":{"src/**/*.{ts,js}":["eslint --fix","prettier --write"],"tests/**/*.{ts,js}":["eslint --fix","prettier --write"],"*.{json,md,yml,yaml}":["prettier --write"]}}');
+module.exports = /*#__PURE__*/JSON.parse('{"name":"@probelabs/visor","version":"0.1.42","main":"dist/index.js","bin":{"visor":"./dist/index.js"},"exports":{".":{"require":"./dist/index.js","import":"./dist/index.js"},"./sdk":{"types":"./dist/sdk/sdk.d.ts","import":"./dist/sdk/sdk.mjs","require":"./dist/sdk/sdk.js"},"./cli":{"require":"./dist/index.js"}},"files":["dist/","defaults/","action.yml","README.md","LICENSE"],"publishConfig":{"access":"public","registry":"https://registry.npmjs.org/"},"scripts":{"build:cli":"ncc build src/index.ts -o dist && cp -r defaults dist/ && cp -r output dist/ && cp -r docs dist/ && cp -r examples dist/ && cp -r src/debug-visualizer/ui dist/debug-visualizer/ && node scripts/inject-version.js && echo \'#!/usr/bin/env node\' | cat - dist/index.js > temp && mv temp dist/index.js && chmod +x dist/index.js","build:sdk":"tsup src/sdk.ts --dts --sourcemap --format esm,cjs --out-dir dist/sdk","build":"npm run build:oss","build:oss":"./scripts/build-oss.sh","build:ee":"npm run build:cli && npm run build:sdk","test":"jest && npm run test:yaml","test:unit":"jest","prepublishOnly":"npm run build","test:watch":"jest --watch","test:coverage":"jest --coverage","test:ee":"jest --testPathPatterns=\'tests/ee\' --testPathIgnorePatterns=\'/node_modules/\' --no-coverage","test:manual:bash":"RUN_MANUAL_TESTS=true jest tests/manual/bash-config-manual.test.ts","lint":"eslint src tests --ext .ts","lint:fix":"eslint src tests --ext .ts --fix","format":"prettier --write src tests","format:check":"prettier --check src tests","clean":"","clean:traces":"node scripts/clean-traces.js","prebuild":"npm run clean && node scripts/generate-config-schema.js","pretest":"npm run clean:traces && node scripts/generate-config-schema.js && npm run build:cli","pretest:unit":"npm run clean:traces && node scripts/generate-config-schema.js && npm run build:cli","test:with-build":"npm run build:cli && jest","test:yaml":"node dist/index.js test --progress compact","test:yaml:parallel":"node dist/index.js test --progress compact --max-parallel 4","prepare":"husky","pre-commit":"lint-staged","deploy:site":"cd site && npx wrangler pages deploy . --project-name=visor-site --commit-dirty=true","deploy:worker":"npx wrangler deploy","deploy":"npm run deploy:site && npm run deploy:worker","publish:ee":"./scripts/publish-ee.sh","release":"./scripts/release.sh","release:patch":"./scripts/release.sh patch","release:minor":"./scripts/release.sh minor","release:major":"./scripts/release.sh major","release:prerelease":"./scripts/release.sh prerelease","docs:validate":"node scripts/validate-readme-links.js","workshop:setup":"npm install -D reveal-md@6.1.2","workshop:serve":"cd workshop && reveal-md slides.md -w","workshop:export":"reveal-md workshop/slides.md --static workshop/build","workshop:pdf":"reveal-md workshop/slides.md --print workshop/Visor-Workshop.pdf --print-size letter","workshop:pdf:ci":"reveal-md workshop/slides.md --print workshop/Visor-Workshop.pdf --print-size letter --puppeteer-launch-args=\\"--no-sandbox --disable-dev-shm-usage\\"","workshop:pdf:a4":"reveal-md workshop/slides.md --print workshop/Visor-Workshop-A4.pdf --print-size A4","workshop:build":"npm run workshop:export && npm run workshop:pdf","simulate:issue":"TS_NODE_TRANSPILE_ONLY=1 ts-node scripts/simulate-gh-run.ts --event issues --action opened --debug","simulate:comment":"TS_NODE_TRANSPILE_ONLY=1 ts-node scripts/simulate-gh-run.ts --event issue_comment --action created --debug"},"keywords":["code-review","ai","github-action","cli","pr-review","visor"],"author":"Probe Labs","license":"MIT","description":"AI workflow engine for code review, assistants, and automation — orchestrate checks, MCP tools, and AI providers with YAML-driven pipelines","repository":{"type":"git","url":"git+https://github.com/probelabs/visor.git"},"bugs":{"url":"https://github.com/probelabs/visor/issues"},"homepage":"https://github.com/probelabs/visor#readme","dependencies":{"@actions/core":"^1.11.1","@apidevtools/swagger-parser":"^12.1.0","@grammyjs/runner":"^2.0.3","@modelcontextprotocol/sdk":"^1.25.3","@nyariv/sandboxjs":"github:probelabs/SandboxJS#23c4bb611f7d05f3cb8c523917b5f57103e48108","@octokit/action":"^8.0.2","@octokit/auth-app":"^8.1.0","@octokit/core":"^7.0.3","@octokit/rest":"^22.0.0","@opentelemetry/api":"^1.9.0","@opentelemetry/api-logs":"^0.203.0","@opentelemetry/core":"^1.30.1","@opentelemetry/exporter-logs-otlp-http":"^0.203.0","@opentelemetry/exporter-metrics-otlp-http":"^0.203.0","@opentelemetry/exporter-trace-otlp-grpc":"^0.203.0","@opentelemetry/exporter-trace-otlp-http":"^0.203.0","@opentelemetry/instrumentation":"^0.203.0","@opentelemetry/resources":"^1.30.1","@opentelemetry/sdk-logs":"^0.203.0","@opentelemetry/sdk-metrics":"^1.30.1","@opentelemetry/sdk-node":"^0.203.0","@opentelemetry/sdk-trace-base":"^1.30.1","@opentelemetry/semantic-conventions":"^1.30.1","@probelabs/probe":"^0.6.0-rc311","@types/commander":"^2.12.0","@types/uuid":"^10.0.0","@utcp/file":"^1.1.0","@utcp/http":"^1.1.0","@utcp/sdk":"^1.1.0","@utcp/text":"^1.1.0","acorn":"^8.16.0","acorn-walk":"^8.3.5","ajv":"^8.17.1","ajv-formats":"^3.0.1","better-sqlite3":"^11.0.0","blessed":"^0.1.81","botbuilder":"^4.23.3","botframework-connector":"^4.23.3","cli-table3":"^0.6.5","commander":"^14.0.0","deepmerge":"^4.3.1","dotenv":"^17.2.3","grammy":"^1.41.1","ignore":"^7.0.5","imapflow":"^1.2.12","js-yaml":"^4.1.0","jsonpath-plus":"^10.4.0","liquidjs":"^10.21.1","mailparser":"^3.9.3","minimatch":"^10.2.2","node-cron":"^3.0.3","nodemailer":"^8.0.1","open":"^9.1.0","resend":"^6.9.3","simple-git":"^3.28.0","uuid":"^11.1.0","ws":"^8.18.3"},"optionalDependencies":{"@anthropic/claude-code-sdk":"npm:null@*","@open-policy-agent/opa-wasm":"^1.10.0","knex":"^3.1.0","mysql2":"^3.11.0","pg":"^8.13.0","tedious":"^19.0.0"},"devDependencies":{"@eslint/js":"^9.34.0","@kie/act-js":"^2.6.2","@kie/mock-github":"^2.0.1","@swc/core":"^1.13.2","@swc/jest":"^0.2.37","@types/better-sqlite3":"^7.6.0","@types/blessed":"^0.1.27","@types/jest":"^30.0.0","@types/js-yaml":"^4.0.9","@types/mailparser":"^3.4.6","@types/node":"^24.3.0","@types/node-cron":"^3.0.11","@types/nodemailer":"^7.0.11","@types/ws":"^8.18.1","@typescript-eslint/eslint-plugin":"^8.42.0","@typescript-eslint/parser":"^8.42.0","@vercel/ncc":"^0.38.4","eslint":"^9.34.0","eslint-config-prettier":"^10.1.8","eslint-plugin-prettier":"^5.5.4","husky":"^9.1.7","jest":"^30.1.3","lint-staged":"^16.1.6","prettier":"^3.6.2","reveal-md":"^6.1.2","ts-json-schema-generator":"^1.5.1","ts-node":"^10.9.2","tsup":"^8.5.0","typescript":"^5.9.2","wrangler":"^3.0.0"},"peerDependenciesMeta":{"@anthropic/claude-code-sdk":{"optional":true}},"directories":{"test":"tests"},"lint-staged":{"src/**/*.{ts,js}":["eslint --fix","prettier --write"],"tests/**/*.{ts,js}":["eslint --fix","prettier --write"],"*.{json,md,yml,yaml}":["prettier --write"]}}');
 
 /***/ })