@indexnetwork/protocol 14.3.2-rc.477.1 → 16.1.1-rc.478.1

package/dist/intents/application/intent.graph.reconcile.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Intent graph, stages 2-3: verify inferred signals, then reconcile against what exists.
+ */
+import { VerifiedIntent, type IntentValidationFailure } from "../domain/intent.state.js";
+import type { NormalizedIntentAction } from "./intent.reconciler.js";
+import type { DebugMetaAgent } from "../../agents/index.js";
+import { type IntentGraphDeps, type IntentState } from "./intent.graph.shared.js";
+/**
+ * Node 2: Verification (Map-Reduce / Parallel)
+ * Verifies each inferred intent in parallel.
+ * Phase 4: Can be skipped for delete operations and updates with no new intents.
+ */
+export declare function verificationNode(state: IntentState, deps: IntentGraphDeps): Promise<{
+    verifiedIntents: never[];
+    agentTimings: never[];
+    validationFailures?: undefined;
+    trace?: undefined;
+} | {
+    verifiedIntents: VerifiedIntent[];
+    validationFailures: IntentValidationFailure[];
+    agentTimings: DebugMetaAgent[];
+    trace: {
+        node: string;
+        detail: string;
+        data: {
+            clarity: number;
+            authority: number;
+            sincerity: number;
+            entropy: number | undefined;
+            referentialBreadth: "narrow" | "moderate" | "broad" | undefined;
+            missingSelectionalConstraints: ("location" | "role" | "outcome" | "timeframe" | "domain" | "concrete_need")[] | undefined;
+            specificityWarning: string | undefined;
+            classification: "COMMISSIVE" | "DIRECTIVE" | "ASSERTIVE" | "EXPRESSIVE" | "DECLARATION" | "UNKNOWN" | undefined;
+            score: number | undefined;
+        } | undefined;
+    }[];
+}>;
+/**
+ * Node 3: Reconciliation
+ * Decides on final actions (Create, Update, Expire).
+ * Phase 4: Handles delete operations directly without LLM reconciliation.
+ */
+export declare function reconciliationNode(state: IntentState, deps: IntentGraphDeps): Promise<{
+    actions: {
+        type: "expire";
+        id: string;
+        reasoning: string;
+    }[];
+    agentTimings: DebugMetaAgent[];
+    trace: {
+        node: string;
+        detail: string;
+    }[];
+    validationFailures?: undefined;
+} | {
+    actions: NormalizedIntentAction[];
+    validationFailures: IntentValidationFailure[];
+    agentTimings: DebugMetaAgent[];
+    trace: {
+        node: string;
+        detail: string;
+    }[];
+} | {
+    actions: NormalizedIntentAction[];
+    agentTimings: DebugMetaAgent[];
+    trace: {
+        node: string;
+        detail: string;
+    }[];
+    validationFailures?: undefined;
+}>;

package/dist/intents/application/intent.graph.reconcile.js

