@indexnetwork/protocol 22.0.0-rc.499.1 → 64.0.0

package/dist/enrichment/enrichment.tools.helpers.js

@@ -1,234 +0,0 @@
-/**
- * Helpers shared by the enrichment tools.
- *
- * These were nested functions inside `createEnrichmentTools`, closing over the
- * destructured host capabilities. They are top-level now, each taking the tool
- * deps explicitly, so the three tool modules can share them.
- */
-import { z } from "zod";
-import { requestContext } from "../shared/observability/request-context.js";
-import { protocolLogger } from "../shared/observability/protocol.logger.js";
-import { socialsToEnrichmentRequest } from "../shared/utils/social-label.js";
-import { normalizeTelegramHandle } from "../shared/utils/telegram-handle.js";
-import { focusedNetworkId } from "../shared/agent/tool.scope.js";
-export const logger = protocolLogger("ChatTools:Enrichment");
-export function isMeaningfulEnrichment(enrichment) {
-    return !!enrichment &&
-        enrichment.confidentMatch &&
-        (enrichment.identity.bio.trim().length > 0 ||
-            enrichment.narrative.context.trim().length > 0 ||
-            enrichment.attributes.skills.length > 0 ||
-            enrichment.attributes.interests.length > 0);
-}
-export const approvedProfileDraftSchema = z.object({
-    identity: z.object({ name: z.string(), bio: z.string(), location: z.string() }),
-    narrative: z.object({ context: z.string() }),
-    attributes: z.object({ interests: z.array(z.string()), skills: z.array(z.string()) }),
-});
-export function trimToUndefined(value) {
-    const trimmed = value?.trim();
-    return trimmed && trimmed.length > 0 ? trimmed : undefined;
-}
-export function isPlaceholderName(value) {
-    const normalized = value.trim().toLowerCase();
-    return normalized === 'unknown' || normalized === 'user';
-}
-export async function enrichFromUserRecord(deps, user) {
-    const enrichmentSocials = socialsToEnrichmentRequest(user.socials);
-    return deps.enricher.enrichUserProfile({
-        name: trimToUndefined(user.name),
-        email: trimToUndefined(user.email),
-        linkedin: enrichmentSocials.linkedin || undefined,
-        twitter: enrichmentSocials.twitter || undefined,
-        github: enrichmentSocials.github || undefined,
-        telegram: enrichmentSocials.telegram || undefined,
-        websites: enrichmentSocials.websites?.length ? enrichmentSocials.websites : undefined,
-    });
-}
-export function selectProfileSeed(onboarding, networkId) {
-    const seeds = onboarding?.profileSeeds ?? [];
-    if (seeds.length === 0)
-        return undefined;
-    const scoped = networkId ? seeds.filter((seed) => seed.networkId === networkId) : seeds;
-    return scoped[scoped.length - 1];
-}
-export function normalizeSocialUpdate(label, value) {
-    const normalizedLabel = label.trim().toLowerCase();
-    if (!normalizedLabel)
-        return null;
-    const trimmedValue = value.trim();
-    if (!trimmedValue)
-        return null;
-    if (normalizedLabel === 'telegram') {
-        const handle = normalizeTelegramHandle(trimmedValue);
-        return handle ? { label: normalizedLabel, value: handle } : null;
-    }
-    return { label: normalizedLabel, value: trimmedValue };
-}
-export async function mergeUserSocials(deps, incoming) {
-    const normalizedIncoming = incoming
-        .map((social) => normalizeSocialUpdate(social.label, social.value))
-        .filter((social) => social !== null);
-    if (normalizedIncoming.length === 0)
-        return;
-    const existingSocials = await deps.userDb.getUserSocials();
-    const incomingLabels = new Set(normalizedIncoming.map((social) => social.label));
-    const kept = existingSocials
-        .filter((social) => !incomingLabels.has(social.label) || social.label === 'custom')
-        .map((social) => ({ label: social.label, value: social.value }));
-    const merged = incomingLabels.has('custom')
-        ? [...kept.filter((social) => social.label !== 'custom'), ...normalizedIncoming]
-        : [...kept, ...normalizedIncoming];
-    await deps.userDb.setUserSocials(merged);
-}
-export function socialsRecordToRows(socials) {
-    if (!socials)
-        return [];
-    return Object.entries(socials).map(([label, value]) => ({ label, value }));
-}
-export async function enqueueEnrichmentRun(deps, context, operation, input) {
-    if (!context.isMcp || !deps.enrichmentRuns || !deps.enrichmentRunQueue)
-        return null;
-    const run = await deps.enrichmentRuns.create({
-        userId: context.userId,
-        agentId: context.agentId ?? null,
-        operation,
-        input,
-        context: {
-            userId: context.userId,
-            userName: context.userName,
-            userEmail: context.userEmail,
-            ...(focusedNetworkId(context) ? { scopeType: 'network', scopeId: focusedNetworkId(context) } : {}),
-            ...(context.indexName ? { indexName: context.indexName } : {}),
-            ...(context.sessionId ? { sessionId: context.sessionId } : {}),
-            ...(context.agentId ? { agentId: context.agentId } : {}),
-        },
-    });
-    try {
-        await deps.enrichmentRunQueue.enqueue(run.id);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        await deps.enrichmentRuns.markFailed(run.id, message);
-        if (err instanceof Error)
-            throw err;
-        const wrapped = new Error(`Failed to enqueue profile run: ${message}`);
-        wrapped.cause = err;
-        throw wrapped;
-    }
-    return run.id;
-}
-export async function persistApprovedProfileContext(deps, profile, user, networkId) {
-    await deps.userDb.updateUser({
-        name: profile.identity.name,
-        intro: profile.identity.bio,
-        location: profile.identity.location,
-    });
-    const onboarding = user?.onboarding ?? undefined;
-    const seed = selectProfileSeed(onboarding, networkId);
-    if (!seed?.socials?.length)
-        return;
-    await mergeUserSocials(deps, seed.socials);
-}
-export async function markApprovedProfileConfirmed(deps, context) {
-    const latestUser = await deps.userDb.getUser();
-    const currentOnboarding = latestUser?.onboarding ?? context.user.onboarding ?? {};
-    await deps.userDb.updateUser({
-        onboarding: {
-            ...currentOnboarding,
-            profileConfirmedAt: currentOnboarding.profileConfirmedAt ?? new Date().toISOString(),
-            currentStep: currentOnboarding.completedAt
-                ? currentOnboarding.currentStep ?? 'complete'
-                : 'first_signal',
-        },
-    });
-}
-export function buildProfileInput(parts) {
-    const lines = [];
-    if (parts.name)
-        lines.push(`Name: ${parts.name}`);
-    if (parts.location)
-        lines.push(`Location: ${parts.location}`);
-    if (parts.bioOrDescription)
-        lines.push(parts.bioOrDescription);
-    if (parts.socials?.length) {
-        lines.push(`User-provided public links:\n${parts.socials.map((s) => `${s.label}: ${s.value}`).join('\n')}`);
-    }
-    return lines.filter((line) => line.trim().length > 0).join('\n\n');
-}
-export function toProfileSummary(profile) {
-    return {
-        name: profile.identity.name,
-        bio: profile.identity.bio,
-        location: profile.identity.location,
-        skills: profile.attributes.skills,
-        interests: profile.attributes.interests,
-    };
-}
-export function buildApprovedDraftProfileInput(draft) {
-    return [
-        draft.identity.name ? `My name is ${draft.identity.name}.` : '',
-        draft.identity.location ? `I am based in ${draft.identity.location}.` : '',
-        draft.identity.bio || '',
-        draft.narrative.context || '',
-        draft.attributes.skills.length ? `My skills include ${draft.attributes.skills.join(', ')}.` : '',
-        draft.attributes.interests.length ? `My interests include ${draft.attributes.interests.join(', ')}.` : '',
-    ].filter((part) => part.trim().length > 0).join('\n');
-}
-export async function decomposeApprovedDraftProfile(deps, profile) {
-    const input = buildApprovedDraftProfileInput(profile);
-    if (!input.trim())
-        return;
-    const traceEmitter = requestContext.getStore()?.traceEmitter;
-    const graphStart = Date.now();
-    traceEmitter?.({ type: "graph_start", name: "enrichment" });
-    try {
-        const graphInput = {
-            userId: profile.userId,
-            operationMode: 'write',
-            input,
-            forceUpdate: true,
-        };
-        // Always invoked as a background fire-and-forget task (see confirm_user_context
-        // call sites), so decomposition must outlive the originating request — invoke
-        // the graph directly and never bind the request abort signal, which would
-        // cancel it as soon as the web request completes.
-        const result = await deps.graphs.profile.invoke(graphInput);
-        if (result.error) {
-            const err = new Error(result.error);
-            logger.error('Approved draft premise decomposition failed', {
-                userId: profile.userId,
-                error: result.error,
-            });
-            deps.reportToolError?.(err, {
-                subsystem: 'enrichment',
-                operation: 'profile.confirm_draft_decompose',
-                toolName: 'confirm_user_context',
-                userId: profile.userId,
-                tags: { toolName: 'confirm_user_context', execution: 'background' },
-            });
-            return;
-        }
-        // The write graph's decompose → aggregate → generate → save_profile
-        // pipeline persists the aggregate profile. The approved draft was already
-        // saved before decomposition started, so the DB is consistent regardless
-        // of graph outcome.  Do not re-save here — the graph's save_profile is
-        // authoritative, and a concurrent user-driven profile update could race.
-    }
-    catch (err) {
-        logger.error('Approved draft premise decomposition failed', {
-            userId: profile.userId,
-            error: err instanceof Error ? err.message : String(err),
-        });
-        deps.reportToolError?.(err, {
-            subsystem: 'enrichment',
-            operation: 'profile.confirm_draft_decompose',
-            toolName: 'confirm_user_context',
-            userId: profile.userId,
-            tags: { toolName: 'confirm_user_context', execution: 'background' },
-        });
-    }
-    finally {
-        traceEmitter?.({ type: "graph_end", name: "enrichment", durationMs: Date.now() - graphStart });
-    }
-}

