@ema.co/mcp-toolkit 2026.3.25-4 → 2026.3.29-1

package/dist/config/tool-guidance.js

@@ -176,13 +176,13 @@ export const TOOL_GUIDANCE = {
         operations: [
             { name: "Get", description: "Fetch current workflow_def + generation schema", example: 'workflow(mode="get", persona_id="...")' },
             { name: "Get (slim)", description: "Fetch slimmed workflow_def for large workflows (strips displaySettings, truncates long values, ~60-70% smaller)", example: 'workflow(mode="get", persona_id="...", slim=true)' },
-            { name: "Deploy", description: "Deploy LLM-generated workflow_def", example: 'workflow(mode="deploy", persona_id="...", workflow_def={...})' },
+            { name: "Deploy", description: "Deploy LLM-generated workflow_def. Deploy outcomes automatically feed knowledge quality — failures demote consulted docs. Test with conversation() after deploy to validate intent alignment.", example: 'workflow(mode="deploy", persona_id="...", workflow_def={...})' },
             { name: "Validate", description: "Static validation with path enumeration", example: 'workflow(mode="validate", persona_id="...")' },
             { name: "Optimize", description: "Structural graph optimization", example: 'workflow(mode="optimize", persona_id="...")' },
         ],
         nextSteps: {
             get: "Build a workflow_def based on the generation_schema and deploy it.",
-            deploy: "Verify deployment: workflow(mode='get', persona_id='...')",
+            deploy: "Test with conversation() to validate intent alignment. Deploy success only means the API accepted it — conversation testing validates the persona actually works.",
             validate: "Fix any reported issues, then deploy.",
             optimize: "Review optimized workflow_def, then deploy if acceptable.",
         },

package/dist/knowledge/search-client.js

@@ -653,6 +653,8 @@ export async function browseDocuments(options = {}) {
 // ─────────────────────────────────────────────────────────────────────────────
 // User Event Tracking
 // ─────────────────────────────────────────────────────────────────────────────
+/** Counters for UserEvent pipeline health — exposed via feedback(method="analyze"). */
+export const userEventCounters = { sent: 0, failed: 0 };
 export async function writeUserEvent(event) {
     if (!isVertexEventsEnabled())
         return;
@@ -661,15 +663,24 @@ export async function writeUserEvent(event) {
     if (!headers)
         return;
     try {
-        await fetch(`${de.baseUrl}/${de.datastorePath}/userEvents:write`, {
+        const resp = await fetch(`${de.baseUrl}/${de.datastorePath}/userEvents:write`, {
             method: "POST",
             headers,
             body: JSON.stringify(event),
             signal: AbortSignal.timeout(5_000),
         });
+        if (!resp.ok) {
+            userEventCounters.failed++;
+            const detail = await resp.text().catch(() => "");
+            console.error(`[SEARCH-CLIENT] UserEvent write failed: ${resp.status} — ${detail.slice(0, 200)}`);
+        }
+        else {
+            userEventCounters.sent++;
+        }
     }
     catch {
-        // Fire-and-forget
+        userEventCounters.failed++;
+        // Fire-and-forget — timeout or network error
     }
 }
 /**

package/dist/knowledge/search-config.js

@@ -38,8 +38,9 @@ export function getSearchBackend() {
 export function isDiscoveryEngineEnabled() {
     return getSearchBackend() === "discovery-engine";
 }
+/** UserEvent tracking is ON by default. Set EMA_VERTEX_EVENTS=false to opt out. */
 export function isVertexEventsEnabled() {
-    return process.env.EMA_VERTEX_EVENTS?.trim().toLowerCase() === "true";
+    return process.env.EMA_VERTEX_EVENTS?.trim().toLowerCase() !== "false";
 }
 export function getDeConfig() {
     const project = process.env.EMA_GCP_PROJECT?.trim() || DEFAULT_PROJECT;

package/dist/mcp/handlers/feedback/index.js

@@ -16,6 +16,9 @@ import { submitFeedback, listFeedback, listTelemetry, analyzeFeedback, rotateLog
 import { markProbeResponded } from "./probes.js";
 import { appendToOutbox, flushOutbox, getOutboxStats, readLocalMessages } from "./outbox.js";
 import { isRemoteEnabled } from "./remote-store.js";
+import { writeUserEvent } from "../../../knowledge/search-client.js";
+import { getOrCreateClientId } from "./client-id.js";
+import { getAttributionToken } from "../knowledge/session-state.js";
 import { analyzeGlobal } from "./global-analysis.js";
 import { TOOLKIT_VERSION } from "../env/config.js";
 const VALID_CATEGORIES = ALL_CATEGORIES;
@@ -141,6 +144,35 @@ async function handleSubmit(args) {
             // Best-effort — don't block feedback submission
         }
     }
+    // UserEvent emission: fire DE conversion/view-item for positive feedback with knowledge_ref.
+    // Independent of confidence loop — no guards, no cooldown. Fire-and-forget.
+    if (knowledgeRef) {
+        const isSuccess = category === "success";
+        const isHighQuality = category === "quality"
+            && (qualityData?.accuracy ?? 0) >= 4
+            && (qualityData?.usefulness ?? 0) >= 4;
+        const isInteraction = category === "interaction";
+        if (isSuccess || isHighQuality || isInteraction) {
+            const conversionType = isSuccess ? "knowledge-success"
+                : isHighQuality ? "knowledge-quality-high"
+                    : undefined; // interaction → view-item, no conversionType
+            getOrCreateClientId()
+                .then((clientId) => {
+                const token = getAttributionToken(knowledgeRef);
+                writeUserEvent({
+                    eventType: conversionType ? "conversion" : "view-item",
+                    userPseudoId: clientId,
+                    ...(token ? { attributionToken: token } : {}),
+                    documents: [{
+                            id: knowledgeRef,
+                            ...(conversionType ? { conversionValue: isSuccess ? 1.0 : 0.8 } : {}),
+                        }],
+                    ...(conversionType ? { conversionType } : {}),
+                }).catch(() => { });
+            })
+                .catch(() => { });
+        }
+    }
     return {
         success: true,
         feedback_id: entry.id,

package/dist/mcp/handlers/feedback/store.js

@@ -12,6 +12,7 @@ import { promises as fs } from "node:fs";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { getToolkitRoot } from "../../../sdk/paths.js";
+import { userEventCounters } from "../../../knowledge/search-client.js";
 import { appendToOutbox } from "./outbox.js";
 import { isRemoteEnabled } from "./remote-store.js";
 import { SESSION_ID } from "./session.js";
@@ -384,6 +385,8 @@ export async function analyzeFeedback(rootOverride) {
             qualityEntries.reduce((sum, e) => sum + (e.quality_data.accuracy ?? 0), 0) /
                 qualityEntries.length;
     }
+    // UserEvent pipeline counters (in-memory, this session only)
+    const hasEventActivity = userEventCounters.sent > 0 || userEventCounters.failed > 0;
     return {
         summary: {
             total_feedback: feedback.length,
@@ -394,6 +397,7 @@ export async function analyzeFeedback(rootOverride) {
             telemetry_period: telemetry.length > 0
                 ? { from: telemetry[0].ts, to: telemetry[telemetry.length - 1].ts }
                 : null,
+            ...(hasEventActivity ? { user_events: { ...userEventCounters } } : {}),
         },
         category_breakdown: categoryBreakdown,
         hot_spots: {

package/dist/mcp/handlers/knowledge/confidence-loop.js

@@ -40,13 +40,18 @@ const cooldownMap = new Map();
 let sessionUpdateCount = 0;
 /** Per-document feedback history for graduated scoring */
 const feedbackHistoryMap = new Map();
+/** Recognized outcome suffixes from the outcome-feedback module */
+const OUTCOME_SUFFIXES = ["_success", "_failure", "_partial", "_misaligned", "_accepted"];
 /** Classify feedback strength based on context */
 export function classifyEvidence(category, context) {
-    // Deploy failures are hard evidence
-    if (context?.includes("deploy_failure"))
-        return "hard";
-    if (category === "correction" && context?.includes("deploy"))
-        return "hard";
+    // Any tool outcome with a structured context suffix is hard evidence.
+    // Context format from outcome-feedback: "{tool}_{operation}_{quality}"
+    if (context) {
+        for (const suffix of OUTCOME_SUFFIXES) {
+            if (context.endsWith(suffix))
+                return "hard";
+        }
+    }
     // Explicit corrections with knowledge_ref are medium-hard
     if (category === "correction")
         return "hard";

package/dist/mcp/handlers/knowledge/index.js

@@ -15,6 +15,8 @@ import { inferSourceType } from "../../../knowledge/pipeline/types.js";
 import { computeConfidenceScore } from "../../../knowledge/pipeline/confidence.js";
 import { actionsForSearchResults, actionsForNoResults, actionsForPublish } from "../response-actions.js";
 import { generateRelatedQueries } from "./related-queries.js";
+import { getOrCreateClientId } from "../feedback/client-id.js";
+import { recordSearchResults } from "./session-state.js";
 const GCS_BUCKET = "em1-knowledge";
 async function checkSupersedeGuard(supersedes) {
     if (!supersedes || supersedes.length === 0)
@@ -599,6 +601,8 @@ async function handleQuery(args) {
         if (related.length > 0) {
             result._related_queries = related;
         }
+        // Record results in session state for attribution cache + consultedDocs tracking
+        recordSearchResults(results.map((r) => ({ id: r.id })), response.attributionToken);
         fireSearchEvent(query, response.attributionToken);
         return result;
     }
@@ -649,6 +653,8 @@ function contextualNextStep(results) {
         return "Follow the guide steps relevant to your task";
     return "Review results and refine search if needed";
 }
+/** Cached client ID for UserEvent pseudoId — resolved once, then sync. */
+let _cachedPseudoId;
 function fireSearchEvent(query, attributionToken) {
     recordTelemetry({
         type: "search_event",
@@ -657,10 +663,21 @@ function fireSearchEvent(query, attributionToken) {
         ok: true,
         resource_uri: attributionToken,
     }).catch(() => { });
-    writeUserEvent({
-        eventType: "search",
-        userPseudoId: "mcp-agent",
-        attributionToken,
-        searchInfo: { searchQuery: query },
-    }).catch(() => { });
+    // Resolve pseudoId: use cached value if available, otherwise resolve async (first call only)
+    const emit = (pseudoId) => {
+        writeUserEvent({
+            eventType: "search",
+            userPseudoId: pseudoId,
+            attributionToken,
+            searchInfo: { searchQuery: query },
+        }).catch(() => { });
+    };
+    if (_cachedPseudoId) {
+        emit(_cachedPseudoId);
+    }
+    else {
+        getOrCreateClientId()
+            .then((id) => { _cachedPseudoId = id; emit(id); })
+            .catch(() => { emit("mcp-agent"); }); // fallback if client-id resolution fails
+    }
 }

package/dist/mcp/handlers/knowledge/outcome-feedback.js

@@ -0,0 +1,205 @@
+/**
+ * Outcome Feedback — Layered signal emitter for knowledge quality feedback.
+ *
+ * Captures the full lifecycle of an agent interaction:
+ *
+ *   Intent stated → work done → outcome assessed at multiple layers
+ *
+ * Signal layers (each carries different weight):
+ *   1. API acceptance  (0.1) — system accepted the input structurally
+ *   2. Agent assessment (0.3) — agent's self-evaluation of alignment
+ *   3. Agent validation (0.5) — functional testing (conversation, debug)
+ *   4. End-user signal  (1.0) — real user responded, kept using it, or abandoned
+ *
+ * Intent tracking:
+ *   - Original intent is recorded at the start of the interaction
+ *   - If intent pivots mid-journey, that's knowledge (not failure):
+ *     "Users with intent X often pivot to Y" → proactive suggestion for next agent
+ *   - Outcome is assessed against the FINAL intent, not the original
+ *   - But the pivot itself is published as a pattern signal
+ */
+import { getConsultedDocs } from "./session-state.js";
+import { processConfidenceFeedback } from "./confidence-loop.js";
+import { writeUserEvent } from "../../../knowledge/search-client.js";
+import { getOrCreateClientId } from "../feedback/client-id.js";
+/** Weight multiplier per signal layer */
+const LAYER_WEIGHTS = {
+    system: 0.1, // API accepted it — weakest signal
+    agent: 0.3, // Agent self-assessment — has context but may be biased
+    validation: 0.5, // Functional testing — objective but synthetic
+    user: 1.0, // End-user response — ground truth
+};
+// ─────────────────────────────────────────────────────────────────────────────
+// Outcome Resolution
+// ─────────────────────────────────────────────────────────────────────────────
+function resolveOutcome(success) {
+    if (typeof success === "boolean") {
+        return success
+            ? { quality: "success", isPositive: true, suffix: "success", category: "success" }
+            : { quality: "failure", isPositive: false, suffix: "failure", category: "correction" };
+    }
+    switch (success) {
+        case "success":
+            return { quality: "success", isPositive: true, suffix: "success", category: "success" };
+        case "partial":
+            return { quality: "partial", isPositive: true, suffix: "partial", category: "success" };
+        case "accepted":
+            return { quality: "accepted", isPositive: true, suffix: "accepted", category: "interaction" };
+        case "misaligned":
+            return { quality: "misaligned", isPositive: false, suffix: "misaligned", category: "correction" };
+        case "failure":
+            return { quality: "failure", isPositive: false, suffix: "failure", category: "correction" };
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Intent Pivot Tracking
+// ─────────────────────────────────────────────────────────────────────────────
+const MAX_PIVOTS = 100;
+/** In-memory pivot accumulator — aggregated by the journey/feedback adapter */
+const intentPivots = [];
+/** Get accumulated intent pivots (for journey reporting) */
+export function getIntentPivots() {
+    return intentPivots;
+}
+/** Reset pivot state (for test isolation) */
+export function _resetIntentPivots() {
+    intentPivots.length = 0;
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Main Entry Point
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Emit outcome feedback for all consulted knowledge docs in the current session.
+ *
+ * Best-effort: never throws. Failures are logged but don't block the calling handler.
+ *
+ * @example
+ * // Layer 1: Deploy accepted (system signal, low weight)
+ * await emitOutcomeFeedback({
+ *   tool: "workflow", operation: "deploy", success: "accepted", layer: "system",
+ * });
+ *
+ * // Layer 2: Agent thinks it looks right
+ * await emitOutcomeFeedback({
+ *   tool: "workflow", operation: "deploy", success: "partial", layer: "agent",
+ *   intent: "route billing questions to billing team",
+ * });
+ *
+ * // Layer 3: Conversation test confirms behavior
+ * await emitOutcomeFeedback({
+ *   tool: "conversation", operation: "test", success: "success", layer: "validation",
+ *   intent: "route billing questions to billing team",
+ * });
+ *
+ * // Layer 4: End-user kept using it (highest weight)
+ * await emitOutcomeFeedback({
+ *   tool: "conversation", operation: "usage", success: true, layer: "user",
+ * });
+ *
+ * // Intent pivot (knowledge, not failure):
+ * await emitOutcomeFeedback({
+ *   tool: "workflow", operation: "deploy", success: "success", layer: "validation",
+ *   intent: {
+ *     original: "route billing questions to billing team",
+ *     final: "route billing questions and auto-generate invoice summaries",
+ *     pivotReason: "user realized they also need invoice summaries during testing",
+ *   },
+ * });
+ */
+export async function emitOutcomeFeedback(event) {
+    const docs = getConsultedDocs();
+    const outcome = resolveOutcome(event.success);
+    const layer = event.layer ?? "system";
+    const weight = LAYER_WEIGHTS[layer];
+    const eventType = `${event.tool}-${event.operation}-${outcome.suffix}`;
+    // Track intent pivots — these are knowledge signals, not failures
+    if (event.intent && typeof event.intent === "object" && event.intent.final && event.intent.final !== event.intent.original) {
+        intentPivots.push({
+            original: event.intent.original,
+            final: event.intent.final,
+            reason: event.intent.pivotReason,
+            tool: event.tool,
+            timestamp: new Date().toISOString(),
+        });
+        // Evict oldest entries to prevent unbounded growth
+        while (intentPivots.length > MAX_PIVOTS)
+            intentPivots.shift();
+        console.error(`[INTENT-PIVOT] "${event.intent.original}" → "${event.intent.final}"` +
+            (event.intent.pivotReason ? ` (${event.intent.pivotReason})` : ""));
+    }
+    if (docs.size === 0) {
+        return { docs_processed: 0, confidence_updates: 0, event_type: eventType };
+    }
+    // "accepted" = system accepted it, no intent validation → skip confidence updates.
+    // This applies at ALL layers: "accepted" means structural acceptance, not functional
+    // success. Use "partial" or "success" to indicate functional validation.
+    if (outcome.quality === "accepted") {
+        return { docs_processed: docs.size, confidence_updates: 0, event_type: eventType };
+    }
+    const defaultCategory = outcome.category;
+    // Context encodes tool, operation, quality, AND layer for evidence classification
+    const context = `${event.tool}_${event.operation}_${outcome.suffix}`;
+    let updates = 0;
+    // Scale the quality signal for lower layers: system/agent produce weaker
+    // quality data, so downgrade "success" to "interaction" (neutral) at system layer.
+    // Higher layers (validation, user) keep the original category.
+    const effectiveDefaultCategory = (layer === "system" && defaultCategory === "success")
+        ? "interaction" // System-layer positive is neutral — API acceptance isn't validation
+        : defaultCategory;
+    const assessment = event.agentAssessment;
+    const helpfulSet = new Set(assessment?.helpful ?? []);
+    const misleadingSet = new Set(assessment?.misleading ?? []);
+    for (const docId of docs) {
+        try {
+            // Agent assessment overrides the blanket signal per doc
+            let category = effectiveDefaultCategory;
+            if (helpfulSet.has(docId)) {
+                category = "success";
+            }
+            else if (misleadingSet.has(docId)) {
+                category = "correction";
+            }
+            const result = await processConfidenceFeedback(category, docId, undefined, context);
+            if (result)
+                updates++;
+        }
+        catch {
+            // Best-effort
+        }
+    }
+    // Emit gap signals for missing knowledge
+    if (assessment?.missing) {
+        for (const topic of assessment.missing) {
+            try {
+                await processConfidenceFeedback("gap", `missing:${topic}`, undefined, context);
+            }
+            catch {
+                // Best-effort
+            }
+        }
+    }
+    // Fire UserEvents (fire-and-forget)
+    getOrCreateClientId()
+        .then((clientId) => {
+        // Conversion value = outcome quality × layer weight
+        const baseValue = outcome.quality === "success" ? 1.0
+            : outcome.quality === "partial" ? 0.5
+                : 0;
+        const conversionValue = baseValue * weight;
+        const isConversion = outcome.isPositive && outcome.quality !== "accepted";
+        const documents = [...docs].map((docId) => ({
+            id: docId,
+            ...(isConversion ? { conversionValue } : {}),
+        }));
+        writeUserEvent({
+            eventType: isConversion ? "conversion" : "view-item",
+            userPseudoId: clientId,
+            ...(isConversion ? { conversionType: eventType } : {}),
+            documents,
+        }).catch(() => { });
+    })
+        .catch(() => { });
+    console.error(`[OUTCOME-FEEDBACK] ${eventType} (layer=${layer}, weight=${weight}): ` +
+        `${docs.size} consulted docs, ${updates} confidence updates`);
+    return { docs_processed: docs.size, confidence_updates: updates, event_type: eventType };
+}

package/dist/mcp/handlers/knowledge/session-state.js

@@ -0,0 +1,110 @@
+/**
+ * Session State — Shared tracking for knowledge search sessions.
+ *
+ * Tracks which documents were served (consultedDocs), their attribution tokens,
+ * and DE resource names. Used by:
+ * - Task 2.2:  consultedDocs for deploy outcome feedback
+ * - Task 2.9:  attribution token cache for UserEvent correlation
+ * - Task 2.10: conversion events from positive feedback
+ * - Task 2.12: auto-citation tracking + dedup for answer mode
+ */
+const ATTRIBUTION_TTL_MS = 30 * 60 * 1000; // 30 minutes
+const MAX_CACHE_SIZE = 500;
+const SWEEP_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+/** Documents consulted in the current deploy cycle. Reset before each deploy attempt. */
+const consultedDocs = new Set();
+/** Attribution token cache: artifactId → {token, ts, deResourceName}. */
+const attributionCache = new Map();
+/** Per-session dedup for L1 auto-citation view-item events. */
+const citationDedupeSet = new Set();
+/** Deploy attempt counter for retry-aware feedback. */
+let deployAttempts = 0;
+// ─── Periodic sweep to prevent memory leak ───────────────────────────────────
+let sweepTimer;
+function startSweepTimer() {
+    if (sweepTimer)
+        return;
+    sweepTimer = setInterval(() => {
+        const now = Date.now();
+        for (const [id, entry] of attributionCache) {
+            if (now - entry.ts > ATTRIBUTION_TTL_MS)
+                attributionCache.delete(id);
+        }
+        // Evict oldest if over max size
+        if (attributionCache.size > MAX_CACHE_SIZE) {
+            const sorted = [...attributionCache.entries()].sort((a, b) => a[1].ts - b[1].ts);
+            const toRemove = sorted.slice(0, sorted.length - MAX_CACHE_SIZE);
+            for (const [id] of toRemove)
+                attributionCache.delete(id);
+        }
+    }, SWEEP_INTERVAL_MS);
+    // Don't prevent process exit
+    if (sweepTimer && typeof sweepTimer === "object" && "unref" in sweepTimer) {
+        sweepTimer.unref();
+    }
+}
+// ─── Public API ──────────────────────────────────────────────────────────────
+/**
+ * Record that documents were served in a search response.
+ * Call after each knowledge() search returns results.
+ */
+export function recordSearchResults(results, attributionToken) {
+    startSweepTimer();
+    const now = Date.now();
+    for (const r of results) {
+        if (!r.id)
+            continue;
+        consultedDocs.add(r.id);
+        attributionCache.set(r.id, {
+            token: attributionToken,
+            ts: now,
+            deResourceName: r.deResourceName,
+        });
+    }
+}
+/** Get the attribution token for a document (if cached and not expired). */
+export function getAttributionToken(docId) {
+    const entry = attributionCache.get(docId);
+    if (!entry)
+        return undefined;
+    if (Date.now() - entry.ts > ATTRIBUTION_TTL_MS) {
+        attributionCache.delete(docId);
+        return undefined;
+    }
+    return entry.token;
+}
+/** Get all documents consulted in the current deploy cycle. */
+export function getConsultedDocs() {
+    return consultedDocs;
+}
+/** Reset consultedDocs for a new deploy cycle. Call before each deploy attempt. */
+export function resetConsultedDocs() {
+    consultedDocs.clear();
+}
+/** Increment deploy attempts counter. Call at start of each deploy. */
+export function incrementDeployAttempts() {
+    deployAttempts++;
+}
+/** Get current deploy attempt count. */
+export function getDeployAttempts() {
+    return deployAttempts;
+}
+/** Check if a citation has already been tracked this session (for L1 dedup). */
+export function hasEmittedCitation(docId) {
+    return citationDedupeSet.has(docId);
+}
+/** Mark a citation as emitted this session. */
+export function markCitationEmitted(docId) {
+    citationDedupeSet.add(docId);
+}
+/** Reset all state (for test isolation). */
+export function _resetSessionState() {
+    consultedDocs.clear();
+    attributionCache.clear();
+    citationDedupeSet.clear();
+    deployAttempts = 0;
+    if (sweepTimer) {
+        clearInterval(sweepTimer);
+        sweepTimer = undefined;
+    }
+}

package/dist/mcp/handlers/workflow/deploy.js

@@ -26,8 +26,11 @@ import { validateWorkflowSchema, validateSearchDataSourceConsistency, validateNo
 hasKnowledgeSearchNodes, extractActionTypeName, } from "./validation.js";
 import { validateWorkflowOutputs } from "./validate-outputs.js";
 import { validateWorkflowDefStructure } from "../../domain/workflow-def-validator.js";
+import { incrementDeployAttempts } from "../knowledge/session-state.js";
+import { emitOutcomeFeedback } from "../knowledge/outcome-feedback.js";
 // Re-export for backwards compatibility with existing imports
 export { hasKnowledgeSearchNodes, extractActionTypeName };
+// Deploy outcome feedback — thin wrapper around the generalized outcome-feedback utility
 /**
  * Handle workflow deploy mode
  */
@@ -52,6 +55,8 @@ export async function handleWorkflowDeploy(args, client) {
     if (!workflowDef) {
         return { error: "workflow_def required for deploy mode" };
     }
+    // Track deploy attempts for retry-aware feedback
+    incrementDeployAttempts();
     const persona = await client.getPersonaById(personaId);
     if (!persona) {
         return { error: `Persona not found: ${personaId}` };
@@ -319,6 +324,11 @@ export async function handleWorkflowDeploy(args, client) {
         // ═══════════════════════════════════════════════════════════════════════════
         const response = updateResponse;
         if (response?.proto_config_updated === false) {
+            // Emit deploy failure feedback before returning
+            try {
+                await emitOutcomeFeedback({ tool: "workflow", operation: "deploy", success: false });
+            }
+            catch { /* best-effort */ }
             return {
                 mode: "deploy",
                 status: "failed",
@@ -403,10 +413,33 @@ export async function handleWorkflowDeploy(args, client) {
         catch {
             // Post-deploy check is best-effort
         }
+        // ═══════════════════════════════════════════════════════════════════════════
+        // DEPLOY-OUTCOME FEEDBACK: Boost confidence on consulted knowledge docs
+        // This closes the feedback loop — successful deploys improve DE ranking.
+        // ═══════════════════════════════════════════════════════════════════════════
+        try {
+            const feedback = await emitOutcomeFeedback({ tool: "workflow", operation: "deploy", success: "accepted" });
+            if (feedback.docs_processed > 0) {
+                result._knowledge_feedback = {
+                    outcome: "accepted",
+                    docs_consulted: feedback.docs_processed,
+                    confidence_updates: feedback.confidence_updates,
+                    _tip: "Deploy accepted by API. Test with conversation() to validate intent alignment — that produces stronger confidence signals.",
+                };
+            }
+        }
+        catch {
+            // Best-effort — never block deploy response
+        }
         return result;
     }
     catch (err) {
         const errorMessage = err instanceof Error ? err.message : String(err);
+        // Emit deploy failure feedback (best-effort, before building response)
+        try {
+            await emitOutcomeFeedback({ tool: "workflow", operation: "deploy", success: false });
+        }
+        catch { /* best-effort */ }
         // Preserve structured error information if available
         const errorResult = {
             mode: "deploy",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ema.co/mcp-toolkit",
-  "version": "2026.3.25-4",
+  "version": "2026.3.29-1",
   "description": "Ema AI Employee toolkit - MCP server, CLI, and SDK for managing AI Employees across environments",
   "type": "module",
   "main": "dist/index.js",