@indexnetwork/protocol 14.3.2-rc.477.1 → 17.0.0-rc.479.1

package/dist/premises/premise.graph.d.ts

@@ -1,16 +1,29 @@
+import { PremiseGraphState } from "./premise.state.js";
 import type { PremiseAnalyzerOutput } from "./premise.analyzer.js";
 import { PremiseIndexer } from "./premise.indexer.js";
 import type { PremiseGraphDatabase, PremiseAnalysis } from "../shared/interfaces/database.interface.js";
 import type { Embedder } from "../shared/interfaces/embedder.interface.js";
 import type { DebugMetaAgent } from "../agents/index.js";
+/**
+ * Graph factory for premise lifecycle: create, update, and query modes.
+ */
+/** The graph's channel state, as every node sees it. */
+export type PremiseState = typeof PremiseGraphState.State;
+/** Everything the premise nodes reach for. */
+export interface PremiseGraphDeps {
+    database: PremiseGraphDatabase;
+    embedder: Embedder;
+    premiseIndexer: PremiseIndexer;
+    premiseAnalyzer: {
+        invoke(premiseText: string, profileContext?: string): Promise<PremiseAnalyzerOutput>;
+    };
+}
 /**
  * Graph factory for premise lifecycle: create, update, and query modes.
  */
 export declare class PremiseGraphFactory {
-    private database;
-    private embedder;
-    private premiseIndexer;
-    private premiseAnalyzer;
+    /** Resolved dependency bag shared by every node. */
+    readonly deps: PremiseGraphDeps;
     constructor(database: PremiseGraphDatabase, embedder: Embedder, premiseIndexer?: PremiseIndexer, premiseAnalyzer?: {
         invoke(premiseText: string, profileContext?: string): Promise<PremiseAnalyzerOutput>;
     });
@@ -36,7 +49,7 @@ export declare class PremiseGraphFactory {
         targetPremiseId: string | undefined;
         analysis: PremiseAnalysis | undefined;
         embedding: number[] | undefined;
-        premise: import("../shared/interfaces/database.interface.js").PremiseRecord | undefined;
+        premise: import("../shared/interfaces/database.entities.js").PremiseRecord | undefined;
         duplicateOf: {
             premiseId: string;
             assertionText: string;
@@ -48,7 +61,7 @@ export declare class PremiseGraphFactory {
         }[];
         error: string | undefined;
         readResult: {
-            premises: import("../shared/interfaces/database.interface.js").PremiseRecord[];
+            premises: import("../shared/interfaces/database.entities.js").PremiseRecord[];
             count: number;
             message?: string;
         } | undefined;
@@ -70,7 +83,7 @@ export declare class PremiseGraphFactory {
         targetPremiseId?: string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined;
         analysis?: PremiseAnalysis | import("@langchain/langgraph").OverwriteValue<PremiseAnalysis | undefined> | undefined;
         embedding?: number[] | import("@langchain/langgraph").OverwriteValue<number[] | undefined> | undefined;
-        premise?: import("../shared/interfaces/database.interface.js").PremiseRecord | import("@langchain/langgraph").OverwriteValue<import("../shared/interfaces/database.interface.js").PremiseRecord | undefined> | undefined;
+        premise?: import("../shared/interfaces/database.entities.js").PremiseRecord | import("@langchain/langgraph").OverwriteValue<import("../shared/interfaces/database.entities.js").PremiseRecord | undefined> | undefined;
         duplicateOf?: {
             premiseId: string;
             assertionText: string;
@@ -89,16 +102,16 @@ export declare class PremiseGraphFactory {
         }[]> | undefined;
         error?: string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined;
         readResult?: {
-            premises: import("../shared/interfaces/database.interface.js").PremiseRecord[];
+            premises: import("../shared/interfaces/database.entities.js").PremiseRecord[];
             count: number;
             message?: string;
         } | import("@langchain/langgraph").OverwriteValue<{
-            premises: import("../shared/interfaces/database.interface.js").PremiseRecord[];
+            premises: import("../shared/interfaces/database.entities.js").PremiseRecord[];
             count: number;
             message?: string;
         } | undefined> | undefined;
         agentTimings?: DebugMetaAgent[] | import("@langchain/langgraph").OverwriteValue<DebugMetaAgent[]> | undefined;
-    }, "index" | "query" | "__start__" | "embed" | "persist" | "analyze" | "dedupe", {
+    }, "index" | "query" | "__start__" | "persist" | "analyze" | "embed" | "dedupe", {
         userId: {
             (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BaseChannel<string, string | import("@langchain/langgraph").OverwriteValue<string>, unknown>;
             (): import("@langchain/langgraph").LastValue<string>;
@@ -119,7 +132,7 @@ export declare class PremiseGraphFactory {
         targetPremiseId: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
         analysis: import("@langchain/langgraph").BaseChannel<PremiseAnalysis | undefined, PremiseAnalysis | import("@langchain/langgraph").OverwriteValue<PremiseAnalysis | undefined> | undefined, unknown>;
         embedding: import("@langchain/langgraph").BaseChannel<number[] | undefined, number[] | import("@langchain/langgraph").OverwriteValue<number[] | undefined> | undefined, unknown>;
-        premise: import("@langchain/langgraph").BaseChannel<import("../shared/interfaces/database.interface.js").PremiseRecord | undefined, import("../shared/interfaces/database.interface.js").PremiseRecord | import("@langchain/langgraph").OverwriteValue<import("../shared/interfaces/database.interface.js").PremiseRecord | undefined> | undefined, unknown>;
+        premise: import("@langchain/langgraph").BaseChannel<import("../shared/interfaces/database.entities.js").PremiseRecord | undefined, import("../shared/interfaces/database.entities.js").PremiseRecord | import("@langchain/langgraph").OverwriteValue<import("../shared/interfaces/database.entities.js").PremiseRecord | undefined> | undefined, unknown>;
         duplicateOf: import("@langchain/langgraph").BaseChannel<{
             premiseId: string;
             assertionText: string;
@@ -145,15 +158,15 @@ export declare class PremiseGraphFactory {
         }[]>, unknown>;
         error: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
         readResult: import("@langchain/langgraph").BaseChannel<{
-            premises: import("../shared/interfaces/database.interface.js").PremiseRecord[];
+            premises: import("../shared/interfaces/database.entities.js").PremiseRecord[];
             count: number;
             message?: string;
         } | undefined, {
-            premises: import("../shared/interfaces/database.interface.js").PremiseRecord[];
+            premises: import("../shared/interfaces/database.entities.js").PremiseRecord[];
             count: number;
             message?: string;
         } | import("@langchain/langgraph").OverwriteValue<{
-            premises: import("../shared/interfaces/database.interface.js").PremiseRecord[];
+            premises: import("../shared/interfaces/database.entities.js").PremiseRecord[];
             count: number;
             message?: string;
         } | undefined> | undefined, unknown>;
@@ -179,7 +192,7 @@ export declare class PremiseGraphFactory {
         targetPremiseId: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
         analysis: import("@langchain/langgraph").BaseChannel<PremiseAnalysis | undefined, PremiseAnalysis | import("@langchain/langgraph").OverwriteValue<PremiseAnalysis | undefined> | undefined, unknown>;
         embedding: import("@langchain/langgraph").BaseChannel<number[] | undefined, number[] | import("@langchain/langgraph").OverwriteValue<number[] | undefined> | undefined, unknown>;
-        premise: import("@langchain/langgraph").BaseChannel<import("../shared/interfaces/database.interface.js").PremiseRecord | undefined, import("../shared/interfaces/database.interface.js").PremiseRecord | import("@langchain/langgraph").OverwriteValue<import("../shared/interfaces/database.interface.js").PremiseRecord | undefined> | undefined, unknown>;
+        premise: import("@langchain/langgraph").BaseChannel<import("../shared/interfaces/database.entities.js").PremiseRecord | undefined, import("../shared/interfaces/database.entities.js").PremiseRecord | import("@langchain/langgraph").OverwriteValue<import("../shared/interfaces/database.entities.js").PremiseRecord | undefined> | undefined, unknown>;
         duplicateOf: import("@langchain/langgraph").BaseChannel<{
             premiseId: string;
             assertionText: string;
@@ -205,15 +218,15 @@ export declare class PremiseGraphFactory {
         }[]>, unknown>;
         error: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
         readResult: import("@langchain/langgraph").BaseChannel<{
-            premises: import("../shared/interfaces/database.interface.js").PremiseRecord[];
+            premises: import("../shared/interfaces/database.entities.js").PremiseRecord[];
             count: number;
             message?: string;
         } | undefined, {
-            premises: import("../shared/interfaces/database.interface.js").PremiseRecord[];
+            premises: import("../shared/interfaces/database.entities.js").PremiseRecord[];
             count: number;
             message?: string;
         } | import("@langchain/langgraph").OverwriteValue<{
-            premises: import("../shared/interfaces/database.interface.js").PremiseRecord[];
+            premises: import("../shared/interfaces/database.entities.js").PremiseRecord[];
             count: number;
             message?: string;
         } | undefined> | undefined, unknown>;
@@ -221,7 +234,7 @@ export declare class PremiseGraphFactory {
     }, import("@langchain/langgraph").StateDefinition, {
         query: {
             readResult: {
-                premises: import("../shared/interfaces/database.interface.js").PremiseRecord[];
+                premises: import("../shared/interfaces/database.entities.js").PremiseRecord[];
                 count: number;
             };
         };
@@ -260,7 +273,7 @@ export declare class PremiseGraphFactory {
             error: string;
             premise?: undefined;
         } | {
-            premise: import("../shared/interfaces/database.interface.js").PremiseRecord;
+            premise: import("../shared/interfaces/database.entities.js").PremiseRecord;
             error?: undefined;
         };
         index: {
@@ -275,3 +288,58 @@ export declare class PremiseGraphFactory {
         };
     }, unknown, unknown, []>;
 }
+export declare function queryNode(state: PremiseState, deps: PremiseGraphDeps): Promise<{
+    readResult: {
+        premises: import("../shared/interfaces/database.entities.js").PremiseRecord[];
+        count: number;
+    };
+}>;
+export declare function analyzeNode(state: PremiseState, deps: PremiseGraphDeps): Promise<{
+    error: string;
+    analysis?: undefined;
+    agentTimings?: undefined;
+} | {
+    analysis: PremiseAnalysis;
+    agentTimings: DebugMetaAgent[];
+    error?: undefined;
+}>;
+export declare function embedNode(state: PremiseState, deps: PremiseGraphDeps): Promise<{
+    error?: undefined;
+    embedding?: undefined;
+} | {
+    error: string;
+    embedding?: undefined;
+} | {
+    embedding: number[];
+    error?: undefined;
+}>;
+export declare function dedupeNode(state: PremiseState, deps: PremiseGraphDeps): Promise<{
+    duplicateOf?: undefined;
+} | {
+    duplicateOf: {
+        premiseId: string;
+        assertionText: string;
+        similarity: number;
+    };
+}>;
+export declare function persistNode(state: PremiseState, deps: PremiseGraphDeps): Promise<{
+    error?: undefined;
+    premise?: undefined;
+} | {
+    error: string;
+    premise?: undefined;
+} | {
+    premise: import("../shared/interfaces/database.entities.js").PremiseRecord;
+    error?: undefined;
+}>;
+export declare function indexNode(state: PremiseState, deps: PremiseGraphDeps): Promise<{
+    networkAssignments?: undefined;
+    agentTimings?: undefined;
+} | {
+    networkAssignments: {
+        networkId: string;
+        relevancyScore: number;
+    }[];
+    agentTimings: DebugMetaAgent[];
+}>;
+export declare function routeByMode(state: PremiseState): "query" | "end" | "analyze";

package/dist/premises/premise.graph.js

@@ -43,10 +43,7 @@ function deriveProvenanceConfidence(analysis) {
  */
 export class PremiseGraphFactory {
     constructor(database, embedder, premiseIndexer = new PremiseIndexer(), premiseAnalyzer = new PremiseAnalyzer()) {
-        this.database = database;
-        this.embedder = embedder;
-        this.premiseIndexer = premiseIndexer;
-        this.premiseAnalyzer = premiseAnalyzer;
+        this.deps = { database, embedder, premiseIndexer, premiseAnalyzer };
     }
     /**
      * Compiles and returns the premise lifecycle graph.
@@ -54,221 +51,14 @@ export class PremiseGraphFactory {
      * @returns A compiled LangGraph graph handling create, update, and query modes.
      */
     createGraph() {
-        const analyzer = this.premiseAnalyzer;
-        const indexer = this.premiseIndexer;
-        const queryNode = async (state) => {
-            return timed("PremiseGraph.query", async () => {
-                queryLog.verbose('Fetching premises for user', { userId: state.userId });
-                const premises = await this.database.getPremisesForUser(state.userId, 'ACTIVE');
-                return {
-                    readResult: {
-                        premises,
-                        count: premises.length,
-                    },
-                };
-            });
-        };
-        const analyzeNode = async (state) => {
-            return timed("PremiseGraph.analyze", async () => {
-                if (!state.assertionText) {
-                    return { error: "assertionText is required for create/update mode" };
-                }
-                analyzeLog.verbose('Analyzing assertion text', { preview: state.assertionText.substring(0, 50) });
-                const start = Date.now();
-                const result = await analyzer.invoke(state.assertionText);
-                const timing = {
-                    name: "premise-analyzer",
-                    durationMs: Date.now() - start,
-                };
-                const analysis = {
-                    speechActType: result.speechActType,
-                    felicityAuthority: result.felicityAuthority,
-                    felicitySincerity: result.felicitySincerity,
-                    felicityClarity: result.felicityClarity,
-                    semanticEntropy: result.semanticEntropy,
-                };
-                return { analysis, agentTimings: [timing] };
-            });
-        };
-        const embedNode = async (state) => {
-            return timed("PremiseGraph.embed", async () => {
-                if (state.error)
-                    return {};
-                if (!state.assertionText) {
-                    return { error: "assertionText is required for embedding" };
-                }
-                embedLog.verbose(`Generating embedding for premise`);
-                // Embedder.generate returns number[] | number[][], cast for single string input
-                const embedding = await this.embedder.generate(state.assertionText, undefined, getAbortSignalConfig());
-                return { embedding };
-            });
-        };
-        // ─────────────────────────────────────────────────────────
-        // NODE: Dedupe (create mode only)
-        // Skips persisting a near-duplicate of an existing ACTIVE premise for the same
-        // user. Re-running similar input (e.g. repeated enrichment) therefore does not
-        // accumulate near-identical premises. No-op for update mode, when no embedding
-        // is available, or when the adapter does not implement findSimilarActivePremise.
-        // ─────────────────────────────────────────────────────────
-        const dedupeNode = async (state) => {
-            return timed("PremiseGraph.dedupe", async () => {
-                if (state.error)
-                    return {};
-                if (state.operationMode === 'update')
-                    return {};
-                if (!state.embedding || state.embedding.length === 0)
-                    return {};
-                if (typeof this.database.findSimilarActivePremise !== 'function')
-                    return {};
-                const match = await this.database.findSimilarActivePremise({
-                    userId: state.userId,
-                    embedding: state.embedding,
-                    threshold: DEDUP_SIMILARITY_THRESHOLD,
-                });
-                if (match) {
-                    dedupeLog.verbose('Skipping near-duplicate premise', {
-                        similarity: Number(match.similarity.toFixed(3)),
-                        threshold: DEDUP_SIMILARITY_THRESHOLD,
-                        premiseId: match.premiseId,
-                    });
-                    return { duplicateOf: match };
-                }
-                return {};
-            });
-        };
-        const persistNode = async (state) => {
-            return timed("PremiseGraph.persist", async () => {
-                if (state.error)
-                    return {};
-                if (state.operationMode === 'update' && !state.targetPremiseId) {
-                    return { error: "targetPremiseId is required for update mode" };
-                }
-                if (state.operationMode === 'update' && state.targetPremiseId) {
-                    persistLog.verbose('Updating premise', { premiseId: state.targetPremiseId });
-                    const updated = await this.database.updatePremise(state.targetPremiseId, {
-                        assertion: {
-                            text: state.assertionText,
-                            tier: state.tier,
-                        },
-                        analysis: state.analysis ?? undefined,
-                        validity: {
-                            validFrom: state.validFrom,
-                            validUntil: state.validUntil,
-                            volatile: state.volatile,
-                        },
-                        embedding: state.embedding,
-                    });
-                    return { premise: updated };
-                }
-                persistLog.verbose('Creating new premise for user', { userId: state.userId });
-                // Provenance confidence: prefer an explicit caller-supplied value; otherwise
-                // derive it from the analyzer's felicity scores (how authoritative, sincere,
-                // and clear the assertion is) rather than a blanket 1.0, so the stored
-                // provenance reflects per-premise signal quality.
-                const derivedConfidence = deriveProvenanceConfidence(state.analysis);
-                const premise = await this.database.createPremise({
-                    userId: state.userId,
-                    assertion: {
-                        text: state.assertionText,
-                        tier: state.tier,
-                    },
-                    provenance: {
-                        source: state.provenanceSource ?? 'explicit',
-                        sourceId: state.provenanceSourceId,
-                        confidence: state.provenanceConfidence ?? derivedConfidence,
-                        timestamp: new Date().toISOString(),
-                    },
-                    analysis: state.analysis ?? undefined,
-                    validity: {
-                        validFrom: state.validFrom,
-                        validUntil: state.validUntil,
-                        volatile: state.volatile,
-                    },
-                    embedding: state.embedding,
-                });
-                return { premise };
-            });
-        };
-        const indexNode = async (state) => {
-            return timed("PremiseGraph.index", async () => {
-                if (!state.premise)
-                    return {};
-                indexLog.verbose(`Scoring premise against user networks`);
-                const assignmentMemberships = await this.database.getAssignmentNetworkMembershipsForUser(state.userId);
-                const requestScope = state.scopeType && state.scopeId
-                    ? { scopeType: state.scopeType, scopeId: state.scopeId }
-                    : scopeFromNetworkId(state.networkScopeId);
-                const indexIds = resolveAssignmentNetworkScope({
-                    memberships: assignmentMemberships,
-                    ...requestScope,
-                });
-                const scope = requestScope.scopeType ? "network" : "global";
-                const assignments = [];
-                const agentTimings = [];
-                for (const networkId of indexIds) {
-                    try {
-                        const assignmentContext = await this.database.getNetworkAssignmentContext(networkId, state.userId);
-                        if (!assignmentContext)
-                            continue;
-                        const indexPrompt = assignmentContext.indexPrompt;
-                        const memberPrompt = assignmentContext.memberPrompt;
-                        const hasPrompts = !!indexPrompt?.trim() || !!memberPrompt?.trim();
-                        let rawScores;
-                        let reason;
-                        if (hasPrompts) {
-                            const start = Date.now();
-                            const result = await indexer.invoke({
-                                premiseText: state.assertionText,
-                                indexPrompt: indexPrompt ?? "",
-                                memberPrompt: memberPrompt ?? undefined,
-                            });
-                            const timing = {
-                                name: "premise-indexer",
-                                durationMs: Date.now() - start,
-                            };
-                            rawScores = { indexScore: result.indexScore, memberScore: result.memberScore };
-                            reason = result.reasoning;
-                            agentTimings.push(timing);
-                        }
-                        const decision = buildNetworkAssignmentDecision({
-                            resourceType: "premise",
-                            mode: "automatic",
-                            scope,
-                            indexPrompt,
-                            memberPrompt,
-                            rawScores,
-                            evaluator: "premise-indexer",
-                            source: "premise-graph",
-                            reason,
-                            createdAt: new Date().toISOString(),
-                        });
-                        if (decision.assigned) {
-                            await this.database.assignPremiseToNetwork(state.premise.id, networkId, decision.finalScore, decision.metadata);
-                            assignments.push({ networkId, relevancyScore: decision.finalScore });
-                        }
-                    }
-                    catch (err) {
-                        indexLog.verbose('Failed to score network, skipping', { networkId, error: err });
-                    }
-                }
-                indexLog.verbose('Assigned to networks', { count: assignments.length });
-                return { networkAssignments: assignments, agentTimings };
-            });
-        };
-        const routeByMode = (state) => {
-            if (state.error)
-                return "end";
-            if (state.operationMode === 'query')
-                return "query";
-            return "analyze";
-        };
+        const deps = this.deps;
         const graph = new StateGraph(PremiseGraphState)
-            .addNode("query", queryNode)
-            .addNode("analyze", analyzeNode)
-            .addNode("embed", embedNode)
-            .addNode("dedupe", dedupeNode)
-            .addNode("persist", persistNode)
-            .addNode("index", indexNode)
+            .addNode("query", (state) => queryNode(state, deps))
+            .addNode("analyze", (state) => analyzeNode(state, deps))
+            .addNode("embed", (state) => embedNode(state, deps))
+            .addNode("dedupe", (state) => dedupeNode(state, deps))
+            .addNode("persist", (state) => persistNode(state, deps))
+            .addNode("index", (state) => indexNode(state, deps))
             .addConditionalEdges(START, routeByMode, {
             query: "query",
             analyze: "analyze",
@@ -287,3 +77,202 @@ export class PremiseGraphFactory {
         return graph.compile();
     }
 }
+export async function queryNode(state, deps) {
+    return timed("PremiseGraph.query", async () => {
+        queryLog.verbose('Fetching premises for user', { userId: state.userId });
+        const premises = await deps.database.getPremisesForUser(state.userId, 'ACTIVE');
+        return {
+            readResult: {
+                premises,
+                count: premises.length,
+            },
+        };
+    });
+}
+export async function analyzeNode(state, deps) {
+    return timed("PremiseGraph.analyze", async () => {
+        if (!state.assertionText) {
+            return { error: "assertionText is required for create/update mode" };
+        }
+        analyzeLog.verbose('Analyzing assertion text', { preview: state.assertionText.substring(0, 50) });
+        const start = Date.now();
+        const result = await deps.premiseAnalyzer.invoke(state.assertionText);
+        const timing = {
+            name: "premise-analyzer",
+            durationMs: Date.now() - start,
+        };
+        const analysis = {
+            speechActType: result.speechActType,
+            felicityAuthority: result.felicityAuthority,
+            felicitySincerity: result.felicitySincerity,
+            felicityClarity: result.felicityClarity,
+            semanticEntropy: result.semanticEntropy,
+        };
+        return { analysis, agentTimings: [timing] };
+    });
+}
+export async function embedNode(state, deps) {
+    return timed("PremiseGraph.embed", async () => {
+        if (state.error)
+            return {};
+        if (!state.assertionText) {
+            return { error: "assertionText is required for embedding" };
+        }
+        embedLog.verbose(`Generating embedding for premise`);
+        // Embedder.generate returns number[] | number[][], cast for single string input
+        const embedding = await deps.embedder.generate(state.assertionText, undefined, getAbortSignalConfig());
+        return { embedding };
+    });
+}
+export async function dedupeNode(state, deps) {
+    return timed("PremiseGraph.dedupe", async () => {
+        if (state.error)
+            return {};
+        if (state.operationMode === 'update')
+            return {};
+        if (!state.embedding || state.embedding.length === 0)
+            return {};
+        if (typeof deps.database.findSimilarActivePremise !== 'function')
+            return {};
+        const match = await deps.database.findSimilarActivePremise({
+            userId: state.userId,
+            embedding: state.embedding,
+            threshold: DEDUP_SIMILARITY_THRESHOLD,
+        });
+        if (match) {
+            dedupeLog.verbose('Skipping near-duplicate premise', {
+                similarity: Number(match.similarity.toFixed(3)),
+                threshold: DEDUP_SIMILARITY_THRESHOLD,
+                premiseId: match.premiseId,
+            });
+            return { duplicateOf: match };
+        }
+        return {};
+    });
+}
+export async function persistNode(state, deps) {
+    return timed("PremiseGraph.persist", async () => {
+        if (state.error)
+            return {};
+        if (state.operationMode === 'update' && !state.targetPremiseId) {
+            return { error: "targetPremiseId is required for update mode" };
+        }
+        if (state.operationMode === 'update' && state.targetPremiseId) {
+            persistLog.verbose('Updating premise', { premiseId: state.targetPremiseId });
+            const updated = await deps.database.updatePremise(state.targetPremiseId, {
+                assertion: {
+                    text: state.assertionText,
+                    tier: state.tier,
+                },
+                analysis: state.analysis ?? undefined,
+                validity: {
+                    validFrom: state.validFrom,
+                    validUntil: state.validUntil,
+                    volatile: state.volatile,
+                },
+                embedding: state.embedding,
+            });
+            return { premise: updated };
+        }
+        persistLog.verbose('Creating new premise for user', { userId: state.userId });
+        // Provenance confidence: prefer an explicit caller-supplied value; otherwise
+        // derive it from the deps.premiseAnalyzer's felicity scores (how authoritative, sincere,
+        // and clear the assertion is) rather than a blanket 1.0, so the stored
+        // provenance reflects per-premise signal quality.
+        const derivedConfidence = deriveProvenanceConfidence(state.analysis);
+        const premise = await deps.database.createPremise({
+            userId: state.userId,
+            assertion: {
+                text: state.assertionText,
+                tier: state.tier,
+            },
+            provenance: {
+                source: state.provenanceSource ?? 'explicit',
+                sourceId: state.provenanceSourceId,
+                confidence: state.provenanceConfidence ?? derivedConfidence,
+                timestamp: new Date().toISOString(),
+            },
+            analysis: state.analysis ?? undefined,
+            validity: {
+                validFrom: state.validFrom,
+                validUntil: state.validUntil,
+                volatile: state.volatile,
+            },
+            embedding: state.embedding,
+        });
+        return { premise };
+    });
+}
+export async function indexNode(state, deps) {
+    return timed("PremiseGraph.index", async () => {
+        if (!state.premise)
+            return {};
+        indexLog.verbose(`Scoring premise against user networks`);
+        const assignmentMemberships = await deps.database.getAssignmentNetworkMembershipsForUser(state.userId);
+        const requestScope = state.scopeType && state.scopeId
+            ? { scopeType: state.scopeType, scopeId: state.scopeId }
+            : scopeFromNetworkId(state.networkScopeId);
+        const indexIds = resolveAssignmentNetworkScope({
+            memberships: assignmentMemberships,
+            ...requestScope,
+        });
+        const scope = requestScope.scopeType ? "network" : "global";
+        const assignments = [];
+        const agentTimings = [];
+        for (const networkId of indexIds) {
+            try {
+                const assignmentContext = await deps.database.getNetworkAssignmentContext(networkId, state.userId);
+                if (!assignmentContext)
+                    continue;
+                const indexPrompt = assignmentContext.indexPrompt;
+                const memberPrompt = assignmentContext.memberPrompt;
+                const hasPrompts = !!indexPrompt?.trim() || !!memberPrompt?.trim();
+                let rawScores;
+                let reason;
+                if (hasPrompts) {
+                    const start = Date.now();
+                    const result = await deps.premiseIndexer.invoke({
+                        premiseText: state.assertionText,
+                        indexPrompt: indexPrompt ?? "",
+                        memberPrompt: memberPrompt ?? undefined,
+                    });
+                    const timing = {
+                        name: "premise-indexer",
+                        durationMs: Date.now() - start,
+                    };
+                    rawScores = { indexScore: result.indexScore, memberScore: result.memberScore };
+                    reason = result.reasoning;
+                    agentTimings.push(timing);
+                }
+                const decision = buildNetworkAssignmentDecision({
+                    resourceType: "premise",
+                    mode: "automatic",
+                    scope,
+                    indexPrompt,
+                    memberPrompt,
+                    rawScores,
+                    evaluator: "premise-indexer",
+                    source: "premise-graph",
+                    reason,
+                    createdAt: new Date().toISOString(),
+                });
+                if (decision.assigned) {
+                    await deps.database.assignPremiseToNetwork(state.premise.id, networkId, decision.finalScore, decision.metadata);
+                    assignments.push({ networkId, relevancyScore: decision.finalScore });
+                }
+            }
+            catch (err) {
+                indexLog.verbose('Failed to score network, skipping', { networkId, error: err });
+            }
+        }
+        indexLog.verbose('Assigned to networks', { count: assignments.length });
+        return { networkAssignments: assignments, agentTimings };
+    });
+}
+export function routeByMode(state) {
+    if (state.error)
+        return "end";
+    if (state.operationMode === 'query')
+        return "query";
+    return "analyze";
+}