@indexnetwork/protocol 6.12.1-rc.404.1 → 6.14.0-rc.406.1

package/dist/signals/application/intent.verifier.d.ts

@@ -0,0 +1,115 @@
+import { z } from "zod";
+declare const referentialBreadthSchema: z.ZodEnum<["narrow", "moderate", "broad"]>;
+declare const missingSelectionalConstraintSchema: z.ZodEnum<["role", "outcome", "location", "timeframe", "domain", "concrete_need"]>;
+declare const responseFormat: z.ZodObject<{
+    reasoning: z.ZodString;
+    classification: z.ZodEnum<["COMMISSIVE", "DIRECTIVE", "ASSERTIVE", "EXPRESSIVE", "DECLARATION", "UNKNOWN"]>;
+    felicity_scores: z.ZodObject<{
+        clarity: z.ZodNumber;
+        authority: z.ZodNumber;
+        sincerity: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        sincerity: number;
+        clarity: number;
+        authority: number;
+    }, {
+        sincerity: number;
+        clarity: number;
+        authority: number;
+    }>;
+    semantic_entropy: z.ZodNumber;
+    referential_anchor: z.ZodNullable<z.ZodString>;
+    referential_breadth: z.ZodEnum<["narrow", "moderate", "broad"]>;
+    missing_selectional_constraints: z.ZodArray<z.ZodEnum<["role", "outcome", "location", "timeframe", "domain", "concrete_need"]>, "many">;
+    specificity_warning: z.ZodNullable<z.ZodString>;
+    flags: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    reasoning: string;
+    classification: "COMMISSIVE" | "DIRECTIVE" | "ASSERTIVE" | "EXPRESSIVE" | "DECLARATION" | "UNKNOWN";
+    felicity_scores: {
+        sincerity: number;
+        clarity: number;
+        authority: number;
+    };
+    semantic_entropy: number;
+    referential_anchor: string | null;
+    referential_breadth: "narrow" | "moderate" | "broad";
+    missing_selectional_constraints: ("location" | "role" | "outcome" | "timeframe" | "domain" | "concrete_need")[];
+    specificity_warning: string | null;
+    flags: string[];
+}, {
+    reasoning: string;
+    classification: "COMMISSIVE" | "DIRECTIVE" | "ASSERTIVE" | "EXPRESSIVE" | "DECLARATION" | "UNKNOWN";
+    felicity_scores: {
+        sincerity: number;
+        clarity: number;
+        authority: number;
+    };
+    semantic_entropy: number;
+    referential_anchor: string | null;
+    referential_breadth: "narrow" | "moderate" | "broad";
+    missing_selectional_constraints: ("location" | "role" | "outcome" | "timeframe" | "domain" | "concrete_need")[];
+    specificity_warning: string | null;
+    flags: string[];
+}>;
+export type ReferentialBreadth = z.infer<typeof referentialBreadthSchema>;
+export type MissingSelectionalConstraint = z.infer<typeof missingSelectionalConstraintSchema>;
+export type SemanticVerifierOutput = z.infer<typeof responseFormat>;
+export declare class SemanticVerifier {
+    private model;
+    constructor();
+    /**
+     * Verifies the semantic validity of an intent.
+     * @param content - The user's raw utterance.
+     * @param context - The User Profile as a JSON string.
+     */
+    invoke(content: string, context: string): Promise<{
+        reasoning: string;
+        classification: "COMMISSIVE" | "DIRECTIVE" | "ASSERTIVE" | "EXPRESSIVE" | "DECLARATION" | "UNKNOWN";
+        felicity_scores: {
+            sincerity: number;
+            clarity: number;
+            authority: number;
+        };
+        semantic_entropy: number;
+        referential_anchor: string | null;
+        referential_breadth: "narrow" | "moderate" | "broad";
+        missing_selectional_constraints: ("location" | "role" | "outcome" | "timeframe" | "domain" | "concrete_need")[];
+        specificity_warning: string | null;
+        flags: string[];
+    }>;
+    /**
+     * Factory method to expose the agent as a LangChain tool.
+     */
+    static asTool(): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+        content: z.ZodString;
+        context: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        context: string;
+        content: string;
+    }, {
+        context: string;
+        content: string;
+    }>, {
+        context: string;
+        content: string;
+    }, {
+        context: string;
+        content: string;
+    }, {
+        reasoning: string;
+        classification: "COMMISSIVE" | "DIRECTIVE" | "ASSERTIVE" | "EXPRESSIVE" | "DECLARATION" | "UNKNOWN";
+        felicity_scores: {
+            sincerity: number;
+            clarity: number;
+            authority: number;
+        };
+        semantic_entropy: number;
+        referential_anchor: string | null;
+        referential_breadth: "narrow" | "moderate" | "broad";
+        missing_selectional_constraints: ("location" | "role" | "outcome" | "timeframe" | "domain" | "concrete_need")[];
+        specificity_warning: string | null;
+        flags: string[];
+    }, unknown, "semantic_verifier">;
+}
+export {};

