autosnippet 3.3.0 → 3.3.3

package/dist/lib/external/mcp/handlers/task.js

@@ -1,151 +1,180 @@
 /**
- * MCP Handler — autosnippet_task (Unified Task & Decision Management)
+ * MCP Handler — autosnippet_task (Intent Lifecycle + Signal Collection)
  *
- * Operations:
- *   Session:   prime (session entry — loads decisions + ready tasks + stats)
- *   Tasks:     create / ready / claim / close / fail / defer / progress
- *              show / list / stats / blocked / decompose / dep_add / dep_tree
- *   Decisions: record_decision / revise_decision / unpin_decision / list_decisions
+ * 5 Operations:
+ *   prime            — Load knowledge context + initialize intent
+ *   create           — Create in-memory task anchor (generates ID)
+ *   close            — Complete task + persist intent chain + trigger Guard
+ *   fail             — Abandon task + persist intent chain
+ *   record_decision  — Record user preference signal
+ *
+ * Architecture: Zero DB. Pure memory (IntentState) + SignalBus → JSONL signals.
  */
+import { notifyTaskProgress } from '#infra/notification/LarkNotifier.js';
+import { extract as extractIntent } from '#service/task/IntentExtractor.js';
 import { envelope } from '../envelope.js';
+import { createIdleIntent } from './types.js';
+// ─── In-memory task ID counter ───────────────────────────
+let _taskCounter = 0;
+function _generateTaskId() {
+    _taskCounter++;
+    return `asd-${Date.now().toString(36)}-${_taskCounter}`;
+}
+// ─── Task Rules Reminder ─────────────────────────────────
+const _taskRules = {
+    reminder: [
+        '📋 TASK RULES (MANDATORY):',
+        '🔑 YOU are the task operator — user speaks naturally, you translate to task operations.',
+        '• MUST prime on EVERY message BEFORE anything else',
+        '• MUST create task for non-trivial work (≥2 files OR ≥10 lines)',
+        '• MUST close when done with meaningful reason',
+        '• When user agrees/disagrees → record_decision immediately',
+        '• NEVER tell user to run task commands',
+    ].join('\n'),
+    translationHint: [
+        'User Says → You Run:',
+        '"fix bug"/"implement" → create→code→close',
+        '"continue" → resume in-progress→close',
+        '"pause"/"abandon" → fail(id, reason)',
+        '"agreed"/"disagree" → record_decision',
+        'Quick question → No task. Just answer.',
+    ].join('\n'),
+};
 /**
- * 统一入口
- * @param ctx { container }
- * @param args { operation, ...params }
+ * Unified entry point
  */
 export async function taskHandler(ctx, args) {
-    const taskService = ctx.container.get('taskGraphService');
     let result;
     switch (args.operation) {
-        // ── Session ──
         case 'prime':
-            return _prime(taskService, args);
-        // ── Task CRUD ──
+            return _prime(ctx, args);
         case 'create':
-            result = await _create(taskService, args);
-            break;
-        case 'ready':
-            return _ready(taskService, args);
-        case 'claim':
-            result = await _claim(taskService, args);
+            result = await _create(ctx, args);
             break;
         case 'close':
-            result = await _close(ctx, taskService, args);
+            result = await _close(ctx, args);
             break;
         case 'fail':
-            result = await _fail(taskService, args);
-            break;
-        case 'defer':
-            result = await _defer(taskService, args);
+            result = await _fail(ctx, args);
             break;
-        case 'progress':
-            result = await _progress(taskService, args);
-            break;
-        case 'decompose':
-            result = await _decompose(taskService, args);
-            break;
-        case 'show':
-            return _show(taskService, args);
-        case 'list':
-            return _list(taskService, args);
-        case 'blocked':
-            return _blocked(taskService);
-        case 'dep_add':
-            return _depAdd(taskService, args);
-        case 'dep_tree':
-            return _depTree(taskService, args);
-        case 'stats':
-            return _stats(taskService);
-        // ── Decisions ──
         case 'record_decision':
-            result = await _recordDecision(taskService, args);
-            break;
-        case 'revise_decision':
-            result = await _reviseDecision(taskService, args);
-            break;
-        case 'unpin_decision':
-            result = await _unpinDecision(taskService, args);
+            result = await _recordDecision(ctx, args);
             break;
-        case 'list_decisions':
-            return _listDecisions(taskService);
         default:
             return envelope({
                 success: false,
-                message: `Unknown operation: ${args.operation}. Valid: prime, ready, create, claim, close, fail, defer, progress, decompose, dep_add, dep_tree, stats, list, record_decision, revise_decision, unpin_decision, list_decisions.`,
+                message: `Unknown operation: ${args.operation}. Valid: prime, create, close, fail, record_decision.`,
                 meta: { tool: 'autosnippet_task' },
             });
     }
-    // ── 飞书任务进度通知（异步非阻塞）──
-    _notifyTaskProgress(args.operation, args, result).catch((err) => {
-        process.stderr.write(`[MCP/Task] Notify error: ${err?.message}\n`);
+    // ── Lark notification (async, non-blocking) ──
+    notifyTaskProgress(args.operation, args, result).catch((err) => {
+        process.stderr.write(`[MCP/Task] Notify error: ${err instanceof Error ? err.message : String(err)}\n`);
     });
     return result;
 }
-// ── create ──
-async function _create(svc, args) {
-    if (!args.title) {
-        return envelope({
-            success: false,
-            message: 'title is required',
-            meta: { tool: 'autosnippet_task' },
-        });
+// ═══ prime ═══════════════════════════════════════════════
+async function _prime(ctx, args) {
+    const intent = ctx.session?.intent;
+    // If there is an active intent, persist it as abandoned before starting fresh
+    if (intent && intent.phase === 'active') {
+        _persistIntentChain(ctx, intent, 'abandoned', 'New prime received');
+    }
+    // ─── Intake: extract intent signals ───
+    const extracted = extractIntent(args.userQuery || '', args.activeFile, args.language);
+    // ─── Enrichment: multi-query search via PrimeSearchPipeline ───
+    const pipeline = _getPipeline(ctx.container);
+    let searchResult = null;
+    if (pipeline && extracted.queries[0]?.trim()) {
+        try {
+            searchResult = await pipeline.search(extracted);
+        }
+        catch {
+            // search failure is non-fatal
+        }
+    }
+    // ─── Lifecycle: initialize IntentState ───
+    const freshIntent = createIdleIntent();
+    freshIntent.phase = 'active';
+    freshIntent.primeQuery = args.userQuery || '';
+    freshIntent.primeActiveFile = args.activeFile;
+    freshIntent.primeLanguage = extracted.language;
+    freshIntent.primeModule = extracted.module;
+    freshIntent.primeScenario = extracted.scenario;
+    freshIntent.primeAt = Date.now();
+    if (searchResult) {
+        freshIntent.primeRecipeIds = [...searchResult.relatedKnowledge, ...searchResult.guardRules]
+            .map((r) => r.id)
+            .filter(Boolean);
+        freshIntent.searchMeta = {
+            queries: searchResult.searchMeta.queries,
+            resultCount: searchResult.searchMeta.resultCount,
+            filteredCount: searchResult.searchMeta.filteredCount,
+        };
+    }
+    // Bind intent to session
+    if (ctx.session) {
+        ctx.session.intent = freshIntent;
+    }
+    // ─── Delivery: build response ───
+    const relatedCount = searchResult?.relatedKnowledge.length ?? 0;
+    const ruleCount = searchResult?.guardRules.length ?? 0;
+    const lines = [];
+    if (relatedCount > 0 || ruleCount > 0) {
+        lines.push(`📋 Found ${relatedCount} recipe(s), ${ruleCount} guard rule(s).`);
+        for (const r of searchResult.relatedKnowledge) {
+            const hint = r.actionHint ? ` — ${r.actionHint}` : '';
+            const refs = r.sourceRefs?.length ? `\n    📍 ${r.sourceRefs.join(', ')}` : '';
+            lines.push(`  • ${r.trigger || r.title}${hint}${refs}`);
+        }
+        for (const r of searchResult.guardRules) {
+            lines.push(`  • [rule] ${r.trigger || r.title}`);
+        }
+    }
+    else {
+        lines.push('No matching recipes found.');
     }
-    const { task, isDuplicate } = await svc.create({
-        title: args.title,
-        description: args.description || '',
-        design: args.design || '',
-        acceptance: args.acceptance || '',
-        priority: args.priority ?? 2,
-        taskType: args.taskType || 'task',
-        parentId: args.parentId || null,
-    });
-    return envelope({
-        success: true,
-        data: task.toJSON(),
-        message: isDuplicate
-            ? `⚠ Duplicate detected: ${task.id} already exists`
-            : `Created ${task.id}: ${task.title}`,
-        meta: { tool: 'autosnippet_task' },
-    });
-}
-// ── ready ──
-async function _ready(svc, args) {
-    const tasks = await svc.ready({
-        limit: args.limit || 10,
-        withKnowledge: args.withKnowledge !== false,
-        userQuery: args.userQuery,
-        activeFile: args.activeFile,
-        language: args.language,
-    });
     return envelope({
         success: true,
-        data: tasks.map((t) => (t.toJSON ? t.toJSON() : t)),
-        message: `${tasks.length} task(s) ready`,
+        data: {
+            knowledge: searchResult
+                ? {
+                    relatedKnowledge: searchResult.relatedKnowledge,
+                    guardRules: searchResult.guardRules,
+                }
+                : null,
+            searchMeta: searchResult?.searchMeta ?? null,
+            _taskRules,
+        },
+        message: lines.join('\n'),
         meta: { tool: 'autosnippet_task' },
     });
 }
-// ── claim ──
-async function _claim(svc, args) {
-    if (!args.id) {
+// ═══ create ═════════════════════════════════════════════
+async function _create(ctx, args) {
+    if (!args.title) {
         return envelope({
             success: false,
-            message: 'id is required',
+            message: 'title is required',
             meta: { tool: 'autosnippet_task' },
         });
     }
-    const knowledgeOptions = args.userQuery || args.activeFile || args.language
-        ? { userQuery: args.userQuery, activeFile: args.activeFile, language: args.language }
-        : undefined;
-    const task = await svc.claim(args.id, 'agent', knowledgeOptions);
+    const taskId = _generateTaskId();
+    const intent = ctx.session?.intent;
+    // Bind task ID to current intent
+    if (intent && intent.phase === 'active') {
+        intent.taskId = taskId;
+        intent.taskTitle = args.title;
+    }
     return envelope({
         success: true,
-        data: task.toJSON(),
-        message: `Claimed ${args.id}`,
+        data: { id: taskId, title: args.title },
+        message: `📌 Created: ${taskId} — ${args.title}`,
         meta: { tool: 'autosnippet_task' },
     });
 }
-// ── close ──
-async function _close(ctx, svc, args) {
+// ═══ close ══════════════════════════════════════════════
+async function _close(ctx, args) {
     if (!args.id) {
         return envelope({
             success: false,
@@ -153,21 +182,23 @@ async function _close(ctx, svc, args) {
             meta: { tool: 'autosnippet_task' },
         });
     }
-    const { task, newlyReady } = await svc.close(args.id, args.reason || 'Completed');
-    const lines = [`✅ Closed: ${args.id} — ${task.title}`];
-    if (args.reason && args.reason !== 'Completed') {
-        lines.push(`Reason: ${args.reason}`);
+    const intent = ctx.session?.intent;
+    const reason = args.reason || 'Completed';
+    // Persist intent chain via SignalBus
+    if (intent && intent.phase === 'active') {
+        _persistIntentChain(ctx, intent, 'completed', reason);
     }
-    if (newlyReady.length > 0) {
-        lines.push(`→ ${newlyReady.length} task(s) newly ready`);
+    // Reset intent to idle
+    if (ctx.session) {
+        ctx.session.intent = createIdleIntent();
     }
+    const lines = [`✅ Closed: ${args.id} — ${reason}`];
     lines.push('');
-    lines.push('⚠️ REQUIRED: You MUST call autosnippet_guard (no args) NOW to review changed files for compliance violations. Do NOT proceed to the next task until guard review passes.');
+    lines.push('⚠️ REQUIRED: You MUST call autosnippet_guard (no args) NOW to review changed files for compliance violations.');
     return envelope({
         success: true,
         data: {
-            closed: task.toJSON(),
-            newlyReady,
+            closed: { id: args.id, reason, closedAt: Date.now() },
             nextAction: {
                 tool: 'autosnippet_guard',
                 args: {},
@@ -179,150 +210,8 @@ async function _close(ctx, svc, args) {
         meta: { tool: 'autosnippet_task' },
     });
 }
-// ── fail ──
-async function _fail(svc, args) {
-    if (!args.id) {
-        return envelope({
-            success: false,
-            message: 'id is required',
-            meta: { tool: 'autosnippet_task' },
-        });
-    }
-    const task = await svc.fail(args.id, args.reason || 'Agent execution failed');
-    return envelope({
-        success: true,
-        data: task.toJSON(),
-        message: `Failed ${args.id} (attempt #${task.failCount}): ${task.lastFailReason}`,
-        meta: { tool: 'autosnippet_task' },
-    });
-}
-// ── defer ──
-async function _defer(svc, args) {
-    if (!args.id) {
-        return envelope({
-            success: false,
-            message: 'id is required',
-            meta: { tool: 'autosnippet_task' },
-        });
-    }
-    const task = await svc.defer(args.id, args.reason || '');
-    return envelope({
-        success: true,
-        data: task.toJSON(),
-        message: `Deferred ${args.id}`,
-        meta: { tool: 'autosnippet_task' },
-    });
-}
-// ── progress ──
-async function _progress(svc, args) {
-    if (!args.id) {
-        return envelope({
-            success: false,
-            message: 'id is required',
-            meta: { tool: 'autosnippet_task' },
-        });
-    }
-    const note = args.reason || args.description || '';
-    const task = await svc.progress(args.id, note);
-    return envelope({
-        success: true,
-        data: task.toJSON(),
-        message: `Progress updated for ${args.id}`,
-        meta: { tool: 'autosnippet_task' },
-    });
-}
-// ── decompose ──
-async function _decompose(svc, args) {
-    if (!args.id) {
-        return envelope({
-            success: false,
-            message: 'Epic id is required',
-            meta: { tool: 'autosnippet_task' },
-        });
-    }
-    if (!args.subtasks || !Array.isArray(args.subtasks) || args.subtasks.length === 0) {
-        return envelope({
-            success: false,
-            message: 'subtasks array is required',
-            meta: { tool: 'autosnippet_task' },
-        });
-    }
-    const tasks = await svc.decompose(args.id, args.subtasks);
-    return envelope({
-        success: true,
-        data: tasks.map((t) => (t.toJSON ? t.toJSON() : t)),
-        message: `Decomposed ${args.id} into ${tasks.length} subtasks`,
-        meta: { tool: 'autosnippet_task' },
-    });
-}
-// ── show ──
-async function _show(svc, args) {
-    if (!args.id) {
-        return envelope({
-            success: false,
-            message: 'id is required',
-            meta: { tool: 'autosnippet_task' },
-        });
-    }
-    const task = await svc.show(args.id);
-    if (!task) {
-        return envelope({
-            success: false,
-            message: `Task not found: ${args.id}`,
-            meta: { tool: 'autosnippet_task' },
-        });
-    }
-    return envelope({
-        success: true,
-        data: task.toJSON(),
-        meta: { tool: 'autosnippet_task' },
-    });
-}
-// ── list ──
-async function _list(svc, args) {
-    const filters = {};
-    if (args.status) {
-        filters.status = args.status;
-    }
-    if (args.taskType) {
-        filters.taskType = args.taskType;
-    }
-    const tasks = await svc.list(filters, { limit: args.limit || 20 });
-    return envelope({
-        success: true,
-        data: tasks.map((t) => t.toJSON()),
-        message: `${tasks.length} task(s)`,
-        meta: { tool: 'autosnippet_task' },
-    });
-}
-// ── blocked ──
-async function _blocked(svc) {
-    const tasks = await svc.blocked();
-    return envelope({
-        success: true,
-        data: tasks,
-        message: `${tasks.length} blocked task(s)`,
-        meta: { tool: 'autosnippet_task' },
-    });
-}
-// ── dep_add ──
-async function _depAdd(svc, args) {
-    if (!args.id || !args.dependsOn) {
-        return envelope({
-            success: false,
-            message: 'id and dependsOn are required',
-            meta: { tool: 'autosnippet_task' },
-        });
-    }
-    await svc.addDependency(args.id, args.dependsOn, args.depType || 'blocks');
-    return envelope({
-        success: true,
-        message: `${args.id} ${args.depType || 'blocks'} ${args.dependsOn}`,
-        meta: { tool: 'autosnippet_task' },
-    });
-}
-// ── dep_tree ──
-async function _depTree(svc, args) {
+// ═══ fail ═══════════════════════════════════════════════
+async function _fail(ctx, args) {
     if (!args.id) {
         return envelope({
             success: false,
@@ -330,104 +219,27 @@ async function _depTree(svc, args) {
             meta: { tool: 'autosnippet_task' },
         });
     }
-    const tree = await svc.depTree(args.id);
-    return envelope({
-        success: true,
-        data: tree,
-        message: `${tree.length} node(s) in dependency tree`,
-        meta: { tool: 'autosnippet_task' },
-    });
-}
-// ── stats ──
-async function _stats(svc) {
-    const stats = await svc.stats();
-    return envelope({
-        success: true,
-        data: stats,
-        meta: { tool: 'autosnippet_task' },
-    });
-}
-// ═══ Session (prime) ═══════════════════════════════════
-async function _prime(svc, args) {
-    const result = await svc.prime({
-        limit: args.limit || 10,
-        withKnowledge: args.withKnowledge !== false,
-        userQuery: args.userQuery,
-        activeFile: args.activeFile,
-        language: args.language,
-    });
-    const decisionCount = (result.decisions || []).length;
-    const staleCount = (result.staleDecisions || []).length;
-    const decisionTitles = (result.decisions || []).map((d) => d.title).join('; ');
-    const statsLine = `${result.inProgress.length} in-progress, ${result.ready.length} ready, ${result.stats.total} total`;
-    // ── Behavioral Rules Reminder (survives compaction) ──
-    result._taskRules = {
-        reminder: [
-            '📋 TASK RULES (MANDATORY):',
-            '🔑 YOU are the task operator — user speaks naturally, you translate to task operations. NEVER tell user to run task commands.',
-            '• MUST prime on EVERY message BEFORE anything else',
-            '• MUST create task for non-trivial work (≥2 files OR ≥10 lines)',
-            '• MUST claim before coding, close when done with meaningful reason',
-            '• MUST handle unfinished tasks before starting new work (ask user: Continue/Defer/Abandon)',
-            '• NEVER skip prime, NEVER start new work with open in_progress tasks',
-            '• NEVER leave tasks in in_progress when session ends — close or defer ALL',
-            '• When in doubt → create a task. When idle → ready()',
-            '• Session end → close all tasks, defer incomplete, verify zero in_progress',
-        ].join('\n'),
-        translationHint: [
-            'User Says → You Run:',
-            '"fix bug"/"implement" → create→claim→code→close',
-            '"continue" → resume in-progress→close',
-            '"pause" → defer | "abandon" → fail | "break down" → decompose',
-            '"what\'s next" → ready() | "agreed" → record_decision',
-            'Quick question → No task. Just answer.',
-        ].join('\n'),
-    };
-    let message;
-    if (decisionCount > 0) {
-        const stalePart = staleCount > 0 ? ` ${staleCount} stale.` : '';
-        message = `⚠️ ${decisionCount} ACTIVE DECISION(S): [${decisionTitles}].${stalePart} ${statsLine}.`;
+    const intent = ctx.session?.intent;
+    const reason = args.reason || 'Agent execution failed';
+    // Persist intent chain via SignalBus
+    if (intent && intent.phase === 'active') {
+        _persistIntentChain(ctx, intent, 'failed', reason);
     }
-    else {
-        message = `${statsLine}.`;
-    }
-    // ── Resume Prompt: 有 inProgress 任务时，提示 Agent 让用户选择 ──
-    if (result.inProgress.length > 0) {
-        const taskList = result.inProgress
-            .map((t) => {
-            const age = t.updatedAt
-                ? `${Math.floor((Date.now() / 1000 - t.updatedAt) / 86400)}d ago`
-                : '';
-            return `• **${t.id}** — ${t.title}${age ? ` (${age})` : ''}`;
-        })
-            .join('\n');
-        result._resumePrompt = {
-            instruction: [
-                'There are unfinished tasks. You MUST present these options to the user BEFORE doing anything else:',
-                '',
-                '**Unfinished tasks:**',
-                taskList,
-                '',
-                'Ask the user to choose:',
-                '1. **Continue** — resume the unfinished task(s)',
-                '2. **Defer** — pause it and work on something else',
-                '3. **Abandon** — close/fail it and start fresh',
-                '',
-                "Wait for the user's answer. Do NOT auto-resume.",
-            ].join('\n'),
-            taskIds: result.inProgress.map((t) => t.id),
-        };
-        message += ` ⏸️ ${result.inProgress.length} unfinished task(s) — ask user before resuming.`;
+    // Reset intent to idle
+    if (ctx.session) {
+        ctx.session.intent = createIdleIntent();
     }
     return envelope({
         success: true,
-        data: result,
-        message,
+        data: {
+            failed: { id: args.id, reason, failedAt: Date.now() },
+        },
+        message: `❌ Failed: ${args.id} — ${reason}`,
         meta: { tool: 'autosnippet_task' },
     });
 }
-// ═══ Decisions ═══════════════════════════════════════
-async function _recordDecision(svc, args) {
+// ═══ record_decision ════════════════════════════════════
+async function _recordDecision(ctx, args) {
     if (!args.title) {
         return envelope({
             success: false,
@@ -442,229 +254,78 @@ async function _recordDecision(svc, args) {
             meta: { tool: 'autosnippet_task' },
         });
     }
-    const { task, isDuplicate } = await svc.recordDecision({
+    const decisionId = `dec-${Date.now().toString(36)}`;
+    const decision = {
+        id: decisionId,
         title: args.title,
         description: args.description,
-        rationale: args.rationale || '',
-        tags: args.tags || [],
-        relatedTaskId: args.relatedTaskId || null,
-    });
-    return envelope({
-        success: true,
-        data: task.toJSON(),
-        message: isDuplicate
-            ? `⚠ Decision already recorded: ${task.id}`
-            : `✅ Decision pinned: ${task.id} — "${args.title}"`,
-        meta: { tool: 'autosnippet_task' },
-    });
-}
-async function _reviseDecision(svc, args) {
-    if (!args.id) {
-        return envelope({
-            success: false,
-            message: 'id of old decision is required',
-            meta: { tool: 'autosnippet_task' },
-        });
-    }
-    if (!args.title) {
-        return envelope({
-            success: false,
-            message: 'title of new decision is required',
-            meta: { tool: 'autosnippet_task' },
-        });
-    }
-    if (!args.description) {
-        return envelope({
-            success: false,
-            message: 'description of new decision is required',
-            meta: { tool: 'autosnippet_task' },
-        });
-    }
-    const result = await svc.reviseDecision({
-        oldDecisionId: args.id,
-        title: args.title,
-        description: args.description,
-        rationale: args.rationale || '',
-        reason: args.reason || '',
-    });
-    return envelope({
-        success: true,
-        data: {
-            newDecision: result.newDecision.toJSON(),
-            superseded: result.oldDecisionId,
-        },
-        message: `✅ Decision revised: ${result.oldDecisionId} → ${result.newDecision.id}`,
-        meta: { tool: 'autosnippet_task' },
-    });
-}
-async function _unpinDecision(svc, args) {
-    if (!args.id) {
-        return envelope({
-            success: false,
-            message: 'id is required',
-            meta: { tool: 'autosnippet_task' },
-        });
+        rationale: args.rationale,
+        tags: args.tags,
+        recordedAt: Date.now(),
+    };
+    // Push to current intent's decisions
+    const intent = ctx.session?.intent;
+    if (intent && intent.phase === 'active') {
+        intent.decisions.push(decision);
     }
-    const task = await svc.unpinDecision(args.id, args.reason || '');
-    return envelope({
-        success: true,
-        data: task.toJSON(),
-        message: `Decision ${args.id} unpinned and closed`,
-        meta: { tool: 'autosnippet_task' },
-    });
-}
-async function _listDecisions(svc) {
-    const decisions = await svc.list({ status: 'pinned', taskType: 'decision' }, { limit: 50 });
     return envelope({
         success: true,
-        data: decisions.map((d) => d.toJSON()),
-        message: `${decisions.length} active decision(s)`,
+        data: { decision: { id: decisionId, title: args.title } },
+        message: `📌 Decision recorded: ${args.title}`,
         meta: { tool: 'autosnippet_task' },
     });
 }
-// ═══ 飞书任务进度通知（通过 API Server 中转）═══════════════
-//
-// MCP Server 与 API Server 是独立进程。
-// 飞书 WSClient 连接在 API Server 中，因此通知需 HTTP 中转。
-// ═══════════════════════════════════════════════════════════
-const PRIORITY_LABELS = ['P0 紧急', 'P1 高', 'P2 中', 'P3 低', 'P4 微'];
-/** 通过 API Server 的 /api/v1/remote/notify 发送飞书通知 */
-async function _sendLarkViaApi(text) {
+// ═══ Intent Chain Persistence (via SignalBus) ═══════════
+function _persistIntentChain(ctx, intent, outcome, reason) {
+    const now = Date.now();
+    const chain = {
+        sessionId: ctx.session?.id || 'unknown',
+        taskId: intent.taskId,
+        outcome,
+        primeQuery: intent.primeQuery,
+        primeActiveFile: intent.primeActiveFile,
+        primeRecipeIds: intent.primeRecipeIds,
+        primeAt: intent.primeAt || now,
+        primeLanguage: intent.primeLanguage ?? null,
+        primeModule: intent.primeModule ?? null,
+        primeScenario: intent.primeScenario ?? 'search',
+        searchMeta: intent.searchMeta,
+        toolCalls: intent.toolCalls,
+        searchQueries: intent.searchQueries,
+        mentionedFiles: intent.mentionedFiles,
+        decisions: intent.decisions,
+        driftEvents: intent.driftEvents,
+        driftScore: _computeDriftScore(intent),
+        closeReason: outcome === 'completed' ? reason : undefined,
+        failReason: outcome !== 'completed' ? reason : undefined,
+        startedAt: intent.primeAt || now,
+        endedAt: now,
+        duration: now - (intent.primeAt || now),
+    };
+    // Emit via SignalBus — subscribers handle JSONL persistence
     try {
-        const port = process.env.PORT || 3000;
-        const resp = await fetch(`http://localhost:${port}/api/v1/remote/notify`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ text }),
-            signal: AbortSignal.timeout(5000),
+        const signalBus = ctx.container.get('signalBus');
+        signalBus.send('intent', 'TaskHandler', _computeDriftScore(intent), {
+            target: intent.taskId ?? null,
+            metadata: { chain },
         });
-        if (!resp.ok) {
-            process.stderr.write(`[MCP/Task] Lark notify HTTP ${resp.status}\n`);
-            return false;
-        }
-        const body = (await resp.json());
-        return body.success === true;
     }
-    catch (err) {
-        process.stderr.write(`[MCP/Task] Lark notify failed: ${err instanceof Error ? err.message : String(err)}\n`);
-        return false;
+    catch {
+        // signalBus unavailable — silent failure, non-blocking
     }
 }
-/**
- * 通过 API Server 截取 IDE 窗口截图并发送到飞书
- * @param [caption] 可选文字说明
- */
-async function _sendScreenshotViaApi(caption = '') {
-    try {
-        const port = process.env.PORT || 3000;
-        const resp = await fetch(`http://localhost:${port}/api/v1/remote/screenshot`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ caption }),
-            signal: AbortSignal.timeout(15000),
-        });
-        if (!resp.ok) {
-            process.stderr.write(`[MCP/Task] Screenshot HTTP ${resp.status}\n`);
-            return false;
-        }
-        const body = (await resp.json());
-        return body.success === true;
-    }
-    catch (err) {
-        process.stderr.write(`[MCP/Task] Screenshot failed: ${err instanceof Error ? err.message : String(err)}\n`);
-        return false;
+function _computeDriftScore(intent) {
+    if (intent.driftEvents.length === 0) {
+        return 0;
     }
+    const sum = intent.driftEvents.reduce((acc, d) => acc + (1 - d.primeOverlap), 0);
+    return sum / intent.driftEvents.length;
 }
-/**
- * 根据任务操作向飞书发送进度通知（异步非阻塞）
- * result 是 envelope() 返回的 { success, data, message, meta }
- */
-async function _notifyTaskProgress(operation, args, result) {
-    if (!result || result.success === false) {
-        return;
-    }
-    const data = result.data;
-    let text = '';
-    switch (operation) {
-        case 'create': {
-            const title = data?.title || args.title || '';
-            const id = data?.id || '';
-            const type = data?.taskType || args.taskType || 'task';
-            const pri = PRIORITY_LABELS[(data?.priority ?? args.priority ?? 2)] || 'P2';
-            const dup = result.message?.includes('Duplicate') || result.message?.startsWith('⚠') ? ' (重复)' : '';
-            text = `📋 新任务${dup}: ${id}\n${title}\n类型: ${type} | ${pri}`;
-            break;
-        }
-        case 'claim': {
-            const id = data?.id || args.id;
-            const title = data?.title || '';
-            text = `🔨 开始执行: ${id}\n${title}`;
-            break;
-        }
-        case 'close': {
-            const closed = (data?.closed || data);
-            const title = closed?.title || '';
-            const id = closed?.id || args.id;
-            const reason = closed?.closeReason || args.reason || '';
-            const readyCount = Array.isArray(data?.newlyReady) ? data.newlyReady.length : 0;
-            const readyInfo = readyCount > 0 ? `\n→ ${readyCount} 个任务新就绪` : '';
-            text = `✅ 完成: ${id}\n${title}\n原因: ${reason}${readyInfo}`;
-            break;
-        }
-        case 'fail': {
-            const title = data?.title || '';
-            const id = data?.id || args.id;
-            const reason = data?.lastFailReason || args.reason || '未知';
-            const count = Number(data?.failCount || 0);
-            text = `❌ 失败: ${id}\n${title}\n原因: ${reason}${count > 1 ? ` (第${count}次)` : ''}`;
-            break;
-        }
-        case 'defer': {
-            const id = data?.id || args.id;
-            const title = data?.title || '';
-            text = `⏸️ 暂缓: ${id} — ${title}`;
-            break;
-        }
-        case 'progress': {
-            const id = data?.id || args.id;
-            const note = args.reason || args.description || '';
-            text = note ? `📝 进度: ${id}\n${note.slice(0, 200)}` : `📝 进度: ${id}`;
-            break;
-        }
-        case 'decompose': {
-            const epicId = args.id;
-            const count = Array.isArray(data) ? data.length : 0;
-            const subTitles = Array.isArray(data)
-                ? data
-                    .slice(0, 5)
-                    .map((t, i) => `  ${i + 1}. ${t.title || t.id}`)
-                    .join('\n')
-                : '';
-            text = `📂 拆解: ${epicId} → ${count} 个子任务${subTitles ? `\n${subTitles}` : ''}`;
-            break;
-        }
-        case 'record_decision': {
-            const title = data?.title || args.title || '';
-            text = `📌 决策: ${title}`;
-            break;
-        }
-        case 'revise_decision': {
-            const oldId = data?.superseded || args.id;
-            const newTitle = data?.newDecision?.title || args.title;
-            text = `🔄 决策更新: ${oldId} → ${newTitle}`;
-            break;
-        }
-        case 'unpin_decision': {
-            const id = data?.id || args.id;
-            text = `🔓 决策取消: ${id}`;
-            break;
-        }
-        default:
-            return;
+function _getPipeline(container) {
+    try {
+        return container.get('primeSearchPipeline');
     }
-    if (text) {
-        await _sendLarkViaApi(text);
-        // 发送文字通知后，附带 IDE 窗口截图
-        await _sendScreenshotViaApi();
+    catch {
+        return null;
     }
 }