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

package/dist/auth/login.js

@@ -145,14 +145,14 @@ async function loginWithPasteToken(appUrl) {
     await new Promise((resolve) => {
         exec(cmd, () => resolve());
     });
-    console.log(`\nBrowser opened to: ${appUrl}`);
-    console.log("Log in normally, then grab your bearer token:\n");
-    console.log("  1. Open DevTools (F12 or Cmd+Opt+I)");
-    console.log("  2. Go to Network tab");
-    console.log("  3. Filter for 'generate_token_from_code'");
-    console.log("  4. Click the request → Response tab");
-    console.log("  5. Copy the access_token value (starts with eyJ...)\n");
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    console.error(`\nBrowser opened to: ${appUrl}`);
+    console.error("Log in normally, then grab your bearer token:\n");
+    console.error("  1. Open DevTools (F12 or Cmd+Opt+I)");
+    console.error("  2. Go to Network tab");
+    console.error("  3. Filter for 'generate_token_from_code'");
+    console.error("  4. Click the request → Response tab");
+    console.error("  5. Copy the access_token value (starts with eyJ...)\n");
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
     const token = await new Promise((resolve) => {
         rl.question("Paste bearer token here: ", (answer) => {
             rl.close();
@@ -205,8 +205,8 @@ export async function loginGoogleOAuth(opts = {}) {
             });
         });
         // Navigate to Cloud Console — triggers Google auth
-        console.log("Opening browser for Google authentication...");
-        console.log("Sign in with your Google account — the token will be captured automatically.\n");
+        console.error("Opening browser for Google authentication...");
+        console.error("Sign in with your Google account — the token will be captured automatically.\n");
         await page.goto("https://console.cloud.google.com/");
         const token = await tokenPromise;
         return token;
@@ -232,15 +232,15 @@ async function isPlaywrightAvailable() {
 // ─────────────────────────────────────────────────────────────────────────────
 async function promptTenantSelection(tenants) {
     const { createInterface } = await import("node:readline");
-    console.log(`\nMultiple tenants available:`);
+    console.error(`\nMultiple tenants available:`);
     for (let i = 0; i < tenants.length; i++) {
         const t = tenants[i];
         const marker = t.is_current ? " ← current" : "";
-        console.log(`  [${i + 1}] ${t.company_name} (${t.domain})${marker}`);
+        console.error(`  [${i + 1}] ${t.company_name} (${t.domain})${marker}`);
     }
     const defaultIdx = tenants.findIndex((t) => t.is_current);
     const defaultNum = defaultIdx >= 0 ? defaultIdx + 1 : 1;
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
     const answer = await new Promise((resolve) => {
         rl.question(`\nSelect tenant [${defaultNum}]: `, (ans) => {
             rl.close();
@@ -250,11 +250,11 @@ async function promptTenantSelection(tenants) {
     const choice = answer === "" ? defaultNum : parseInt(answer, 10);
     if (choice >= 1 && choice <= tenants.length) {
         const selected = tenants[choice - 1];
-        console.log(`Selected: ${selected.company_name}`);
+        console.error(`Selected: ${selected.company_name}`);
         return selected.tenant_id;
     }
     // Invalid input — use default
-    console.log(`Invalid choice, using default: ${tenants[defaultNum - 1].company_name}`);
+    console.error(`Invalid choice, using default: ${tenants[defaultNum - 1].company_name}`);
     return tenants[defaultNum - 1].tenant_id;
 }
 // ─────────────────────────────────────────────────────────────────────────────
@@ -281,22 +281,22 @@ export async function login(opts = {}) {
     else if (await isPlaywrightAvailable()) {
         // Primary: Playwright-controlled browser, with paste-token fallback on failure
         try {
-            console.log("Opening browser for login...");
-            console.log("Authenticate normally — the token will be captured automatically.\n");
+            console.error("Opening browser for login...");
+            console.error("Authenticate normally — the token will be captured automatically.\n");
             tokenResponse = await loginWithPlaywright(appUrl, apiUrl, timeoutMs);
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            console.log(`\nBrowser login failed: ${msg}`);
-            console.log("Falling back to manual token entry...\n");
+            console.error(`\nBrowser login failed: ${msg}`);
+            console.error("Falling back to manual token entry...\n");
             tokenResponse = await loginWithPasteToken(appUrl);
         }
     }
     else {
         // Fallback: system browser + paste URL
-        console.log("(Playwright not installed — using paste-URL fallback)\n");
-        console.log("For automatic login, install playwright-chromium:");
-        console.log("  npm install -g playwright-chromium\n");
+        console.error("(Playwright not installed — using paste-URL fallback)\n");
+        console.error("For automatic login, install playwright-chromium:");
+        console.error("  npm install -g playwright-chromium\n");
         tokenResponse = await loginWithPasteToken(appUrl);
     }
     const token = tokenResponse.access_token;
@@ -318,10 +318,10 @@ export async function login(opts = {}) {
             const match = accessibleTenants.find((t) => t.tenant_id === opts.tenantId);
             if (match) {
                 selectedTenantId = match.tenant_id;
-                console.log(`\nUsing tenant: ${match.company_name} (${match.domain})`);
+                console.error(`\nUsing tenant: ${match.company_name} (${match.domain})`);
             }
             else {
-                console.log(`\nWarning: tenant ${opts.tenantId} not in accessible list. Using default.`);
+                console.error(`\nWarning: tenant ${opts.tenantId} not in accessible list. Using default.`);
             }
         }
         else if (process.stdin.isTTY) {
@@ -330,10 +330,10 @@ export async function login(opts = {}) {
         }
         else {
             // Non-interactive: log what's available
-            console.log(`\nAccessible tenants (${accessibleTenants.length}):`);
+            console.error(`\nAccessible tenants (${accessibleTenants.length}):`);
             for (const t of accessibleTenants) {
                 const marker = t.is_current ? " ← active" : "";
-                console.log(`  ${t.company_name} (${t.domain})${marker}`);
+                console.error(`  ${t.company_name} (${t.domain})${marker}`);
             }
         }
     }

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/extractors/agent-catalog.js

@@ -1,15 +1,21 @@
 export async function extractAgentCatalog(config) {
     const { AGENT_CATALOG } = await import("../../sdk/generated/agent-catalog.js");
     const documents = AGENT_CATALOG.map((action) => {
-        const inputs = (action.inputs ?? []).map((i) => `${i.name}: ${i.type}`).join(", ");
-        const outputs = (action.outputs ?? []).map((o) => `${o.name}: ${o.type}`).join(", ");
+        const inputs = (action.inputs ?? []).map((i) => `${i.name} (${i.type})${i.description ? `: ${i.description}` : ""}`).join("; ");
+        const outputs = (action.outputs ?? []).map((o) => `${o.name} (${o.type})${o.description ? `: ${o.description}` : ""}`).join("; ");
+        const criticalRules = (action.criticalRules ?? []).map((r) => `- ${r}`).join("\n");
+        // Build prose content optimized for semantic search.
+        // Repeat the actionName in natural language so DE embeddings match queries like "call_llm".
         const content = [
-            action.displayName,
-            action.description,
-            action.whenToUse,
-            inputs ? `Inputs: ${inputs}` : "",
-            outputs ? `Outputs: ${outputs}` : "",
-            action.aliases?.length ? `Aliases: ${action.aliases.join(", ")}` : "",
+            `# ${action.actionName} — ${action.displayName}`,
+            "",
+            `The ${action.actionName} action (also known as "${action.displayName}") ${action.description?.toLowerCase() ?? ""}`,
+            action.whenToUse ? `\nUse ${action.actionName} when: ${action.whenToUse}` : "",
+            action.whenNotToUse ? `\nDo NOT use ${action.actionName} when: ${action.whenNotToUse}` : "",
+            inputs ? `\n## Inputs for ${action.actionName}\n${inputs}` : "",
+            outputs ? `\n## Outputs from ${action.actionName}\n${outputs}` : "",
+            criticalRules ? `\n## Critical rules for ${action.actionName}\n${criticalRules}` : "",
+            action.aliases?.length ? `\nAlso known as: ${action.aliases.join(", ")}` : "",
         ].filter(Boolean).join("\n");
         return {
             id: `entity:${action.actionName}`,

package/dist/knowledge/pipeline/confidence.js

@@ -53,7 +53,7 @@ export function computeConfidenceScore(provenance, feedbackDelta, boost) {
     const floor = Math.max(0, base - MAX_NEGATIVE_DRIFT);
     return Math.max(floor, Math.min(1.0, adjusted));
 }
-/** Per-event feedback deltas (used by runtime confidence-loop) */
+/** Per-event feedback deltas (used by runtime confidence-loop for backward compat) */
 export const FEEDBACK_DELTA_NEGATIVE = -0.08;
 export const FEEDBACK_DELTA_POSITIVE = 0.04;
 /** Maximum boost above provenance base from positive feedback */
@@ -62,6 +62,12 @@ export const MAX_POSITIVE_BOOST = 0.15;
 export const MAX_NEGATIVE_DRIFT = 0.30;
 /** Minimum score delta to trigger a DE update (avoids churn) */
 export const MIN_SCORE_DELTA = 0.05;
+/** Minimum unique clients required before score changes take effect */
+export const MIN_CORROBORATION_CLIENTS = 2;
+/** Evidence-based feedback gets stronger delta multiplier */
+export const EVIDENCE_MULTIPLIER = 1.5; // deploy failure = hard evidence
+/** Soft feedback gets weaker delta multiplier */
+export const SOFT_MULTIPLIER = 0.5; // "this seems wrong" without evidence
 /** Score thresholds for label assignment — single source of truth */
 export const LABEL_THRESHOLDS = {
     verified: 0.80, // >= 0.80
@@ -79,19 +85,134 @@ export function scoreToLabel(score) {
         return "inferred";
     return "low-confidence";
 }
+/**
+ * Compute confidence adjustment based on the ratio of negative to total feedback.
+ *
+ * Key principle: a doc with 500 positives and 5 negatives (1% negative) should NOT
+ * be downgraded — the 5 are likely confused agents, not a real problem.
+ *
+ * The ratio determines the direction. The total count determines the strength.
+ * Both matter: low ratio + high count = strong confidence. High ratio + low count = weak signal.
+ *
+ * @param negativeCount - Total negative feedback events
+ * @param positiveCount - Total positive feedback events
+ * @param uniqueClients - Number of distinct clients (for corroboration)
+ * @returns Confidence delta to apply (negative = downgrade, positive = upgrade)
+ */
+export function computeFeedbackDelta(negativeCount, positiveCount, uniqueClients = 1) {
+    const total = negativeCount + positiveCount;
+    if (total === 0)
+        return 0;
+    const negativeRatio = negativeCount / total;
+    // Confidence bands based on negative ratio
+    // High negative ratio = downgrade, low ratio = upgrade, middle = neutral
+    let baseDelta;
+    if (negativeRatio >= 0.80) {
+        // Overwhelmingly negative — strong downgrade
+        baseDelta = -0.15;
+    }
+    else if (negativeRatio >= 0.60) {
+        // Mostly negative — moderate downgrade
+        baseDelta = -0.10;
+    }
+    else if (negativeRatio >= 0.40) {
+        // Mixed signals — slight downgrade (benefit of doubt to negative)
+        baseDelta = -0.05;
+    }
+    else if (negativeRatio >= 0.20) {
+        // Mostly positive with some complaints — neutral/slight upgrade
+        baseDelta = 0.02;
+    }
+    else {
+        // Overwhelmingly positive — upgrade
+        baseDelta = 0.05;
+    }
+    // Volume amplifier — more total feedback = more confidence in the signal
+    // But with diminishing returns (log scale)
+    const volumeMultiplier = Math.min(2.0, 1.0 + Math.log2(Math.max(1, total)) * 0.15);
+    // Corroboration amplifier — multiple independent clients agreeing is stronger
+    const corroborationMultiplier = Math.min(1.5, 1.0 + Math.max(0, uniqueClients - 1) * 0.1);
+    return baseDelta * volumeMultiplier * corroborationMultiplier;
+}
+/**
+ * Compute effective floor — allows breakthrough under sustained, high-ratio negative feedback.
+ *
+ * The base floor (provenance - MAX_NEGATIVE_DRIFT) protects against noise.
+ * The floor only gives way when: high negative ratio AND sufficient volume.
+ * This prevents a single bad feedback from breaking the floor.
+ */
+export function effectiveFloor(provenanceBase, negativeRatio, totalCount) {
+    const baseFloor = Math.max(0, provenanceBase - MAX_NEGATIVE_DRIFT);
+    // Floor only gives way when: high negative ratio AND sufficient volume
+    if (negativeRatio < 0.70 || totalCount < 5)
+        return baseFloor;
+    // Beyond threshold: floor lowers proportionally to how negative the ratio is
+    const floorReduction = (negativeRatio - 0.70) * totalCount * 0.01;
+    return Math.max(0.10, baseFloor - floorReduction);
+}
+// ── Legacy graduated functions (kept for backward compat imports) ────────────
+/** @deprecated Use computeFeedbackDelta instead */
+export function graduatedNegativeDelta(negativeCount) {
+    if (negativeCount >= 8)
+        return -0.14;
+    if (negativeCount >= 5)
+        return -0.12;
+    if (negativeCount >= 3)
+        return -0.08;
+    if (negativeCount >= 2)
+        return -0.06;
+    return -0.04;
+}
+/** @deprecated Use computeFeedbackDelta instead */
+export function graduatedPositiveDelta(positiveCount) {
+    if (positiveCount >= 5)
+        return 0.06;
+    if (positiveCount >= 3)
+        return 0.04;
+    return 0.03;
+}
 /**
  * Compute a per-event feedback delta and apply to current score.
  * Used by the runtime confidence loop when a single feedback event arrives.
  *
- * @returns { newScore, label } — clamped to [0, provenanceBase + MAX_POSITIVE_BOOST]
+ * When feedbackHistory is provided, uses graduated deltas that accelerate
+ * with corroboration. Without feedbackHistory, uses flat deltas for
+ * backward compatibility.
+ *
+ * @returns { newScore, label } — clamped to [floor, provenanceBase + MAX_POSITIVE_BOOST]
  */
-export function applyFeedbackDelta(currentScore, provenance, isNegative) {
-    const delta = isNegative ? FEEDBACK_DELTA_NEGATIVE : FEEDBACK_DELTA_POSITIVE;
+export function applyFeedbackDelta(currentScore, provenance, isNegative, feedbackHistory) {
     const provenanceBase = PROVENANCE_BASE_SCORES[provenance] ?? PROVENANCE_BASE_SCORES["inferred"];
     const maxScore = provenanceBase + MAX_POSITIVE_BOOST;
-    const minScore = Math.max(0, provenanceBase - MAX_NEGATIVE_DRIFT);
-    const newScore = Math.max(minScore, Math.min(maxScore, currentScore + delta));
-    return { newScore, label: scoreToLabel(newScore) };
+    let delta;
+    let minScore;
+    if (feedbackHistory) {
+        // Ratio-based model — direction from ratio, strength from volume
+        const { negativeCount, positiveCount, uniqueClients } = feedbackHistory;
+        // Add the current event to history for calculation
+        const adjNeg = isNegative ? negativeCount + 1 : negativeCount;
+        const adjPos = isNegative ? positiveCount : positiveCount + 1;
+        const total = adjNeg + adjPos;
+        const negRatio = total > 0 ? adjNeg / total : 0;
+        delta = computeFeedbackDelta(adjNeg, adjPos, uniqueClients);
+        // Apply delta relative to provenance base, not current score
+        const targetScore = provenanceBase + delta;
+        // Move current score toward target (don't jump, converge)
+        const moveRate = 0.3; // converge 30% toward target per event
+        const newScore = currentScore + (targetScore - currentScore) * moveRate;
+        minScore = effectiveFloor(provenanceBase, negRatio, total);
+        return {
+            newScore: Math.max(minScore, Math.min(maxScore, newScore)),
+            label: scoreToLabel(Math.max(minScore, Math.min(maxScore, newScore))),
+        };
+    }
+    else {
+        // Legacy flat model for backward compatibility
+        delta = isNegative ? FEEDBACK_DELTA_NEGATIVE : FEEDBACK_DELTA_POSITIVE;
+        minScore = Math.max(0, provenanceBase - MAX_NEGATIVE_DRIFT);
+        const newScore = Math.max(minScore, Math.min(maxScore, currentScore + delta));
+        return { newScore, label: scoreToLabel(newScore) };
+    }
 }
 /**
  * Feedback signal classification — single source of truth.
@@ -281,25 +402,16 @@ function buildReport(source, totalEntries, correlated, signalMap) {
     const signals = [];
     const lowConfidence = [];
     for (const [docId, signal] of signalMap) {
-        const netNegative = signal.negative - signal.positive;
-        let delta;
-        // Stepped delta tiers based on aggregate feedback count
-        if (netNegative >= 5) {
-            delta = -0.40;
-        }
-        else if (netNegative >= 3) {
-            delta = -0.25;
-        }
-        else if (netNegative >= 1) {
-            delta = -0.10;
-        }
-        else {
-            delta = 0;
-        }
-        // Estimate label from score using "curated" as a conservative baseline.
+        // Ratio-based delta — direction from ratio, strength from volume
+        const total = signal.negative + signal.positive;
+        const negRatio = total > 0 ? signal.negative / total : 0;
+        const delta = computeFeedbackDelta(signal.negative, signal.positive);
+        // Estimate label using "curated" baseline + adaptive floor.
         // This is advisory — applyConfidenceSignals() recomputes with actual provenance.
-        // For low-provenance docs (raw-document, inferred), the real label may differ.
-        const estimatedScore = computeConfidenceScore("curated", delta);
+        const provenanceBase = PROVENANCE_BASE_SCORES["curated"];
+        const maxScore = provenanceBase + MAX_POSITIVE_BOOST;
+        const minScore = effectiveFloor(provenanceBase, negRatio, total);
+        const estimatedScore = Math.max(minScore, Math.min(maxScore, provenanceBase + delta));
         const label = scoreToLabel(estimatedScore);
         if (label === "low-confidence") {
             lowConfidence.push(docId);

package/dist/knowledge/search-client.js

@@ -478,9 +478,22 @@ async function searchDirect(query, options) {
     // Dynamic domain boost — if query signals a specific platform, boost its domain
     // and demote the other. DE serves both platforms; this keeps results focused.
     const queryBoost = buildQueryBoostSpec(query, filters);
-    if (queryBoost) {
-        body.boostSpec = queryBoost;
-    }
+    // Confidence boost — always applied. Verified docs rank higher, low-confidence lower.
+    // This makes the feedback loop visible at search time: downgraded docs get demoted
+    // regardless of relevance. DE boost values are additive to relevance score.
+    // Values calibrated against signal viewer: semantic relevance spreads 0.07-0.99,
+    // so boosts must be large enough to move docs across that range.
+    const confidenceBoosts = [
+        { condition: 'confidence: ANY("verified")', boost: 0.5 },
+        { condition: 'confidence: ANY("inferred")', boost: -0.2 },
+        { condition: 'confidence: ANY("low-confidence")', boost: -0.8 },
+    ];
+    const querySpecs = (queryBoost?.conditionBoostSpecs ?? []);
+    const allBoosts = [
+        ...querySpecs,
+        ...confidenceBoosts,
+    ];
+    body.boostSpec = { conditionBoostSpecs: allBoosts };
     // Always request snippets — works with chunked datastores.
     // (Extractive answers do NOT work with chunking, only snippets.)
     // For answer mode, also request summary with citations.
@@ -640,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;
@@ -648,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/domain/workflow-def-schema.js

@@ -35,7 +35,7 @@ export const WORKFLOW_DEF_SCHEMA = {
                         namespaces: {
                             type: "array",
                             items: { type: "string" },
-                            description: "Namespace path (e.g., ['ema', 'personas', '<id>'])",
+                            description: "Namespace path — MUST be copied exactly from workflow(mode='get') response. Do NOT construct manually.",
                         },
                         name: {
                             type: "string",

package/dist/mcp/domain/workflow-def-validator.js

@@ -149,8 +149,8 @@ function validateEnumTypes(wf, issues) {
             }
             enumNames.add(name.name);
         }
-        // Validate options array
-        const options = et.options;
+        // Validate options/values array — proto uses "options", compiled proto uses "values"
+        const options = (et.options ?? et.values);
         if (!Array.isArray(options) || options.length === 0) {
             issues.push({
                 path: `${prefix}.options`,

package/dist/mcp/guidance/classify.js

@@ -40,16 +40,17 @@ export function classifyResult(result, unfilteredCount) {
             return "error_500";
         return "error";
     }
-    // Success shapes
+    // Success shapes — order matters: check deploy before created,
+    // because deploy results also carry persona_id but aren't "created".
+    if (result.deployed === true || result.workflow_deployed === true || (result.mode === "deploy" && status === "deployed")) {
+        return "deployed";
+    }
     if (result.success === true || result.persona_id) {
         // Created entity
         if (result.persona_id && !result.workflow_def) {
             return "created";
         }
     }
-    if (result.deployed === true || (result.mode === "deploy" && !error)) {
-        return "deployed";
-    }
     // List shapes — check count
     const count = typeof result.count === "number" ? result.count : undefined;
     if (count !== undefined) {

package/dist/mcp/guidance/defaults.js

@@ -30,7 +30,8 @@ export function getDefaultGuidance(shape, ctx) {
             };
         case "deployed":
             return {
-                _next_step: "Verify: workflow(mode='get', persona_id='{persona_id}') — confirm workflow is active.",
+                _next_step: "Test your deployed workflow: conversation(method='create', persona_id='{persona_id}') for chat, or upload documents via persona(id='{persona_id}', data={method:'upload', path:'/path/to/doc.pdf'}) for dashboard.",
+                _tip: "Deployed successfully. The workflow is now active.",
             };
         case "deploy_failed":
             return {

package/dist/mcp/guidance.js

@@ -119,6 +119,7 @@ function generateDecisionFlow(tools) {
 2. \`knowledge("workflow patterns for <your use case>")\` → learn the correct workflow pattern
 3. \`${createPersona}\` → creates persona
 4. \`${getWorkflow}\` → get starter workflow + generation schema (FULL input/output specs from API) + fingerprint
+   Use \`compact=true\` for a smaller response (workflowName + fingerprint + workflow_def only, no schema).
 5. Build a complete workflow_def using the generation schema — it shows ALL required inputs per action
 6. Upload data sources if needed — \`persona(id="<new_id>", data={method:"upload", path:"/path/to/doc.pdf"})\`
 7. \`workflow(mode="validate", persona_id="...", workflow_def={...})\` → catch errors BEFORE deploying
@@ -131,7 +132,7 @@ function generateDecisionFlow(tools) {
         const get = opExample("workflow", "Get");
         const deploy = opExample("workflow", "Deploy");
         sections.push(`**Modifying an existing AI Employee's workflow?**
-1. \`${get}\` → get current workflow_def + schema + fingerprint
+1. \`${get}\` → get current workflow_def + schema + fingerprint (use \`compact=true\` for smaller response)
 2. LLM modifies the workflow_def JSON (use the returned workflow_def as format reference)
 3. \`workflow(mode="validate", persona_id="...", workflow_def={...})\` → catch errors before deploying
 4. \`${deploy}\``);

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: {