package/dist/enrichment/enrichment.tools.js

@@ -1,153 +0,0 @@
-/**
- * The enrichment tool registry.
- *
- * The user-context read and write tools live in sibling modules and the shared
- * helpers in `enrichment.tools.helpers.ts`; this file owns the enrichment-run
- * and onboarding tools and assembles the registry.
- */
-import { z } from "zod";
-import { success, error } from "../shared/agent/tool.helpers.js";
-import { logger } from "./enrichment.tools.helpers.js";
-import { createUserContextReadTools } from "./enrichment.tools.context-read.js";
-import { createUserContextWriteTools } from "./enrichment.tools.context-write.js";
-export function createEnrichmentTools(defineTool, deps, options = {}) {
-    const { userDb, systemDb, graphs, enricher, grantDefaultSystemPermissions, reportToolError, getUserContextText } = deps;
-    const isMcpSurface = options.surface === "mcp";
-    const { readUserContexts, previewUserContext, confirmUserContext } = createUserContextReadTools(defineTool, deps);
-    const { createUserContext, updateUserContext } = createUserContextWriteTools(defineTool, deps);
-    const getEnrichmentRun = defineTool({
-        name: "get_enrichment_run",
-        description: "Checks the status of an async profile preview/update run started by preview_user_context or update_user_context in MCP contexts. " +
-            "Poll this tool with the profileRunId until status is succeeded, failed, or cancelled. When succeeded, present the result to the user.",
-        querySchema: z.object({
-            profileRunId: z.string().describe("Profile run ID returned by preview_user_context or update_user_context."),
-        }),
-        handler: async ({ context, query }) => {
-            if (!deps.enrichmentRuns) {
-                return error("Profile run polling is not available in this environment.");
-            }
-            const run = await deps.enrichmentRuns.get(query.profileRunId, context.userId);
-            if (!run)
-                return error("Profile run not found.");
-            return success({
-                profileRunId: run.id,
-                operation: run.operation,
-                status: run.status,
-                progress: run.progress ?? null,
-                result: run.result ?? null,
-                error: run.error ?? null,
-                createdAt: run.createdAt.toISOString?.() ?? null,
-                startedAt: run.startedAt?.toISOString?.() ?? null,
-                completedAt: run.completedAt?.toISOString?.() ?? null,
-            });
-        },
-    });
-    const cancelEnrichmentRun = defineTool({
-        name: "cancel_enrichment_run",
-        description: "Requests cancellation for an async profile run. If the queued job has not started, it is removed and marked cancelled. " +
-            "If already running, the worker observes the cancellation request and aborts where supported.",
-        querySchema: z.object({
-            profileRunId: z.string().describe("Profile run ID returned by preview_user_context or update_user_context."),
-        }),
-        handler: async ({ context, query }) => {
-            if (!deps.enrichmentRuns || !deps.enrichmentRunQueue) {
-                return error("Profile run cancellation is not available in this environment.");
-            }
-            const existing = await deps.enrichmentRuns.get(query.profileRunId, context.userId);
-            if (!existing)
-                return error("Profile run not found.");
-            if (!["queued", "running"].includes(existing.status)) {
-                return success({
-                    profileRunId: existing.id,
-                    status: existing.status,
-                    message: `Profile run is already ${existing.status}.`,
-                });
-            }
-            const run = await deps.enrichmentRuns.requestCancel(query.profileRunId, context.userId);
-            if (!run)
-                return error("Profile run not found or cannot be cancelled.");
-            const removed = await deps.enrichmentRunQueue.cancel(run.id);
-            if (removed) {
-                await deps.enrichmentRuns.markCancelled(run.id, "cancelled before worker start");
-            }
-            const updated = await deps.enrichmentRuns.get(run.id, context.userId);
-            return success({
-                profileRunId: run.id,
-                status: updated?.status ?? run.status,
-                cancelled: true,
-                message: removed
-                    ? "Profile run cancelled before it started."
-                    : "Cancellation requested while the profile run is running or queued.",
-            });
-        },
-    });
-    const completeOnboarding = isMcpSurface ? null : defineTool({
-        name: "complete_onboarding",
-        description: "Marks the user's onboarding as complete after validating the durable approved-profile marker and a persisted active first signal created at or after that approval. " +
-            "Web onboarding should pass the exact intentId returned by /intents/confirm; legacy clients may omit it and use any eligible active intent. " +
-            "This records firstSignalIntentId/currentStep and is idempotent.",
-        querySchema: z.object({
-            intentId: z.string().min(1).optional().describe("Exact first-signal ID returned by the confirmation endpoint."),
-        }).strict(),
-        handler: async ({ context, query }) => {
-            const currentUser = await userDb.getUser();
-            const currentOnboarding = currentUser?.onboarding ?? context.user.onboarding ?? {};
-            if (currentOnboarding.completedAt) {
-                logger.verbose("Onboarding already completed, skipping", { userId: context.userId });
-                return success({
-                    message: "Onboarding already completed.",
-                    completedAt: currentOnboarding.completedAt,
-                    ...(currentOnboarding.firstSignalIntentId
-                        ? { intentId: currentOnboarding.firstSignalIntentId }
-                        : {}),
-                });
-            }
-            if (!currentOnboarding.profileConfirmedAt) {
-                return error("Onboarding cannot be completed until the user has a confirmed profile. Show the profile draft, get explicit approval, then save it before finishing onboarding.");
-            }
-            const profileConfirmedAtMs = Date.parse(currentOnboarding.profileConfirmedAt);
-            if (!Number.isFinite(profileConfirmedAtMs)) {
-                return error("Onboarding cannot be completed because the durable profile confirmation timestamp is invalid. Confirm the approved profile again before finishing onboarding.");
-            }
-            const activeIntents = await userDb.getActiveIntents();
-            const isEligibleFirstSignal = (intent) => {
-                const createdAtMs = intent.createdAt.getTime();
-                return Number.isFinite(createdAtMs) && createdAtMs >= profileConfirmedAtMs;
-            };
-            const firstSignal = query.intentId
-                ? activeIntents.find((intent) => intent.id === query.intentId)
-                : activeIntents.find(isEligibleFirstSignal);
-            if (!firstSignal) {
-                return error(query.intentId
-                    ? "Onboarding cannot be completed because the confirmed first signal is not active for this user."
-                    : "Onboarding cannot be completed until the user has at least one active intent created after profile confirmation. Ask what they are open to right now and create the first signal before finishing onboarding.");
-            }
-            if (!isEligibleFirstSignal(firstSignal)) {
-                return error("Onboarding cannot be completed because the selected first signal was created before profile confirmation. Create and confirm a new signal before finishing onboarding.");
-            }
-            const completedAt = new Date().toISOString();
-            await userDb.updateUser({
-                onboarding: {
-                    ...currentOnboarding,
-                    firstSignalIntentId: firstSignal.id,
-                    currentStep: 'complete',
-                    completedAt,
-                },
-            });
-            if (grantDefaultSystemPermissions) {
-                try {
-                    await grantDefaultSystemPermissions(context.userId);
-                }
-                catch (err) {
-                    logger.warn('Default system agent permission grant failed (non-fatal)', {
-                        userId: context.userId,
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
-            }
-            logger.info("Onboarding completed", { userId: context.userId, intentId: firstSignal.id });
-            return success({ message: "Onboarding complete.", intentId: firstSignal.id, completedAt });
-        },
-    });
-    return [readUserContexts, previewUserContext, confirmUserContext, createUserContext, updateUserContext, getEnrichmentRun, cancelEnrichmentRun, completeOnboarding];
-}

package/dist/intents/graph/intent.graph.infer.d.ts

@@ -1,44 +0,0 @@
-/**
- * Intent graph, stages 0-1: load the user's signals, then infer new ones.
- */
-import type { DebugMetaAgent } from "../../agents/agent.module.js";
-import { type IntentGraphDeps, type IntentState } from "./intent.graph.shared.js";
-/**
- * Node 0: Prep
- * Always fetches ALL of the user's active intents from the DB via getActiveIntents(userId).
- * This ensures reconciliation can detect duplicates and modifications globally,
- * regardless of network scope.
- */
-export declare function prepNode(state: IntentState, deps: IntentGraphDeps): Promise<{
-    error: string;
-    activeIntents?: undefined;
-    activeIntentIds?: undefined;
-    trace?: undefined;
-} | {
-    activeIntents: string;
-    activeIntentIds: string[];
-    trace: {
-        node: string;
-        detail: string;
-    }[];
-    error?: undefined;
-}>;
-/**
- * Node 1: Inference
- * Extracts intents from raw content.
- * Phase 4: Uses operation mode to control behavior and determine if node should execute.
- * Phase 5: Passes conversation context for anaphoric resolution.
- */
-export declare function inferenceNode(state: IntentState, deps: IntentGraphDeps): Promise<{
-    inferredIntents: {
-        reasoning: string;
-        type: "goal" | "tombstone";
-        confidence: "low" | "medium" | "high";
-        description: string;
-    }[];
-    agentTimings: DebugMetaAgent[];
-    trace: {
-        node: string;
-        detail: string;
-    }[];
-}>;

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

@@ -1,97 +0,0 @@
-/**
- * Intent graph, stages 0-1: load the user's signals, then infer new ones.
- */
-import { timed } from "../../shared/observability/performance.js";
-import { requestContext } from "../../shared/observability/request-context.js";
-import { logger } from "./intent.graph.shared.js";
-/**
- * Node 0: Prep
- * Always fetches ALL of the user's active intents from the DB via getActiveIntents(userId).
- * This ensures reconciliation can detect duplicates and modifications globally,
- * regardless of network scope.
- */
-export async function prepNode(state, deps) {
-    return timed("IntentGraph.prep", async () => {
-        logger.verbose("Starting preparation phase", {
-            operationMode: state.operationMode,
-            hasContent: !!state.inputContent,
-            targetIntentIds: state.targetIntentIds,
-            networkId: state.networkId,
-        });
-        // Gate: write operations require an existing profile
-        if (state.operationMode !== 'read') {
-            const profile = await deps.database.getProfile(state.userId);
-            if (!profile) {
-                const msg = "You need to create a profile before creating intents. Please set up your profile first.";
-                logger.error("Prep failed: no profile for user", { userId: state.userId });
-                return { error: msg };
-            }
-        }
-        const activeIntents = await deps.database.getActiveIntents(state.userId);
-        const formattedActiveIntents = activeIntents
-            .map(i => `ID: ${i.id}, Description: ${i.payload}, Summary: ${i.summary || 'N/A'}`)
-            .join('\n') || "No active intents.";
-        logger.verbose("Fetched active intents", {
-            count: activeIntents.length,
-            operationMode: state.operationMode
-        });
-        return {
-            activeIntents: formattedActiveIntents,
-            activeIntentIds: activeIntents.map((intent) => intent.id),
-            trace: [{
-                    node: "prep",
-                    detail: `Fetched ${activeIntents.length} active intent(s)`,
-                }],
-        };
-    });
-}
-/**
- * Node 1: Inference
- * Extracts intents from raw content.
- * Phase 4: Uses operation mode to control behavior and determine if node should execute.
- * Phase 5: Passes conversation context for anaphoric resolution.
- */
-export async function inferenceNode(state, deps) {
-    return timed("IntentGraph.inference", async () => {
-        logger.verbose("Starting inference", {
-            operationMode: state.operationMode,
-            hasContent: !!state.inputContent,
-            contentPreview: state.inputContent?.substring(0, 50),
-            hasConversationContext: !!state.conversationContext,
-            conversationMessagesCount: state.conversationContext?.length || 0
-        });
-        const agentTimingsAccum = [];
-        // Phase 4: Control profile fallback based on operation mode
-        // Only allow for create operations without explicit content
-        const allowProfileFallback = state.operationMode === 'create' && !state.inputContent;
-        // Cast operationMode: 'read' and 'propose' map to 'create' for the deps.inferrer
-        // (inference node is never called in read mode; propose behaves like create for inference)
-        const inferrerMode = (state.operationMode === 'read' || state.operationMode === 'propose') ? 'create' : state.operationMode;
-        const _traceEmitterInferrer = requestContext.getStore()?.traceEmitter;
-        const inferrerStart = Date.now();
-        _traceEmitterInferrer?.({ type: "agent_start", name: "intent-inferrer" });
-        const result = await deps.inferrer.invoke(state.inputContent || null, state.userProfile, {
-            allowProfileFallback,
-            operationMode: inferrerMode,
-            conversationContext: state.conversationContext // Phase 5: Pass conversation history
-        });
-        agentTimingsAccum.push({ name: 'intent.inferrer', durationMs: Date.now() - inferrerStart });
-        _traceEmitterInferrer?.({ type: "agent_end", name: "intent-inferrer", durationMs: Date.now() - inferrerStart, summary: result.intents.length > 0 ? `Extracted ${result.intents.length} intent(s)` : "intent-inferrer completed" });
-        logger.verbose("Inference complete", {
-            inferredCount: result.intents.length,
-            operationMode: state.operationMode
-        });
-        const descriptions = result.intents.map(i => i.description).slice(0, 3);
-        const truncated = result.intents.length > 3 ? `... +${result.intents.length - 3} more` : "";
-        return {
-            inferredIntents: result.intents,
-            agentTimings: agentTimingsAccum,
-            trace: [{
-                    node: "inference",
-                    detail: result.intents.length === 0
-                        ? "No intents extracted"
-                        : `Extracted ${result.intents.length}: ${descriptions.map(d => `"${d.slice(0, 50)}${d.length > 50 ? '...' : ''}"`).join(", ")}${truncated}`,
-                }],
-        };
-    });
-}

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

@@ -1,134 +0,0 @@
-/**
- * Intent graph: prep → (query | inference → verification → reconciler → executor).
- *
- * Every node is a top-level function in a sibling module, taking the graph
- * state and an explicit {@link IntentGraphDeps}. This file composes the
- * dependency bag and wires the edges — nothing else.
- */
-import { StateGraph, START, END } from "@langchain/langgraph";
-import { ExplicitIntentInferrer } from "../intent.inferrer.js";
-import { SemanticVerifier } from "../intent.verifier.js";
-import { IntentReconciler } from "../intent.reconciler.js";
-import { IntentGraphState } from "./intent.graph.state.js";
-import { logger } from "./intent.graph.shared.js";
-import { inferenceNode, prepNode } from "./intent.graph.infer.js";
-import { reconciliationNode, verificationNode } from "./intent.graph.reconcile.js";
-import { executorNode, queryNode } from "./intent.graph.execute.js";
-export { buildExplicitUpdateActions, enforceIntentActionBoundary } from "./intent.graph.shared.js";
-export class IntentGraphFactory {
-    constructor(database, embedder, intentQueue, agents) {
-        this.deps = {
-            database,
-            embedder,
-            intentQueue,
-            inferrer: agents?.inferrer ?? new ExplicitIntentInferrer(),
-            verifier: agents?.verifier ?? new SemanticVerifier(),
-            reconciler: agents?.reconciler ?? new IntentReconciler(),
-        };
-    }
-    createGraph() {
-        const deps = this.deps;
-        return new StateGraph(IntentGraphState)
-            .addNode("prep", (state) => prepNode(state, deps))
-            .addNode("query", (state) => queryNode(state, deps))
-            .addNode("inference", (state) => inferenceNode(state, deps))
-            .addNode("verification", (state) => verificationNode(state, deps))
-            .addNode("reconciler", (state) => reconciliationNode(state, deps))
-            .addNode("executor", (state) => executorNode(state, deps))
-            // Flow paths:
-            // - READ:    prep → query → END (fast path, no LLM calls)
-            // - CREATE:  prep → inference → verification → reconciler → executor → END
-            // - UPDATE:  prep → inference → reconciliation → executor → END (skips verification if no new intents)
-            // - DELETE:  prep → reconciliation → executor → END (skips inference and verification)
-            // - PROPOSE: prep → inference → verification → END (no reconciliation/execution, no DB writes)
-            .addEdge(START, "prep")
-            // After prep: read mode → query; else inference or reconciler
-            .addConditionalEdges("prep", afterPrepRoute, {
-            query: "query",
-            inference: "inference",
-            reconciler: "reconciler",
-            __end__: END,
-        })
-            // Query (read mode) always ends
-            .addEdge("query", END)
-            // After inference: decide if we need verification (skip if no intents)
-            .addConditionalEdges("inference", shouldRunVerification, {
-            verification: "verification",
-            reconciler: "reconciler",
-            __end__: END,
-        })
-            // After verification: propose mode exits early; others continue to reconciliation
-            .addConditionalEdges("verification", routeAfterVerification, {
-            reconciler: "reconciler",
-            __end__: END,
-        })
-            // Reconciliation always goes to executor
-            .addEdge("reconciler", "executor")
-            // Executor is always the end
-            .addEdge("executor", END)
-            .compile();
-    }
-}
-/**
- * After prep: read mode → query; otherwise decide inference vs reconciler by operation mode.
- */
-export function afterPrepRoute(state) {
-    if (state.error) {
-        logger.warn('Prep failed with error, short-circuiting to END', { error: state.error });
-        return '__end__';
-    }
-    if (state.operationMode === 'read') {
-        logger.verbose('Read mode - routing to query (fast path)');
-        return 'query';
-    }
-    return shouldRunInference(state);
-}
-/**
- * Determines if inference should run based on operation mode.
- * Delete operations skip inference entirely and go straight to reconciliation.
- */
-export function shouldRunInference(state) {
-    if (state.operationMode === 'delete') {
-        logger.verbose('Delete mode - skipping inference, routing to reconciliation');
-        return 'reconciler';
-    }
-    logger.verbose('Running inference', {
-        operationMode: state.operationMode
-    });
-    return 'inference';
-}
-/**
- * Determines if verification should run based on operation mode and inferred intents.
- * Skips verification for:
- * - Operations with no inferred intents
- * - Can be extended to skip for update operations with no new intents
- */
-export function shouldRunVerification(state) {
-    if (state.inferredIntents.length === 0) {
-        if (state.operationMode === 'propose') {
-            logger.verbose('Propose mode with no inferred intents - exiting early');
-            return '__end__';
-        }
-        logger.verbose('No intents to verify - skipping verification, routing to reconciliation');
-        return 'reconciler';
-    }
-    if (state.operationMode === 'update') {
-        logger.verbose('Update mode with new intents - running verification');
-        return 'verification';
-    }
-    if (state.operationMode === 'create') {
-        logger.verbose('Create mode - running verification');
-        return 'verification';
-    }
-    // Default to verification for safety
-    logger.verbose('Default routing to verification');
-    return 'verification';
-}
-/** After verification: propose mode exits early; others continue to reconciliation. */
-export function routeAfterVerification(state) {
-    if (state.operationMode === 'propose') {
-        logger.verbose('Propose mode - stopping after verification, skipping reconciliation');
-        return '__end__';
-    }
-    return 'reconciler';
-}