@@ -0,0 +1,274 @@
+/**
+ * Intent graph, stages 2-3: verify inferred signals, then reconcile against what exists.
+ */
+import { timed } from "../../shared/observability/performance.js";
+import { requestContext } from "../../shared/observability/request-context.js";
+import { buildExplicitUpdateActions, enforceIntentActionBoundary, enrichVagueIntentWithContext, getSpecificityWarning, isVague, logger } from "./intent.graph.shared.js";
+/**
+ * Node 2: Verification (Map-Reduce / Parallel)
+ * Verifies each inferred intent in parallel.
+ * Phase 4: Can be skipped for delete operations and updates with no new intents.
+ */
+export async function verificationNode(state, deps) {
+    return timed("IntentGraph.verification", async () => {
+        const intents = state.inferredIntents;
+        logger.verbose("Starting verification", {
+            operationMode: state.operationMode,
+            intentCount: intents.length
+        });
+        if (intents.length === 0) {
+            logger.verbose("No intents to verify");
+            return { verifiedIntents: [], agentTimings: [] };
+        }
+        logger.verbose('Verifying intents in parallel', { count: intents.length });
+        const agentTimingsAccum = [];
+        // Parallel Execution
+        const verificationResults = await Promise.all(intents.map(async (intent) => {
+            try {
+                let description = intent.description;
+                const _traceEmitterVerifier = requestContext.getStore()?.traceEmitter;
+                const verifierStart1 = Date.now();
+                _traceEmitterVerifier?.({ type: "agent_start", name: "intent-verifier" });
+                let verdict = await deps.verifier.invoke(description, state.userProfile);
+                agentTimingsAccum.push({ name: 'intent.verifier', durationMs: Date.now() - verifierStart1 });
+                _traceEmitterVerifier?.({ type: "agent_end", name: "intent-verifier", durationMs: Date.now() - verifierStart1, summary: `Verified: ${verdict.classification}` });
+                if (isVague(description, verdict.semantic_entropy, verdict.felicity_scores.clarity)) {
+                    // Role-hint enrichment for vague job intents reads the global
+                    // user_context paragraph instead of the structured profile fields.
+                    const roleHintContext = (await deps.database.getUserContext(state.userId, null))?.text ?? '';
+                    const enrichedDescription = enrichVagueIntentWithContext(description, roleHintContext);
+                    if (enrichedDescription !== description) {
+                        logger.verbose("Enriched vague intent using profile context", {
+                            before: description,
+                            after: enrichedDescription,
+                        });
+                        const _traceEmitterVerifier2 = requestContext.getStore()?.traceEmitter;
+                        const verifierStart2 = Date.now();
+                        _traceEmitterVerifier2?.({ type: "agent_start", name: "intent-verifier" });
+                        const enrichedVerdict = await deps.verifier.invoke(enrichedDescription, state.userProfile);
+                        agentTimingsAccum.push({ name: 'intent.verifier', durationMs: Date.now() - verifierStart2 });
+                        _traceEmitterVerifier2?.({ type: "agent_end", name: "intent-verifier", durationMs: Date.now() - verifierStart2, summary: `Verified (enriched): ${enrichedVerdict.classification}` });
+                        const becameClear = enrichedVerdict.semantic_entropy < verdict.semantic_entropy ||
+                            enrichedVerdict.felicity_scores.clarity > verdict.felicity_scores.clarity;
+                        if (becameClear) {
+                            description = enrichedDescription;
+                            verdict = enrichedVerdict;
+                        }
+                    }
+                }
+                // Filter Logic: Must be a Commissive, Directive, or Declaration
+                const VALID_TYPES = ['COMMISSIVE', 'DIRECTIVE', 'DECLARATION'];
+                if (!VALID_TYPES.includes(verdict.classification)) {
+                    logger.warn('Dropping intent', { description, classification: verdict.classification });
+                    return {
+                        failure: {
+                            category: 'non_actionable',
+                            classification: verdict.classification,
+                            referentialBreadth: verdict.referential_breadth,
+                            message: `Description was classified as ${verdict.classification}, not an actionable goal.`,
+                        },
+                    };
+                }
+                if (isVague(description, verdict.semantic_entropy, verdict.felicity_scores.clarity)) {
+                    logger.warn('Dropping vague intent after verification', {
+                        description,
+                        entropy: verdict.semantic_entropy,
+                        clarity: verdict.felicity_scores.clarity,
+                    });
+                    return {
+                        failure: {
+                            category: 'vague_or_invalid',
+                            classification: verdict.classification,
+                            referentialBreadth: verdict.referential_breadth,
+                            message: 'Description failed clarity or semantic-entropy requirements.',
+                        },
+                    };
+                }
+                if (state.operationMode === 'create' && verdict.referential_breadth === 'broad') {
+                    logger.warn('Dropping broad attributive intent before persistence', {
+                        description,
+                        referentialBreadth: verdict.referential_breadth,
+                        missingSelectionalConstraints: verdict.missing_selectional_constraints,
+                        warning: getSpecificityWarning(verdict),
+                    });
+                    return {
+                        failure: {
+                            category: 'vague_or_invalid',
+                            classification: verdict.classification,
+                            referentialBreadth: verdict.referential_breadth,
+                            message: getSpecificityWarning(verdict),
+                        },
+                    };
+                }
+                // Calculate Score
+                const score = Math.min(verdict.felicity_scores.authority, verdict.felicity_scores.sincerity, verdict.felicity_scores.clarity);
+                // Return enriched intent
+                return {
+                    intent: {
+                        ...intent,
+                        description,
+                        verification: verdict,
+                        score,
+                    },
+                };
+            }
+            catch (e) {
+                logger.error('Error verifying intent', { description: intent.description, error: e });
+                return {
+                    failure: {
+                        category: 'verification_failure',
+                        message: e instanceof Error ? e.message : 'Intent verification failed unexpectedly.',
+                    },
+                };
+            }
+        }));
+        const verified = verificationResults.flatMap((result) => 'intent' in result ? [result.intent] : []);
+        const validationFailures = verificationResults.flatMap((result) => 'failure' in result ? [result.failure] : []);
+        logger.verbose(`Verification complete`, {
+            passed: verified.length,
+            total: intents.length,
+            operationMode: state.operationMode
+        });
+        // Build trace entries with Felicity scores for each verified intent
+        const traceEntries = verified.map(v => {
+            const fs = v.verification?.felicity_scores;
+            const entropy = v.verification?.semantic_entropy;
+            const classification = v.verification?.classification;
+            const referentialBreadth = v.verification?.referential_breadth;
+            return {
+                node: "verification",
+                detail: `"${v.description.slice(0, 40)}${v.description.length > 40 ? '...' : ''}" → ${classification}${referentialBreadth ? ` (${referentialBreadth} referential breadth)` : ''}`,
+                data: fs ? {
+                    clarity: fs.clarity,
+                    authority: fs.authority,
+                    sincerity: fs.sincerity,
+                    entropy: entropy != null ? Math.round(entropy * 100) / 100 : undefined,
+                    referentialBreadth,
+                    missingSelectionalConstraints: v.verification?.missing_selectional_constraints,
+                    specificityWarning: v.verification?.specificity_warning ?? undefined,
+                    classification,
+                    score: v.score,
+                } : undefined,
+            };
+        });
+        // Add summary trace if some intents were filtered out
+        const dropped = intents.length - verified.length;
+        if (dropped > 0) {
+            traceEntries.unshift({
+                node: "verification",
+                detail: `Verified ${verified.length}/${intents.length} (${dropped} filtered as invalid)`,
+                data: undefined,
+            });
+        }
+        else if (verified.length > 0) {
+            traceEntries.unshift({
+                node: "verification",
+                detail: `Verified ${verified.length} intent(s)`,
+                data: undefined,
+            });
+        }
+        return { verifiedIntents: verified, validationFailures, agentTimings: agentTimingsAccum, trace: traceEntries };
+    });
+}
+/**
+ * Node 3: Reconciliation
+ * Decides on final actions (Create, Update, Expire).
+ * Phase 4: Handles delete operations directly without LLM reconciliation.
+ */
+export async function reconciliationNode(state, deps) {
+    return timed("IntentGraph.reconciliation", async () => {
+        logger.verbose("Starting reconciliation", {
+            operationMode: state.operationMode,
+            verifiedIntentCount: state.verifiedIntents.length,
+            targetIntentIds: state.targetIntentIds
+        });
+        const agentTimingsAccum = [];
+        // Phase 4: Handle delete operations directly
+        if (state.operationMode === 'delete') {
+            if (!state.targetIntentIds || state.targetIntentIds.length === 0) {
+                logger.warn("Delete mode with no target IDs");
+                return {
+                    actions: [],
+                    agentTimings: agentTimingsAccum,
+                    trace: [{ node: "reconciler", detail: "Delete mode with no target IDs" }],
+                };
+            }
+            logger.verbose("Delete mode - generating expire actions", {
+                targetIds: state.targetIntentIds
+            });
+            const actions = state.targetIntentIds.map(id => ({
+                type: 'expire',
+                id,
+                reasoning: 'User requested deletion'
+            }));
+            return {
+                actions,
+                agentTimings: agentTimingsAccum,
+                trace: [{
+                        node: "reconciler",
+                        detail: `Actions: expire=${actions.length}`,
+                    }],
+            };
+        }
+        // Standard reconciliation for create/update operations
+        const candidates = state.verifiedIntents;
+        if (candidates.length === 0) {
+            logger.verbose("No verified intents to reconcile");
+            return {
+                actions: [],
+                agentTimings: agentTimingsAccum,
+                trace: [{ node: "reconciler", detail: "No intents to reconcile" }],
+            };
+        }
+        if (state.operationMode === 'update') {
+            const explicitUpdate = buildExplicitUpdateActions(state.targetIntentIds, state.activeIntentIds, candidates);
+            return {
+                actions: explicitUpdate.actions,
+                validationFailures: explicitUpdate.failure
+                    ? [...state.validationFailures, explicitUpdate.failure]
+                    : state.validationFailures,
+                agentTimings: agentTimingsAccum,
+                trace: [{
+                        node: 'reconciler',
+                        detail: explicitUpdate.failure
+                            ? `Explicit update rejected: ${explicitUpdate.failure.category}`
+                            : `Explicit update bound to target ${state.targetIntentIds?.[0]}`,
+                    }],
+            };
+        }
+        // Format candidates for the Reconciler Prompt
+        const formattedCandidates = candidates.map(c => `- [${c.type.toUpperCase()}] "${c.description}" (Confidence: ${c.confidence}, Score: ${c.score})\n` +
+            `  Reasoning: ${c.reasoning}\n` +
+            `  Verification: ${c.verification?.classification} (Flags: ${c.verification?.flags.join(', ') || 'None'})`).join('\n');
+        logger.verbose("Invoking reconciler agent", {
+            candidateCount: candidates.length,
+            operationMode: state.operationMode
+        });
+        const _traceEmitterReconciler = requestContext.getStore()?.traceEmitter;
+        const reconcilerStart = Date.now();
+        _traceEmitterReconciler?.({ type: "agent_start", name: "intent-reconciler" });
+        const result = await deps.reconciler.invoke(formattedCandidates, state.activeIntents);
+        agentTimingsAccum.push({ name: 'intent.reconciler', durationMs: Date.now() - reconcilerStart });
+        _traceEmitterReconciler?.({ type: "agent_end", name: "intent-reconciler", durationMs: Date.now() - reconcilerStart, summary: `Reconciled ${result.actions.length} action(s)` });
+        const actions = enforceIntentActionBoundary(state.operationMode, state.targetIntentIds, result.actions);
+        logger.verbose("Reconciliation complete", {
+            actionCount: actions.length,
+            droppedActionCount: result.actions.length - actions.length,
+            operationMode: state.operationMode
+        });
+        // Count actions by type after enforcing the operation boundary.
+        const counts = { create: 0, update: 0, expire: 0 };
+        for (const a of actions) {
+            if (a.type in counts)
+                counts[a.type]++;
+        }
+        return {
+            actions,
+            agentTimings: agentTimingsAccum,
+            trace: [{
+                    node: "reconciler",
+                    detail: `Actions: create=${counts.create}, update=${counts.update}, expire=${counts.expire}`,
+                }],
+        };
+    });
+}

