@indexnetwork/protocol 22.0.0-rc.499.1 → 64.0.0-rc.604.2

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

@@ -1,274 +0,0 @@
-/**
- * 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/graph/intent.graph.shared.d.ts

@@ -1,68 +0,0 @@
-/**
- * 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 "./intent.graph.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";
-/** 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;
-    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/intake/intake.orchestrator.d.ts

@@ -1,203 +0,0 @@
-/**
- * Deterministic signal-intake stage logic.
- *
- * The fast intake path is a fixed funnel, so stages are driven here rather than
- * by an agent loop: round 1 comes from the precomputed pack, round 2 is one
- * structured call, round 3 is a deterministic client-side picker, and synthesis
- * is one structured call. This module owns no I/O.
- */
-import type { BaseLanguageModelInput } from "@langchain/core/language_models/base";
-import type { Runnable } from "@langchain/core/runnables";
-import { z } from "zod";
-import { type IntakePackQuestion } from "./intake.pack.generator.js";
-/** One answered intake round. */
-export interface IntakeAnswer {
-    selectedOptions: string[];
-    freeText?: string;
-}
-/** One answered intake round, in order (round 1 first). */
-export interface IntakeRound {
-    prompt: string;
-    answer: IntakeAnswer;
-}
-/** Everything synthesis needs to write the signal. */
-export interface SynthesisInput {
-    brief: string;
-    rounds: IntakeRound[];
-    /** Free-text place/community constraint from the where round. */
-    whereText?: string;
-    /**
-     * Free-text correction the user typed against a draft they already saw.
-     * Distinct from {@link SynthesisInput.whereText}: feedback rewrites the
-     * signal, it does not constrain where to look.
-     */
-    feedback?: string;
-}
-/** Planning input for one follow-up generation call. */
-export interface FollowUpPlanInput {
-    brief: string;
-    /** Answered rounds in order (round 1 first). */
-    rounds: IntakeRound[];
-    /** Hard cap on questions returned by THIS call. */
-    maxFollowUps: number;
-    /** Locked interview plan on continuation calls; echoed unchanged. */
-    plannedFollowUpCount?: number;
-}
-/** The model's follow-up batch plus its total follow-up plan. */
-export interface FollowUpPlan {
-    questions: IntakePackQuestion[];
-    plannedFollowUpCount: number;
-}
-/** Synthesized signal text plus its summary fields. */
-export interface SynthesisResult {
-    description: string;
-    lookingFor: string;
-    youBring: string;
-}
-declare const followUpPlanSchema: z.ZodObject<{
-    questions: z.ZodArray<z.ZodObject<{
-        missingAxis: z.ZodEnum<["purpose", "desired_attributes", "exchange", "constraint"]>;
-        title: z.ZodString;
-        prompt: z.ZodString;
-        answerGroundedOptions: z.ZodArray<z.ZodObject<{
-            label: z.ZodString;
-            description: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            label: string;
-            description: string;
-        }, {
-            label: string;
-            description: string;
-        }>, "many">;
-        multiSelect: z.ZodBoolean;
-    }, "strip", z.ZodTypeAny, {
-        prompt: string;
-        title: string;
-        multiSelect: boolean;
-        missingAxis: "purpose" | "desired_attributes" | "exchange" | "constraint";
-        answerGroundedOptions: {
-            label: string;
-            description: string;
-        }[];
-    }, {
-        prompt: string;
-        title: string;
-        multiSelect: boolean;
-        missingAxis: "purpose" | "desired_attributes" | "exchange" | "constraint";
-        answerGroundedOptions: {
-            label: string;
-            description: string;
-        }[];
-    }>, "many">;
-    plannedFollowUpCount: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    questions: {
-        prompt: string;
-        title: string;
-        multiSelect: boolean;
-        missingAxis: "purpose" | "desired_attributes" | "exchange" | "constraint";
-        answerGroundedOptions: {
-            label: string;
-            description: string;
-        }[];
-    }[];
-    plannedFollowUpCount: number;
-}, {
-    questions: {
-        prompt: string;
-        title: string;
-        multiSelect: boolean;
-        missingAxis: "purpose" | "desired_attributes" | "exchange" | "constraint";
-        answerGroundedOptions: {
-            label: string;
-            description: string;
-        }[];
-    }[];
-    plannedFollowUpCount: number;
-}>;
-declare const profileBridgePlanSchema: z.ZodObject<{
-    bridges: z.ZodArray<z.ZodObject<{
-        questionIndex: z.ZodNumber;
-        profileBridgeOption: z.ZodNullable<z.ZodObject<{
-            label: z.ZodString;
-            description: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            label: string;
-            description: string;
-        }, {
-            label: string;
-            description: string;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        questionIndex: number;
-        profileBridgeOption: {
-            label: string;
-            description: string;
-        } | null;
-    }, {
-        questionIndex: number;
-        profileBridgeOption: {
-            label: string;
-            description: string;
-        } | null;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    bridges: {
-        questionIndex: number;
-        profileBridgeOption: {
-            label: string;
-            description: string;
-        } | null;
-    }[];
-}, {
-    bridges: {
-        questionIndex: number;
-        profileBridgeOption: {
-            label: string;
-            description: string;
-        } | null;
-    }[];
-}>;
-/** Static round-1 question used only when pack generation fails outright. */
-export declare const FALLBACK_WHO_QUESTION: IntakePackQuestion;
-/** Static round-2 question used when live generation fails. */
-export declare const FALLBACK_BRING_QUESTION: IntakePackQuestion;
-/**
- * Render an answer as a human-readable label.
- *
- * @param answer - Selected options plus optional free text
- * @returns Comma-joined non-empty parts
- */
-export declare function answerLabel(answer: IntakeAnswer): string;
-/** Runs the two live stages of the fast intake funnel: follow-up planning and synthesis. */
-export declare class SignalIntakeOrchestrator {
-    private readonly plannerModel;
-    private readonly profileBridgeModel;
-    private readonly synthesisModel;
-    /**
-     * @param models - Optional injected structured models. Tests pass stubs.
-     */
-    constructor(models?: {
-        planner?: Runnable<BaseLanguageModelInput, z.infer<typeof followUpPlanSchema>>;
-        profileBridge?: Runnable<BaseLanguageModelInput, z.infer<typeof profileBridgePlanSchema>>;
-        synthesis?: Runnable<BaseLanguageModelInput, SynthesisResult>;
-    });
-    /**
-     * Plan and write follow-up questions from the brief and answered rounds.
-     *
-     * @param input - Brief, answered rounds, per-call cap, and any locked plan
-     * @returns Up to `maxFollowUps` renderable questions plus the total plan;
-     * the static fallback question with count 1 when generation fails
-     */
-    generateFollowUps(input: FollowUpPlanInput): Promise<FollowUpPlan>;
-    /**
-     * Write the signal from every answered round, any where-constraint, and any
-     * revision feedback.
-     *
-     * @param input - Brief, ordered rounds, optional where constraint, optional feedback
-     * @returns Description plus card summary fields
-     * @throws Propagates model failure so the caller can mark the run failed
-     */
-    synthesize(input: SynthesisInput): Promise<SynthesisResult>;
-}
-export {};