package/dist/signals/application/intent.verifier.js

@@ -0,0 +1,262 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { HumanMessage, SystemMessage } from "@langchain/core/messages";
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+import { protocolLogger } from "../../shared/observability/protocol.logger.js";
+import { Timed } from "../../shared/observability/performance.js";
+import { createStructuredModel } from "../../shared/agent/model.config.js";
+import { invokeWithAbortSignal } from "../../shared/agent/model-signal.js";
+const logger = protocolLogger("SemanticVerifier");
+const invokeLog = protocolLogger("SemanticVerifier:invoke");
+const referentialBreadthSchema = z.enum(["narrow", "moderate", "broad"]);
+const missingSelectionalConstraintSchema = z.enum([
+    "role",
+    "outcome",
+    "location",
+    "timeframe",
+    "domain",
+    "concrete_need",
+]);
+// ──────────────────────────────────────────────────────────────
+// 1. SYSTEM PROMPT
+// ──────────────────────────────────────────────────────────────
+const systemPrompt = `
+You are the Semantic Verification Engine for the Index Network — an intent-driven discovery protocol.
+
+Your job: classify a user utterance using Searle's Speech Act Theory, then score its felicity conditions.
+
+Always reason before classifying. Output reasoning first.
+
+═══════════════════════════════════════════════════
+STEP 1 — CLASSIFY THE ILLOCUTIONARY ACT
+═══════════════════════════════════════════════════
+
+Work through this decision tree in order. Stop at the first matching branch.
+
+IF the utterance cancels, terminates, or declares a state change (e.g., "I quit", "Project cancelled", "This position is closed"):
+  → DECLARATION
+
+ELSE IF the utterance expresses a search, need, or request for another party — even without an explicit verb or first-person subject:
+  → DIRECTIVE
+
+  DIRECTIVE trigger patterns (any of these → DIRECTIVE):
+  · "Looking for [X]"          · "Seeking [X]"
+  · "In search of [X]"         · "Need a [X]"
+  · "Want to find [X]"         · "Interested in connecting with [X]"
+  · "Open to [X]"              · "Hiring [X]"
+  · "Would love to meet [X]"   · "Anyone know [X]"
+
+  KEY RULE: A verbless gerundive like "Looking for artists for collaboration" IS a DIRECTIVE.
+  The missing first-person subject ("I am") is routinely elided in natural intent language.
+  The illocutionary force is a search directive aimed at the system, not an assertion about reality.
+
+  DIRECTIVE positive examples:
+  · "Looking for artists for collaboration" → DIRECTIVE (elided subject, search intent)
+  · "Seeking a technical co-founder in NYC" → DIRECTIVE
+  · "Need a PyTorch expert for a 3-month contract" → DIRECTIVE
+  · "Open to angel investment opportunities" → DIRECTIVE
+  · "Anyone building in the DeSci space?" → DIRECTIVE
+
+  DIRECTIVE negative examples (do NOT classify these as DIRECTIVE):
+  · "AI is changing the creative industry" → ASSERTIVE (states a belief, no search)
+  · "I built a collaboration platform" → ASSERTIVE/COMMISSIVE (past action, no request)
+  · "Collaboration is important" → ASSERTIVE (general belief)
+
+ELSE IF the utterance commits the speaker to a future action:
+  → COMMISSIVE
+
+  COMMISSIVE positive examples:
+  · "I will deploy the contract by Friday" → COMMISSIVE
+  · "I'm going to learn Rust this quarter" → COMMISSIVE
+  · "I commit to mentoring two junior devs" → COMMISSIVE
+
+  COMMISSIVE negative examples (do NOT classify these as COMMISSIVE):
+  · "I could probably look into it" → too hedged; score sincerity low instead
+  · "We should build something cool" → vague, no personal commitment
+
+ELSE IF the utterance states a fact, belief, or opinion with no implied request or commitment:
+  → ASSERTIVE
+
+  ASSERTIVE positive examples:
+  · "Rust is faster than C++" → ASSERTIVE
+  · "I have 10 years of experience in ML" → ASSERTIVE (profile statement, not a request)
+  · "The crypto market is volatile" → ASSERTIVE
+
+ELSE IF the utterance expresses a psychological state or social ritual:
+  → EXPRESSIVE
+
+  EXPRESSIVE examples: "I'm so excited!", "Hello everyone", "Congrats to the team"
+
+If none of the above apply cleanly:
+  → UNKNOWN
+
+═══════════════════════════════════════════════════
+STEP 2 — SCORE THE FELICITY CONDITIONS (0–100)
+═══════════════════════════════════════════════════
+
+Score AFTER classification. Do not let scores influence the category decision.
+
+CLARITY (Essential Condition)
+  How unambiguous and actionable is the utterance?
+  100 → "Deploy the Solidity contract to Mainnet by March 15"
+   60 → "Looking for a developer" (clear direction, vague spec)
+   20 → "We should do something cool"
+
+AUTHORITY (Preparatory Condition)
+  Does the speaker's profile support this act?
+  Compare stated skills/role against the action or search domain.
+  100 → Profile: Senior ML Engineer | Utterance: "Seeking a research collaborator on transformers"
+   20 → Profile: Junior Marketer | Utterance: "I will rewrite the Rust compiler"
+  For DIRECTIVEs: authority = plausibility that this person would make this search.
+
+SINCERITY (Sincerity Condition)
+  Does the linguistic form imply genuine commitment or genuine need?
+  For COMMISSIVEs: check modality (will > going to > might > could).
+  For DIRECTIVEs: check specificity of the search (specific need > vague wish).
+  100 → "I need a Rails contractor starting next week, $150/hr, remote"
+   40 → "I could maybe try to find someone"
+
+SEMANTIC ENTROPY (Constraint Density) → semantic_entropy field, range 0.0–1.0
+  0.0 = maximally constrained (time, location, tech stack, quantifiers all present)
+  1.0 = no constraints at all
+  0.0 example: "Meet 50 senior React devs in SF by Friday"
+  1.0 example: "Network"
+
+REFERENTIAL ANCHOR → referential_anchor field
+  Does the utterance name a specific unique entity (Donnellan referential use)?
+  If YES → output the entity name string.
+  If NO (attributive reference to any member of a class) → output null.
+  "I want to join Google" → "Google"
+  "I want to join a startup" → null
+
+REFERENTIAL BREADTH → referential_breadth field
+  Estimate the extension size of the open candidate class: how many people could plausibly satisfy the description.
+  This is NOT the same as semantic_entropy. Semantic entropy measures underspecification/constraint density;
+  referential breadth measures whether the attributive description narrows the satisfier class enough for discovery.
+
+  narrow   → a small satisfier class due to concrete role/outcome/location/timeframe/specific need.
+             Example: "Find a robotics founder in Healdsburg this week to test my meditation hardware prototype"
+  moderate → a bounded professional/community class, but some constraints are still missing.
+             Example: "Meet AI safety researchers working on evals in London"
+  broad    → a large satisfier class; many people could plausibly match even if topical constraints are present.
+             Example: "Meet creative people, builders, and makers interested in AI, meditation, and tech exploration"
+
+MISSING SELECTIONAL CONSTRAINTS → missing_selectional_constraints field
+  Report the constraints whose absence keeps the candidate class too broad:
+  role, outcome, location, timeframe, domain, concrete_need.
+
+SPECIFICITY WARNING → specificity_warning field
+  If referential_breadth is broad, provide a concise user-facing warning asking for a more concrete role,
+  outcome, location, timeframe, domain, or need. Otherwise output null.
+
+═══════════════════════════════════════════════════
+STEP 3 — FLAGS
+═══════════════════════════════════════════════════
+
+Add flags when scores fall below threshold:
+  authority < 70  → "SKILL_MISMATCH"
+  sincerity < 70  → "WEAK_COMMITMENT"
+  clarity < 50    → "VAGUE_INTENT"
+  classification is ASSERTIVE or EXPRESSIVE → "NOISE"
+  referential_breadth is broad → "BROAD_ATTRIBUTIVE_REFERENCE"
+`;
+// ──────────────────────────────────────────────────────────────
+// 2. RESPONSE SCHEMA (Zod)
+// ──────────────────────────────────────────────────────────────
+const responseFormat = z.object({
+    // reasoning comes first so the model commits to its analysis
+    // before the classification token is generated (chain-of-thought anchor)
+    reasoning: z.string().describe("Step-by-step analysis: (1) which decision-tree branch fired and why, " +
+        "(2) key surface features of the utterance (trigger keywords, elided subject, modality), " +
+        "(3) felicity condition assessment."),
+    classification: z.enum([
+        "COMMISSIVE",
+        "DIRECTIVE",
+        "ASSERTIVE",
+        "EXPRESSIVE",
+        "DECLARATION",
+        "UNKNOWN"
+    ]).describe("Searle's Speech Act category — determined by the decision tree in STEP 1"),
+    felicity_scores: z.object({
+        clarity: z.number().min(0).max(100).describe("Essential Condition: how unambiguous and actionable is the utterance (0–100)"),
+        authority: z.number().min(0).max(100).describe("Preparatory Condition: does the speaker's profile support this act (0–100)"),
+        sincerity: z.number().min(0).max(100).describe("Sincerity Condition: does the linguistic form imply genuine commitment or need (0–100)"),
+    }),
+    semantic_entropy: z.number().min(0).max(1).describe("Constraint density: 0.0 = maximally specific (time + location + tech + quantifiers), 1.0 = completely unconstrained"),
+    referential_anchor: z.string().nullable().describe("Named specific entity the utterance refers to (Donnellan referential), or null for attributive reference"),
+    referential_breadth: referentialBreadthSchema.describe("Extension size of the open candidate class: narrow, moderate, or broad. Distinct from semantic entropy."),
+    missing_selectional_constraints: z.array(missingSelectionalConstraintSchema).describe("Selectional constraints whose absence leaves the satisfier class too broad."),
+    specificity_warning: z.string().nullable().describe("Concise user-facing warning when referential_breadth is broad; otherwise null."),
+    flags: z.array(z.string()).describe("Semantic violation tags: SKILL_MISMATCH (authority<70), WEAK_COMMITMENT (sincerity<70), VAGUE_INTENT (clarity<50), NOISE (ASSERTIVE or EXPRESSIVE), BROAD_ATTRIBUTIVE_REFERENCE (referential_breadth=broad)"),
+});
+// ──────────────────────────────────────────────────────────────
+// 4. CLASS DEFINITION
+// ──────────────────────────────────────────────────────────────
+export class SemanticVerifier {
+    constructor() {
+        this.model = createStructuredModel("intentVerifier", responseFormat, {
+            name: "semantic_verifier"
+        });
+    }
+    /**
+     * Verifies the semantic validity of an intent.
+     * @param content - The user's raw utterance.
+     * @param context - The User Profile as a JSON string.
+     */
+    async invoke(content, context) {
+        invokeLog.verbose('Verifying content', { preview: content.substring(0, 30) });
+        const prompt = `
+      # User Profile (Context)
+      ${context}
+
+      # User Utterance (Content)
+      "${content}"
+
+      Verify the Felicity Conditions and Semantic Metrics for this utterance.
+    `;
+        const messages = [
+            new SystemMessage(systemPrompt),
+            new HumanMessage(prompt)
+        ];
+        try {
+            const result = await invokeWithAbortSignal(this.model, messages);
+            const output = responseFormat.parse(result);
+            invokeLog.verbose('Verdict computed', { classification: output.classification, semanticEntropy: output.semantic_entropy });
+            return output;
+        }
+        catch (error) {
+            logger.error("Error during invocation", { error });
+            throw error;
+        }
+    }
+    /**
+     * Factory method to expose the agent as a LangChain tool.
+     */
+    static asTool() {
+        return tool(async (args) => {
+            const agent = new SemanticVerifier();
+            return await agent.invoke(args.content, args.context);
+        }, {
+            name: 'semantic_verifier',
+            description: 'Verifies the semantic validity and felicity conditions of an intent.',
+            schema: z.object({
+                content: z.string().describe('The intent content to verify'),
+                context: z.string().describe('The user profile context')
+            })
+        });
+    }
+}
+__decorate([
+    Timed(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], SemanticVerifier.prototype, "invoke", null);

package/dist/signals/domain/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * signals/domain — pure signal contracts.
+ *
+ * Value types, graph-state shapes, validation-failure enumerations, and
+ * domain constants that define the signals capability's domain language.
+ * No LLM calls, no LangGraph edges, no host-adapter imports.
+ */
+export { type VerifiedIntent, type IntentValidationFailureCategory, type IntentValidationFailure, type ExecutionResult, IntentGraphState, } from "./intent.state.js";
+export { DEFAULT_SPECIFICITY_WARNING } from "./signal.specificity.js";

package/dist/signals/domain/index.js

@@ -0,0 +1,11 @@
+/**
+ * signals/domain — pure signal contracts.
+ *
+ * Value types, graph-state shapes, validation-failure enumerations, and
+ * domain constants that define the signals capability's domain language.
+ * No LLM calls, no LangGraph edges, no host-adapter imports.
+ */
+// ── State and value types ─────────────────────────────────────────────────────
+export { IntentGraphState, } from "./intent.state.js";
+// ── Domain constants ──────────────────────────────────────────────────────────
+export { DEFAULT_SPECIFICITY_WARNING } from "./signal.specificity.js";

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

@@ -0,0 +1,230 @@
+import { BaseMessage } from "@langchain/core/messages";
+import { InferredIntent } from "../../intent/intent.inferrer.js";
+import { SemanticVerifierOutput } from "../../intent/intent.verifier.js";
+import type { DebugMetaAgent } from '../../capabilities/participant-agents.debug.facade.js';
+import type { ToolScopeType } from '../../shared/agent/tool.scope.js';
+/**
+ * Extended InferredIntent that includes verification results.
+ * We attach the verification output directly to the intent object
+ * as it flows through the graph.
+ */
+export type VerifiedIntent = InferredIntent & {
+    verification?: SemanticVerifierOutput;
+    score?: number;
+};
+export type IntentValidationFailureCategory = 'non_actionable' | 'vague_or_invalid' | 'verification_failure' | 'update_target_boundary' | 'reconciliation_boundary';
+export interface IntentValidationFailure {
+    category: IntentValidationFailureCategory;
+    message: string;
+    classification?: string;
+    referentialBreadth?: 'narrow' | 'moderate' | 'broad';
+}
+/**
+ * Result of executing a single reconciler action.
+ */
+export interface ExecutionResult {
+    /** The action type that was executed */
+    actionType: 'create' | 'update' | 'expire';
+    /** Whether the action succeeded */
+    success: boolean;
+    /** The intent ID (created/updated/archived) */
+    intentId?: string;
+    /** Final payload (sanitized, for create/update) */
+    payload?: string;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * The Graph State using LangGraph Annotations.
+ * This acts as the central bus for data flowing through our graph.
+ */
+export declare const IntentGraphState: import("@langchain/langgraph").AnnotationRoot<{
+    /**
+     * The unique identifier of the user whose intents are being processed.
+     * Required for database operations.
+     */
+    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>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    /**
+     * The user's profile context (Identity, Narrative, etc.)
+     */
+    userProfile: {
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BaseChannel<string, string | import("@langchain/langgraph").OverwriteValue<string>, unknown>;
+        (): import("@langchain/langgraph").LastValue<string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    /**
+     * Explicit input content (e.g., user message).
+     * Optional - graph might run on implicit only.
+     */
+    inputContent: {
+        (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
+        (): import("@langchain/langgraph").LastValue<string | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    /**
+     * Conversation history for context-aware intent inference.
+     * Used to resolve anaphoric references ("that intent", "this goal").
+     * Limited to recent messages (typically last 10) for token efficiency.
+     * Optional - if not provided, intent inference uses only inputContent.
+     */
+    conversationContext: import("@langchain/langgraph").BaseChannel<BaseMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>, import("@langchain/core/messages").MessageType>[] | undefined, BaseMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>, import("@langchain/core/messages").MessageType>[] | import("@langchain/langgraph").OverwriteValue<BaseMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>, import("@langchain/core/messages").MessageType>[] | undefined> | undefined, unknown>;
+    /**
+     * Operation mode controls graph flow and determines which nodes execute.
+     * - 'create': Full pipeline (prep → inference → verification → reconciliation → execution)
+     * - 'update': Skip verification if no new intents (prep → inference → reconciliation → execution)
+     * - 'delete': Skip inference and verification (prep → reconciliation → execution)
+     * - 'read': Fast path (prep → queryNode → END) — reads intents without LLM calls
+     * - 'propose': Inference + verification only, stops before reconciliation (no DB writes)
+     *
+     * Defaults to 'create' for backward compatibility.
+     */
+    operationMode: import("@langchain/langgraph").BaseChannel<"delete" | "propose" | "update" | "create" | "read", "delete" | "propose" | "update" | "create" | "read" | import("@langchain/langgraph").OverwriteValue<"delete" | "propose" | "update" | "create" | "read">, unknown>;
+    /**
+     * For update/delete operations, specifies which intent IDs to target.
+     * Optional - used when modifying or removing specific intents.
+     */
+    targetIntentIds: import("@langchain/langgraph").BaseChannel<string[] | undefined, string[] | import("@langchain/langgraph").OverwriteValue<string[] | undefined> | undefined, unknown>;
+    /**
+     * Optional material compare-and-set guard used only by recovery-answer
+     * updates. The database rechecks it while holding the final intent row lock.
+     */
+    expectedIntentFingerprint: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
+    /**
+     * Optional network scope (network ID). Used for linking created intents to a network
+     * and for scoping read operations. Prep always fetches ALL user intents via
+     * getActiveIntents(userId) regardless of network scope (for global dedup/reconciliation).
+     */
+    networkId: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
+    /** Focused request scope type for write-side assignment and follow-up queues. */
+    scopeType: import("@langchain/langgraph").BaseChannel<ToolScopeType | undefined, ToolScopeType | import("@langchain/langgraph").OverwriteValue<ToolScopeType | undefined> | undefined, unknown>;
+    /** Focused request scope id. When scopeType is `network`, this is the focused network id. */
+    scopeId: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
+    /**
+     * The formatted string of currently active intents.
+     * Always populated by prep via getActiveIntents(userId).
+     */
+    activeIntents: import("@langchain/langgraph").BaseChannel<string, string | import("@langchain/langgraph").OverwriteValue<string>, unknown>;
+    /** IDs of active intents owned by the graph user, used to fail closed on explicit updates. */
+    activeIntentIds: import("@langchain/langgraph").BaseChannel<string[], string[] | import("@langchain/langgraph").OverwriteValue<string[]>, unknown>;
+    /**
+     * List of raw intents extracted from text.
+     */
+    inferredIntents: import("@langchain/langgraph").BaseChannel<{
+        reasoning: string;
+        type: "goal" | "tombstone";
+        confidence: "low" | "medium" | "high";
+        description: string;
+    }[], {
+        reasoning: string;
+        type: "goal" | "tombstone";
+        confidence: "low" | "medium" | "high";
+        description: string;
+    }[] | import("@langchain/langgraph").OverwriteValue<{
+        reasoning: string;
+        type: "goal" | "tombstone";
+        confidence: "low" | "medium" | "high";
+        description: string;
+    }[]>, unknown>;
+    /**
+     * List of intents that have passed semantic verification.
+     * Invalid intents are filtered out before reaching this state.
+     */
+    verifiedIntents: import("@langchain/langgraph").BaseChannel<VerifiedIntent[], VerifiedIntent[] | import("@langchain/langgraph").OverwriteValue<VerifiedIntent[]>, unknown>;
+    /** Structured reasons for candidates rejected before persistence. */
+    validationFailures: import("@langchain/langgraph").BaseChannel<IntentValidationFailure[], IntentValidationFailure[] | import("@langchain/langgraph").OverwriteValue<IntentValidationFailure[]>, unknown>;
+    /**
+     * Final actions to be performed on the DB (Create, Update, Expire).
+     */
+    actions: import("@langchain/langgraph").BaseChannel<import("../application/intent.reconciler.js").NormalizedIntentAction[], import("../application/intent.reconciler.js").NormalizedIntentAction[] | import("@langchain/langgraph").OverwriteValue<import("../application/intent.reconciler.js").NormalizedIntentAction[]>, unknown>;
+    /**
+     * Results of executing actions against the database.
+     * Populated by executorNode after actions are persisted.
+     */
+    executionResults: import("@langchain/langgraph").BaseChannel<ExecutionResult[], ExecutionResult[] | import("@langchain/langgraph").OverwriteValue<ExecutionResult[]>, unknown>;
+    /**
+     * If set, indicates a fatal error that should short-circuit the graph to END.
+     * Populated by prep when a precondition fails (e.g. missing profile).
+     */
+    error: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
+    /**
+     * Accumulated trace entries from each graph node.
+     * Used for observability: surfaces internal processing steps (inference,
+     * verification with Felicity scores, reconciliation) to the frontend.
+     */
+    trace: import("@langchain/langgraph").BaseChannel<{
+        node: string;
+        detail?: string;
+        data?: Record<string, unknown>;
+    }[], {
+        node: string;
+        detail?: string;
+        data?: Record<string, unknown>;
+    }[] | import("@langchain/langgraph").OverwriteValue<{
+        node: string;
+        detail?: string;
+        data?: Record<string, unknown>;
+    }[]>, unknown>;
+    /** Timing records for each agent invocation within this graph run. */
+    agentTimings: import("@langchain/langgraph").BaseChannel<DebugMetaAgent[], DebugMetaAgent[] | import("@langchain/langgraph").OverwriteValue<DebugMetaAgent[]>, unknown>;
+    /**
+     * For read mode: the set of network IDs the caller's agent can reach.
+     * When set and neither networkId nor queryUserId is provided, the graph
+     * returns the caller's own intents across all networks in this set (scope-aware
+     * default path). Derived by the tool layer from the scope envelope plus memberships.
+     */
+    indexScope: import("@langchain/langgraph").BaseChannel<string[] | undefined, string[] | import("@langchain/langgraph").OverwriteValue<string[] | undefined> | undefined, unknown>;
+    /**
+     * For read mode: filter intents by a specific user when reading in a network.
+     * When omitted and network-scoped, returns all intents in the network.
+     */
+    queryUserId: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
+    /**
+     * For read mode: when true, return all of the current user's intents
+     * ignoring network scope. Used before create_intent to detect duplicates.
+     */
+    allUserIntents: import("@langchain/langgraph").BaseChannel<boolean, boolean | import("@langchain/langgraph").OverwriteValue<boolean>, unknown>;
+    /**
+     * Output of read mode: queried intents with count and optional metadata.
+     */
+    readResult: import("@langchain/langgraph").BaseChannel<{
+        count: number;
+        intents: Array<{
+            id: string;
+            description: string;
+            summary: string | null;
+            createdAt: Date;
+            userId?: string;
+            userName?: string | null;
+        }>;
+        message?: string;
+        networkId?: string;
+    } | undefined, {
+        count: number;
+        intents: Array<{
+            id: string;
+            description: string;
+            summary: string | null;
+            createdAt: Date;
+            userId?: string;
+            userName?: string | null;
+        }>;
+        message?: string;
+        networkId?: string;
+    } | import("@langchain/langgraph").OverwriteValue<{
+        count: number;
+        intents: Array<{
+            id: string;
+            description: string;
+            summary: string | null;
+            createdAt: Date;
+            userId?: string;
+            userName?: string | null;
+        }>;
+        message?: string;
+        networkId?: string;
+    } | undefined> | undefined, unknown>;
+}>;