package/dist/intents/application/intent.graph.shared.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Shared vocabulary for the intent graph's nodes.
+ *
+ * The nodes were closures inside `IntentGraphFactory.createGraph()`; they are
+ * top-level functions now, each taking an explicit {@link IntentGraphDeps}.
+ * This module owns the bag, the logger, and the pure helpers.
+ */
+import { IntentGraphState, VerifiedIntent, type IntentValidationFailure } from "../domain/intent.state.js";
+import { ExplicitIntentInferrer } from "./intent.inferrer.js";
+import { SemanticVerifier } from "./intent.verifier.js";
+import { IntentReconciler } from "./intent.reconciler.js";
+import type { NormalizedIntentAction } from "./intent.reconciler.js";
+import { IntentGraphDatabase } from "../../shared/interfaces/database.interface.js";
+import type { EmbeddingGenerator } from "../../shared/interfaces/embedder.interface.js";
+import type { IntentGraphQueue } from "../../shared/interfaces/queue.interface.js";
+import type { QuestionerEnqueueFn } from "../../questions/index.js";
+/** The graph's channel state, as every node sees it. */
+export type IntentState = typeof IntentGraphState.State;
+/** Everything the intent nodes reach for. Composed once by the factory. */
+export interface IntentGraphDeps {
+    database: IntentGraphDatabase;
+    embedder?: EmbeddingGenerator;
+    intentQueue?: IntentGraphQueue;
+    questionerEnqueue?: QuestionerEnqueueFn;
+    inferrer: Pick<ExplicitIntentInferrer, 'invoke'>;
+    verifier: Pick<SemanticVerifier, 'invoke'>;
+    reconciler: Pick<IntentReconciler, 'invoke'>;
+}
+export declare const logger: import("../../shared/observability/log.js").LoggerWithSource;
+/**
+ * Enforce write-mode constraints on reconciler output before any action can
+ * reach persistence. Update mode is deliberately fail-closed: only updates
+ * whose id is one of the caller-provided targets survive.
+ */
+export declare function enforceIntentActionBoundary(operationMode: 'create' | 'update' | 'delete' | 'read' | 'propose', targetIntentIds: string[] | undefined, actions: NormalizedIntentAction[]): NormalizedIntentAction[];
+/**
+ * Build the only action permitted for an explicit update. This path is
+ * intentionally deterministic: semantic reconciliation may shape create
+ * operations, but it may not redirect an update away from its supplied target.
+ */
+export declare function buildExplicitUpdateActions(targetIntentIds: string[] | undefined, activeIntentIds: string[], candidates: VerifiedIntent[]): {
+    actions: NormalizedIntentAction[];
+    failure?: IntentValidationFailure;
+};
+export declare const MAX_PERMISSIBLE_ENTROPY = 0.75;
+export declare const MIN_CLEAR_INTENT_SCORE = 40;
+export declare const GENERIC_JOB_PHRASE: RegExp;
+export declare const inferRoleFromContextText: (text: string) => string | null;
+/**
+ * Derive a job-role qualifier from the user's global user_context paragraph
+ * (the identity text that replaced the legacy profile projection). Role is
+ * inferred from the free text; the old structured skills/interests extraction
+ * is gone with the removed profile fields.
+ */
+export declare const buildJobQualifierFromContext: (contextText: string) => string | null;
+export declare const enrichVagueIntentWithContext: (description: string, userContext: string) => string;
+export declare const isVague: (description: string, entropy: number, clarity: number) => boolean;
+export declare const getSpecificityWarning: (verdict: {
+    specificity_warning?: string | null;
+}) => string;
+export declare const toSpeechActType: (classification?: string) => "COMMISSIVE" | "DIRECTIVE" | null;
+/**
+ * Factory class to build and compile the Intent Processing Graph.
+
+/**
+ * Generate a flat embedding for an intent payload, swallowing failures so
+ * persistence can continue without an embedding. `intentId` is logging-only
+ * (present for updates, absent for creates).
+ */
+export declare function generateIntentEmbedding(deps: IntentGraphDeps, sanitizedPayload: string, intentId?: string): Promise<number[] | undefined>;

package/dist/intents/application/intent.graph.shared.js

@@ -0,0 +1,153 @@
+/**
+ * Shared vocabulary for the intent graph's nodes.
+ *
+ * The nodes were closures inside `IntentGraphFactory.createGraph()`; they are
+ * top-level functions now, each taking an explicit {@link IntentGraphDeps}.
+ * This module owns the bag, the logger, and the pure helpers.
+ */
+import { DEFAULT_SPECIFICITY_WARNING } from "../domain/signal.specificity.js";
+import { getAbortSignalConfig } from "../../shared/agent/model-signal.js";
+import { protocolLogger } from "../../shared/observability/protocol.logger.js";
+export const logger = protocolLogger("IntentGraphFactory");
+/**
+ * Enforce write-mode constraints on reconciler output before any action can
+ * reach persistence. Update mode is deliberately fail-closed: only updates
+ * whose id is one of the caller-provided targets survive.
+ */
+export function enforceIntentActionBoundary(operationMode, targetIntentIds, actions) {
+    if (operationMode !== 'update')
+        return actions;
+    const targets = new Set(targetIntentIds ?? []);
+    return actions.filter((action) => action.type === 'update' && targets.has(action.id));
+}
+/**
+ * Build the only action permitted for an explicit update. This path is
+ * intentionally deterministic: semantic reconciliation may shape create
+ * operations, but it may not redirect an update away from its supplied target.
+ */
+export function buildExplicitUpdateActions(targetIntentIds, activeIntentIds, candidates) {
+    if (targetIntentIds?.length !== 1 || !activeIntentIds.includes(targetIntentIds[0])) {
+        return {
+            actions: [],
+            failure: {
+                category: 'update_target_boundary',
+                message: 'Explicit update requires exactly one active intent owned by the caller.',
+            },
+        };
+    }
+    if (candidates.length !== 1) {
+        return {
+            actions: [],
+            failure: {
+                category: 'reconciliation_boundary',
+                message: 'Explicit update must resolve to exactly one verified intent.',
+            },
+        };
+    }
+    const candidate = candidates[0];
+    return {
+        actions: [{
+                type: 'update',
+                id: targetIntentIds[0],
+                payload: candidate.description,
+                score: candidate.score ?? null,
+                reasoning: candidate.reasoning ?? 'Explicit user-confirmed update',
+                intentMode: candidate.verification?.referential_anchor ? 'REFERENTIAL' : 'ATTRIBUTIVE',
+            }],
+    };
+}
+export const MAX_PERMISSIBLE_ENTROPY = 0.75;
+export const MIN_CLEAR_INTENT_SCORE = 40;
+export const GENERIC_JOB_PHRASE = /\b(?:a|any|some)\s+job\b/i;
+export const inferRoleFromContextText = (text) => {
+    const normalized = text.toLowerCase();
+    if (/\b(engineer|developer)\b/.test(normalized))
+        return "software engineering";
+    if (/\b(designer|ux|ui)\b/.test(normalized))
+        return "product design";
+    if (/\b(marketing|marketer|growth)\b/.test(normalized))
+        return "marketing";
+    if (/\b(product manager|product)\b/.test(normalized))
+        return "product management";
+    if (/\b(data scientist|machine learning|ml|ai)\b/.test(normalized))
+        return "AI/ML";
+    if (/\b(sales|account executive|business development)\b/.test(normalized))
+        return "sales";
+    return null;
+};
+/**
+ * Derive a job-role qualifier from the user's global user_context paragraph
+ * (the identity text that replaced the legacy profile projection). Role is
+ * inferred from the free text; the old structured skills/interests extraction
+ * is gone with the removed profile fields.
+ */
+export const buildJobQualifierFromContext = (contextText) => {
+    const roleHint = inferRoleFromContextText(contextText ?? "");
+    return roleHint ? `${roleHint} role` : null;
+};
+export const enrichVagueIntentWithContext = (description, userContext) => {
+    const trimmed = description?.trim();
+    if (!trimmed)
+        return description;
+    const isGenericJobRequest = GENERIC_JOB_PHRASE.test(trimmed) ||
+        /\b(?:find|get|look(?:ing)?\s+for|want)\s+(?:to\s+)?(?:find\s+)?job\b/i.test(trimmed);
+    if (!isGenericJobRequest)
+        return description;
+    const qualifier = buildJobQualifierFromContext(userContext);
+    if (!qualifier)
+        return description;
+    const enriched = trimmed
+        .replace(/\ba job\b/i, `a ${qualifier}`)
+        .replace(/\bjob\b/i, `${qualifier}`)
+        .replace(/\s{2,}/g, " ")
+        .trim();
+    return enriched.length > 0 ? enriched : description;
+};
+export const isVague = (description, entropy, clarity) => {
+    if (GENERIC_JOB_PHRASE.test(description))
+        return true;
+    if (entropy > MAX_PERMISSIBLE_ENTROPY)
+        return true;
+    if (clarity < MIN_CLEAR_INTENT_SCORE)
+        return true;
+    return false;
+};
+export const getSpecificityWarning = (verdict) => {
+    const warning = verdict.specificity_warning?.trim();
+    return warning && warning.length > 0 ? warning : DEFAULT_SPECIFICITY_WARNING;
+};
+export const toSpeechActType = (classification) => {
+    if (classification === "COMMISSIVE" || classification === "DIRECTIVE")
+        return classification;
+    return null;
+};
+/**
+ * Factory class to build and compile the Intent Processing Graph.
+
+/**
+ * Generate a flat embedding for an intent payload, swallowing failures so
+ * persistence can continue without an embedding. `intentId` is logging-only
+ * (present for updates, absent for creates).
+ */
+export async function generateIntentEmbedding(deps, sanitizedPayload, intentId) {
+    if (!deps.embedder)
+        return undefined;
+    try {
+        const embedding = await deps.embedder.generate(sanitizedPayload, undefined, getAbortSignalConfig());
+        const flatEmbedding = Array.isArray(embedding?.[0])
+            ? embedding[0]
+            : embedding;
+        logger.verbose("Generated embedding for intent", {
+            ...(intentId ? { intentId } : {}),
+            dimensions: flatEmbedding?.length,
+        });
+        return flatEmbedding;
+    }
+    catch (embErr) {
+        logger.error("Failed to generate embedding for intent (continuing without)", {
+            ...(intentId ? { intentId } : {}),
+            error: embErr,
+        });
+        return undefined;
+    }
+}

package/dist/intents/domain/intent.state.d.ts

@@ -82,7 +82,7 @@ export declare const IntentGraphState: import("@langchain/langgraph").Annotation
      *
      * Defaults to 'create' for backward compatibility.
      */
-    operationMode: import("@langchain/langgraph").BaseChannel<"delete" | "propose" | "update" | "create" | "read", "delete" | "propose" | "update" | "create" | "read" | import("@langchain/langgraph").OverwriteValue<"delete" | "propose" | "update" | "create" | "read">, unknown>;
+    operationMode: import("@langchain/langgraph").BaseChannel<"update" | "propose" | "create" | "delete" | "read", "update" | "propose" | "create" | "delete" | "read" | import("@langchain/langgraph").OverwriteValue<"update" | "propose" | "create" | "delete" | "read">, unknown>;
     /**
      * For update/delete operations, specifies which intent IDs to target.
      * Optional - used when modifying or removing specific intents.

package/dist/maintenance/maintenance.graph.d.ts

@@ -1,3 +1,4 @@
+import { MaintenanceGraphState } from './maintenance.state.js';
 /** Database methods needed by the maintenance graph (includes introducer discovery). */
 export interface MaintenanceGraphDatabase {
     getOpportunitiesForUser(userId: string, options?: {
@@ -43,14 +44,25 @@ export interface MaintenanceGraphQueue {
         jobId?: string;
     }): Promise<unknown>;
 }
+/**
+ * Factory for the Maintenance Graph.
+ * Accepts database, cache, and queue dependencies via constructor injection.
+ */
+/** The graph's channel state, as every node sees it. */
+export type MaintenanceState = typeof MaintenanceGraphState.State;
+/** Everything the maintenance nodes reach for. */
+export interface MaintenanceGraphDeps {
+    database: MaintenanceGraphDatabase;
+    cache: MaintenanceGraphCache;
+    queue: MaintenanceGraphQueue;
+}
 /**
  * Factory for the Maintenance Graph.
  * Accepts database, cache, and queue dependencies via constructor injection.
  */
 export declare class MaintenanceGraphFactory {
-    private database;
-    private cache;
-    private queue;
+    /** Resolved dependency bag shared by every node. */
+    readonly deps: MaintenanceGraphDeps;
     constructor(database: MaintenanceGraphDatabase, cache: MaintenanceGraphCache, queue: MaintenanceGraphQueue);
     /** Compile and return the maintenance graph. */
     createGraph(): import("@langchain/langgraph").CompiledStateGraph<{
@@ -174,3 +186,54 @@ export declare class MaintenanceGraphFactory {
         logMaintenance: {};
     }, unknown, unknown, []>;
 }
+export declare function loadCurrentRadarNode(state: MaintenanceState, deps: MaintenanceGraphDeps): Promise<{
+    error: string;
+    currentOpportunities?: undefined;
+    expiredCount?: undefined;
+    activeIntents?: undefined;
+    lastRediscoveryAt?: undefined;
+} | {
+    currentOpportunities: {
+        [key: string]: unknown;
+        id: string;
+        actors: Array<{
+            userId: string;
+            role: string;
+        }>;
+        status: string;
+    }[];
+    expiredCount: number;
+    activeIntents: {
+        id: string;
+        payload: string;
+    }[];
+    lastRediscoveryAt: number | null;
+    error?: undefined;
+}>;
+export declare function scoreRadarHealthNode(state: MaintenanceState): Promise<{
+    healthResult?: undefined;
+    connectorFlowCount?: undefined;
+    error?: undefined;
+} | {
+    healthResult: import("../opportunities/radar/radar.health.js").RadarHealthResult;
+    connectorFlowCount: number;
+    error?: undefined;
+} | {
+    error: string;
+    healthResult?: undefined;
+    connectorFlowCount?: undefined;
+}>;
+export declare function shouldRediscover(state: MaintenanceState): string;
+export declare function rediscoverNode(state: MaintenanceState, deps: MaintenanceGraphDeps): Promise<{
+    rediscoveryJobsEnqueued: number;
+    error?: undefined;
+} | {
+    error: string;
+    rediscoveryJobsEnqueued?: undefined;
+}>;
+export declare function introducerDiscoveryNode(state: MaintenanceState, deps: MaintenanceGraphDeps): Promise<{
+    introducerDiscoveryJobsEnqueued?: undefined;
+} | {
+    introducerDiscoveryJobsEnqueued: number;
+}>;
+export declare function logMaintenanceNode(state: MaintenanceState): Promise<{}>;