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

package/dist/{intents → internal/intents}/graph/intent.graph.reconcile.d.ts

@@ -2,8 +2,7 @@
  * Intent graph, stages 2-3: verify inferred signals, then reconcile against what exists.
  */
 import { VerifiedIntent, type IntentValidationFailure } from "./intent.graph.state.js";
-import type { NormalizedIntentAction } from "../intent.reconciler.js";
-import type { DebugMetaAgent } from "../../agents/agent.module.js";
+import type { DebugMetaAgent } from "../../../protocol/core.js";
 import { type IntentGraphDeps, type IntentState } from "./intent.graph.shared.js";
 /**
  * Node 2: Verification (Map-Reduce / Parallel)
@@ -28,7 +27,7 @@ export declare function verificationNode(state: IntentState, deps: IntentGraphDe
             sincerity: number;
             entropy: number | undefined;
             referentialBreadth: "narrow" | "moderate" | "broad" | undefined;
-            missingSelectionalConstraints: ("location" | "role" | "outcome" | "timeframe" | "domain" | "concrete_need")[] | undefined;
+            missingSelectionalConstraints: ("location" | "outcome" | "role" | "timeframe" | "domain" | "concrete_need")[] | undefined;
             specificityWarning: string | undefined;
             classification: "COMMISSIVE" | "DIRECTIVE" | "ASSERTIVE" | "EXPRESSIVE" | "DECLARATION" | "UNKNOWN" | undefined;
             score: number | undefined;
@@ -37,10 +36,11 @@ export declare function verificationNode(state: IntentState, deps: IntentGraphDe
 }>;
 /**
  * Node 3: Reconciliation
- * Decides on final actions (Create, Update, Expire).
- * Phase 4: Handles delete operations directly without LLM reconciliation.
+ * Decides on final actions. Archive and transition build their one
+ * deterministic action directly (no LLM). Explicit update binds to its
+ * one target. Creation has its own deterministic preparation route.
  */
-export declare function reconciliationNode(state: IntentState, deps: IntentGraphDeps): Promise<{
+export declare function reconciliationNode(state: IntentState): Promise<{
     actions: {
         type: "expire";
         id: string;
@@ -53,19 +53,28 @@ export declare function reconciliationNode(state: IntentState, deps: IntentGraph
     }[];
     validationFailures?: undefined;
 } | {
-    actions: NormalizedIntentAction[];
-    validationFailures: IntentValidationFailure[];
+    actions: {
+        type: "transition";
+        id: string;
+        status: "ACTIVE" | "PAUSED";
+    }[];
     agentTimings: DebugMetaAgent[];
     trace: {
         node: string;
         detail: string;
     }[];
+    validationFailures?: undefined;
 } | {
-    actions: NormalizedIntentAction[];
+    actions: import("./intent.graph.state.js").IntentGraphAction[];
+    validationFailures: IntentValidationFailure[];
     agentTimings: DebugMetaAgent[];
     trace: {
         node: string;
         detail: string;
     }[];
+} | {
+    actions: never[];
+    agentTimings?: undefined;
+    trace?: undefined;
     validationFailures?: undefined;
 }>;

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

@@ -0,0 +1,173 @@
+/**
+ * Intent graph, stages 2-3: verify inferred signals, then reconcile against what exists.
+ */
+import { admissionFailure } from "../intent.admission.js";
+import { timed } from "../../shared/observability/performance.js";
+import { requestContext } from "../../shared/observability/request-context.js";
+import { buildExplicitUpdateActions, isExplicitUpdateRequest, logger } from "./intent.graph.shared.js";
+/**
+ * Node 2: Verification (Map-Reduce / Parallel)
+ * Verifies each inferred intent in parallel.
+ * Phase 4: Can be skipped for delete operations and updates with no new intents.
+ */
+export async function verificationNode(state, deps) {
+    return timed("IntentGraph.verification", async () => {
+        const intents = state.inferredIntents;
+        const isExplicitUpdate = isExplicitUpdateRequest(state);
+        logger.verbose("Starting verification", {
+            isExplicitUpdate,
+            intentCount: intents.length
+        });
+        if (intents.length === 0) {
+            logger.verbose("No intents to verify");
+            return { verifiedIntents: [], agentTimings: [] };
+        }
+        logger.verbose('Verifying intents in parallel', { count: intents.length });
+        const agentTimingsAccum = [];
+        // Parallel Execution
+        const verificationResults = await Promise.all(intents.map(async (intent) => {
+            try {
+                const description = intent.description;
+                const _traceEmitterVerifier = requestContext.getStore()?.traceEmitter;
+                const verifierStart = Date.now();
+                _traceEmitterVerifier?.({ type: "agent_start", name: "intent-verifier" });
+                const verdict = await deps.verifier.invoke(description, state.userProfile);
+                agentTimingsAccum.push({ name: 'intent.verifier', durationMs: Date.now() - verifierStart });
+                _traceEmitterVerifier?.({ type: "agent_end", name: "intent-verifier", durationMs: Date.now() - verifierStart, summary: `Verified: ${verdict.classification}` });
+                const failure = admissionFailure(description, verdict, isExplicitUpdate);
+                if (failure)
+                    return { failure };
+                // Calculate Score
+                const score = Math.min(verdict.felicity_scores.authority, verdict.felicity_scores.sincerity, verdict.felicity_scores.clarity);
+                // Return enriched intent
+                return {
+                    intent: {
+                        ...intent,
+                        description,
+                        verification: verdict,
+                        score,
+                    },
+                };
+            }
+            catch (e) {
+                logger.error('Error verifying intent', { description: intent.description, error: e });
+                return {
+                    failure: {
+                        category: 'verification_failure',
+                        message: e instanceof Error ? e.message : 'Intent verification failed unexpectedly.',
+                    },
+                };
+            }
+        }));
+        const verified = verificationResults.flatMap((result) => 'intent' in result ? [result.intent] : []);
+        const validationFailures = verificationResults.flatMap((result) => 'failure' in result ? [result.failure] : []);
+        logger.verbose(`Verification complete`, {
+            passed: verified.length,
+            total: intents.length,
+            isExplicitUpdate,
+        });
+        // Build trace entries with Felicity scores for each verified intent
+        const traceEntries = verified.map(v => {
+            const fs = v.verification?.felicity_scores;
+            const entropy = v.verification?.semantic_entropy;
+            const classification = v.verification?.classification;
+            const referentialBreadth = v.verification?.referential_breadth;
+            return {
+                node: "verification",
+                detail: `"${v.description.slice(0, 40)}${v.description.length > 40 ? '...' : ''}" → ${classification}${referentialBreadth ? ` (${referentialBreadth} referential breadth)` : ''}`,
+                data: fs ? {
+                    clarity: fs.clarity,
+                    authority: fs.authority,
+                    sincerity: fs.sincerity,
+                    entropy: entropy != null ? Math.round(entropy * 100) / 100 : undefined,
+                    referentialBreadth,
+                    missingSelectionalConstraints: v.verification?.missing_selectional_constraints,
+                    specificityWarning: v.verification?.specificity_warning ?? undefined,
+                    classification,
+                    score: v.score,
+                } : undefined,
+            };
+        });
+        // Add summary trace if some intents were filtered out
+        const dropped = intents.length - verified.length;
+        if (dropped > 0) {
+            traceEntries.unshift({
+                node: "verification",
+                detail: `Verified ${verified.length}/${intents.length} (${dropped} filtered as invalid)`,
+                data: undefined,
+            });
+        }
+        else if (verified.length > 0) {
+            traceEntries.unshift({
+                node: "verification",
+                detail: `Verified ${verified.length} intent(s)`,
+                data: undefined,
+            });
+        }
+        return { verifiedIntents: verified, validationFailures, agentTimings: agentTimingsAccum, trace: traceEntries };
+    });
+}
+/**
+ * Node 3: Reconciliation
+ * Decides on final actions. Archive and transition build their one
+ * deterministic action directly (no LLM). Explicit update binds to its
+ * one target. Creation has its own deterministic preparation route.
+ */
+export async function reconciliationNode(state) {
+    return timed("IntentGraph.reconciliation", async () => {
+        logger.verbose("Starting reconciliation", {
+            verifiedIntentCount: state.verifiedIntents.length,
+            targetIntentIds: state.targetIntentIds,
+            archive: state.archive,
+            status: state.status,
+        });
+        const agentTimingsAccum = [];
+        if (state.archive) {
+            const actions = (state.targetIntentIds ?? []).map(id => ({
+                type: 'expire',
+                id,
+                reasoning: 'User requested deletion'
+            }));
+            return {
+                actions,
+                agentTimings: agentTimingsAccum,
+                trace: [{ node: "reconciler", detail: `Actions: expire=${actions.length}` }],
+            };
+        }
+        if (state.status !== undefined) {
+            const actions = [{ type: 'transition', id: state.targetIntentIds[0], status: state.status }];
+            return {
+                actions,
+                agentTimings: agentTimingsAccum,
+                trace: [{ node: "reconciler", detail: `Actions: transition=1 (${state.status})` }],
+            };
+        }
+        // Content path: explicit update or bare create.
+        const candidates = state.verifiedIntents;
+        if (candidates.length === 0) {
+            logger.verbose("No verified intents to reconcile");
+            return {
+                actions: [],
+                agentTimings: agentTimingsAccum,
+                trace: [{ node: "reconciler", detail: "No intents to reconcile" }],
+            };
+        }
+        if (isExplicitUpdateRequest(state)) {
+            const explicitUpdate = buildExplicitUpdateActions(state.targetIntentIds, state.activeIntentIds, candidates);
+            return {
+                actions: explicitUpdate.actions,
+                validationFailures: explicitUpdate.failure
+                    ? [...state.validationFailures, explicitUpdate.failure]
+                    : state.validationFailures,
+                agentTimings: agentTimingsAccum,
+                trace: [{
+                        node: 'reconciler',
+                        detail: explicitUpdate.failure
+                            ? `Explicit update rejected: ${explicitUpdate.failure.category}`
+                            : `Explicit update bound to target ${state.targetIntentIds?.[0]}`,
+                    }],
+            };
+        }
+        return { actions: [] };
+    });
+}

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

@@ -0,0 +1,55 @@
+/**
+ * Shared vocabulary for the intent graph's nodes.
+ *
+ * The nodes were closures inside `IntentGraphFactory.createGraph()`; they are
+ * top-level functions now, each taking an explicit {@link IntentGraphDeps}.
+ * This module owns the bag, the logger, and the pure helpers.
+ */
+import { IntentGraphState, VerifiedIntent, type IntentGraphAction, type IntentValidationFailure } from "./intent.graph.state.js";
+import { ExplicitIntentInferrer } from "../intent.inferrer.js";
+import { SemanticVerifier } from "../intent.verifier.js";
+import { IntentPreparer } from "../intent.preparer.js";
+import { IntentGraphDatabase } from "../../../platform/database.js";
+import type { EmbeddingGenerator } from "../../../platform/discovery/embedder.js";
+import type { IntentFollowUp } from "../../../platform/runtime/follow-up.js";
+/** The graph's channel state, as every node sees it. */
+export type IntentState = typeof IntentGraphState.State;
+/** Everything the intent nodes reach for. Composed once by the factory. */
+export interface IntentGraphDeps {
+    database: IntentGraphDatabase;
+    embedder?: EmbeddingGenerator;
+    intentFollowUp?: IntentFollowUp;
+    inferrer: Pick<ExplicitIntentInferrer, 'invoke'>;
+    verifier: Pick<SemanticVerifier, 'invoke'>;
+    preparer: Pick<IntentPreparer, 'invoke'>;
+}
+export declare const logger: import("../../shared/observability/log.js").LoggerWithSource;
+/**
+ * True when the input shape is an explicit update: content plus a target id.
+ * Distinguishes an explicit update from archive/transition/confirm, which also
+ * carry `targetIntentIds` but for a different purpose.
+ */
+export declare function isExplicitUpdateRequest(state: Pick<IntentState, 'inputContent' | 'targetIntentIds'>): boolean;
+/**
+ * Enforce write-mode constraints on reconciler output before any action can
+ * reach persistence. An explicit update is deliberately fail-closed: only an
+ * update whose id is the caller-provided target survives.
+ */
+export declare function enforceIntentActionBoundary(isExplicitUpdate: boolean, targetIntentIds: string[] | undefined, actions: IntentGraphAction[]): IntentGraphAction[];
+/**
+ * Build the only action permitted for an explicit update. This path is
+ * deterministic and cannot redirect an update away from its supplied target.
+ */
+export declare function buildExplicitUpdateActions(targetIntentIds: string[] | undefined, activeIntentIds: string[], candidates: VerifiedIntent[]): {
+    actions: IntentGraphAction[];
+    failure?: IntentValidationFailure;
+};
+export declare const toSpeechActType: (classification?: string) => "COMMISSIVE" | "DIRECTIVE" | null;
+/** Normalize explicit update text; creation preserves the submitted text. */
+export declare function normalizeIntentDescription(description: string): string;
+/**
+ * Generate a flat embedding for an intent payload, swallowing failures so
+ * persistence can continue without an embedding. `intentId` is logging-only
+ * (present for updates, absent for creates).
+ */
+export declare function generateIntentEmbedding(deps: IntentGraphDeps, sanitizedPayload: string, intentId?: string): Promise<number[] | undefined>;

package/dist/{intents → internal/intents}/graph/intent.graph.shared.js

@@ -5,25 +5,31 @@
  * top-level functions now, each taking an explicit {@link IntentGraphDeps}.
  * This module owns the bag, the logger, and the pure helpers.
  */
-import { DEFAULT_SPECIFICITY_WARNING } from "../intent.proposal.js";
 import { getAbortSignalConfig } from "../../shared/agent/model-signal.js";
 import { protocolLogger } from "../../shared/observability/protocol.logger.js";
 export const logger = protocolLogger("IntentGraphFactory");
+/**
+ * True when the input shape is an explicit update: content plus a target id.
+ * Distinguishes an explicit update from archive/transition/confirm, which also
+ * carry `targetIntentIds` but for a different purpose.
+ */
+export function isExplicitUpdateRequest(state) {
+    return state.inputContent !== undefined && !!state.targetIntentIds?.length;
+}
 /**
  * Enforce write-mode constraints on reconciler output before any action can
- * reach persistence. Update mode is deliberately fail-closed: only updates
- * whose id is one of the caller-provided targets survive.
+ * reach persistence. An explicit update is deliberately fail-closed: only an
+ * update whose id is the caller-provided target survives.
  */
-export function enforceIntentActionBoundary(operationMode, targetIntentIds, actions) {
-    if (operationMode !== 'update')
+export function enforceIntentActionBoundary(isExplicitUpdate, targetIntentIds, actions) {
+    if (!isExplicitUpdate)
         return actions;
     const targets = new Set(targetIntentIds ?? []);
     return actions.filter((action) => action.type === 'update' && targets.has(action.id));
 }
 /**
  * Build the only action permitted for an explicit update. This path is
- * intentionally deterministic: semantic reconciliation may shape create
- * operations, but it may not redirect an update away from its supplied target.
+ * deterministic and cannot redirect an update away from its supplied target.
  */
 export function buildExplicitUpdateActions(targetIntentIds, activeIntentIds, candidates) {
     if (targetIntentIds?.length !== 1 || !activeIntentIds.includes(targetIntentIds[0])) {
@@ -56,74 +62,23 @@ export function buildExplicitUpdateActions(targetIntentIds, activeIntentIds, can
             }],
     };
 }
-export const MAX_PERMISSIBLE_ENTROPY = 0.75;
-export const MIN_CLEAR_INTENT_SCORE = 40;
-export const GENERIC_JOB_PHRASE = /\b(?:a|any|some)\s+job\b/i;
-export const inferRoleFromContextText = (text) => {
-    const normalized = text.toLowerCase();
-    if (/\b(engineer|developer)\b/.test(normalized))
-        return "software engineering";
-    if (/\b(designer|ux|ui)\b/.test(normalized))
-        return "product design";
-    if (/\b(marketing|marketer|growth)\b/.test(normalized))
-        return "marketing";
-    if (/\b(product manager|product)\b/.test(normalized))
-        return "product management";
-    if (/\b(data scientist|machine learning|ml|ai)\b/.test(normalized))
-        return "AI/ML";
-    if (/\b(sales|account executive|business development)\b/.test(normalized))
-        return "sales";
-    return null;
-};
-/**
- * Derive a job-role qualifier from the user's global user_context paragraph
- * (the identity text that replaced the legacy profile projection). Role is
- * inferred from the free text; the old structured skills/interests extraction
- * is gone with the removed profile fields.
- */
-export const buildJobQualifierFromContext = (contextText) => {
-    const roleHint = inferRoleFromContextText(contextText ?? "");
-    return roleHint ? `${roleHint} role` : null;
-};
-export const enrichVagueIntentWithContext = (description, userContext) => {
-    const trimmed = description?.trim();
-    if (!trimmed)
-        return description;
-    const isGenericJobRequest = GENERIC_JOB_PHRASE.test(trimmed) ||
-        /\b(?:find|get|look(?:ing)?\s+for|want)\s+(?:to\s+)?(?:find\s+)?job\b/i.test(trimmed);
-    if (!isGenericJobRequest)
-        return description;
-    const qualifier = buildJobQualifierFromContext(userContext);
-    if (!qualifier)
-        return description;
-    const enriched = trimmed
-        .replace(/\ba job\b/i, `a ${qualifier}`)
-        .replace(/\bjob\b/i, `${qualifier}`)
-        .replace(/\s{2,}/g, " ")
-        .trim();
-    return enriched.length > 0 ? enriched : description;
-};
-export const isVague = (description, entropy, clarity) => {
-    if (GENERIC_JOB_PHRASE.test(description))
-        return true;
-    if (entropy > MAX_PERMISSIBLE_ENTROPY)
-        return true;
-    if (clarity < MIN_CLEAR_INTENT_SCORE)
-        return true;
-    return false;
-};
-export const getSpecificityWarning = (verdict) => {
-    const warning = verdict.specificity_warning?.trim();
-    return warning && warning.length > 0 ? warning : DEFAULT_SPECIFICITY_WARNING;
-};
 export const toSpeechActType = (classification) => {
     if (classification === "COMMISSIVE" || classification === "DIRECTIVE")
         return classification;
     return null;
 };
-/**
- * Factory class to build and compile the Intent Processing Graph.
-
+/** Normalize explicit update text; creation preserves the submitted text. */
+export function normalizeIntentDescription(description) {
+    if (!description || typeof description !== "string")
+        return description;
+    const normalized = description
+        .replace(/\s*More details at\s*:?\s*https?:\/\/[^\s"'<>)\]]+/gi, "")
+        .replace(/\s*See\s+https?:\/\/[^\s"'<>)\]]+\s+for\s+more[^.]*\.?/gi, "")
+        .replace(/https?:\/\/[^\s"'<>)\]]+/g, "")
+        .replace(/\s{2,}/g, " ")
+        .trim();
+    return normalized.replace(/[.,;]\s*$/, "").trim() || description;
+}
 /**
  * Generate a flat embedding for an intent payload, swallowing failures so
  * persistence can continue without an embedding. `intentId` is logging-only

package/dist/{intents → internal/intents}/graph/intent.graph.state.d.ts

@@ -1,8 +1,11 @@
 import { BaseMessage } from "@langchain/core/messages";
 import { InferredIntent } from "../intent.inferrer.js";
 import { SemanticVerifierOutput } from "../intent.verifier.js";
-import type { DebugMetaAgent } from '../../agents/agent.module.js';
-import type { ToolScopeType } from '../../shared/agent/tool.scope.js';
+import type { IntentSemanticMetadata } from "../intent.admission.js";
+import type { PreparedIntent, PrepareResult } from "../intent.preparer.js";
+import type { DebugMetaAgent } from "../../../protocol/core.js";
+import type { ScopeType } from '../../shared/agent/scope.js';
+import type { IntentLifecycleStatus } from "../../../platform/database.js";
 /**
  * Extended InferredIntent that includes verification results.
  * We attach the verification output directly to the intent object
@@ -24,16 +27,64 @@ export interface IntentValidationFailure {
  */
 export interface ExecutionResult {
     /** The action type that was executed */
-    actionType: 'create' | 'update' | 'expire';
+    actionType: 'create' | 'update' | 'expire' | 'transition';
     /** 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 message if failed. For transition this is the outcome's `kind`. */
     error?: string;
+    /** Networks the created intent was linked to, for a `create` action. */
+    linkedNetworkIds?: string[];
 }
+/** A deterministic pause/resume action, bypassing the LLM reconciler. */
+export interface TransitionIntentAction {
+    type: 'transition';
+    id: string;
+    status: 'ACTIVE' | 'PAUSED';
+}
+/** Every action kind the executor can carry out. */
+export type IntentGraphAction = {
+    type: 'create';
+    payload: string;
+    metadata: IntentSemanticMetadata | null;
+} | {
+    type: 'update';
+    id: string;
+    payload: string;
+    score: number | null;
+    reasoning: string;
+    intentMode: 'REFERENTIAL' | 'ATTRIBUTIVE';
+} | {
+    type: 'expire';
+    id: string;
+    reasoning: string;
+} | TransitionIntentAction;
+/** Outcome of a `transition` action, mirroring the adapter's discriminated result plus the enqueue-failure compensation case. */
+export type TransitionOutcome = {
+    kind: 'success';
+    id: string;
+    status: 'ACTIVE' | 'PAUSED';
+    changed: boolean;
+    lifecycleVersionMs: number;
+} | {
+    kind: 'not_found';
+} | {
+    kind: 'scope_violation';
+} | {
+    kind: 'stale';
+} | {
+    kind: 'conflict';
+    status: IntentLifecycleStatus | null;
+    archived: boolean;
+} | {
+    kind: 'enqueue_failed';
+    id: string;
+    status: IntentLifecycleStatus;
+    lifecycleVersionMs: number;
+};
 /**
  * The Graph State using LangGraph Annotations.
  * This acts as the central bus for data flowing through our graph.
@@ -58,13 +109,25 @@ export declare const IntentGraphState: import("@langchain/langgraph").Annotation
     };
     /**
      * Explicit input content (e.g., user message).
-     * Optional - graph might run on implicit only.
+     * Omitted for read, archive, and status operations.
      */
     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>;
     };
+    /** Host-authorized preparation, reused without admission. Null metadata means the final text was edited. Never pass client-supplied objects here. */
+    preparation: {
+        (annotation: import("@langchain/langgraph").SingleReducer<PreparedIntent | undefined, PreparedIntent | undefined>): import("@langchain/langgraph").BaseChannel<PreparedIntent | undefined, PreparedIntent | import("@langchain/langgraph").OverwriteValue<PreparedIntent | undefined> | undefined, unknown>;
+        (): import("@langchain/langgraph").LastValue<PreparedIntent | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    /** The full preparation outcome for an unprepared create, including repairable feedback. */
+    preparationResult: {
+        (annotation: import("@langchain/langgraph").SingleReducer<PrepareResult | undefined, PrepareResult | undefined>): import("@langchain/langgraph").BaseChannel<PrepareResult | undefined, PrepareResult | import("@langchain/langgraph").OverwriteValue<PrepareResult | undefined> | undefined, unknown>;
+        (): import("@langchain/langgraph").LastValue<PrepareResult | 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").
@@ -73,41 +136,40 @@ export declare const IntentGraphState: import("@langchain/langgraph").Annotation
      */
     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<"update" | "propose" | "create" | "delete" | "read", "update" | "propose" | "create" | "delete" | "read" | import("@langchain/langgraph").OverwriteValue<"update" | "propose" | "create" | "delete" | "read">, unknown>;
-    /**
-     * For update/delete operations, specifies which intent IDs to target.
-     * Optional - used when modifying or removing specific intents.
+     * The graph routes on the shape of its input, not a mode flag:
+     * - `inputContent` alone → create path (prepare → execute)
+     * - `inputContent` + `targetIntentIds` → explicit update, bound to that one id
+     * - `targetIntentIds` + `archive: true` → expire those ids, no LLM
+     * - `targetIntentIds` + `status` → pause/resume, no LLM
+     * - none of the above → read (query fast path)
+     * Exactly one of {content, archive, status} may be set per invoke.
      */
     targetIntentIds: import("@langchain/langgraph").BaseChannel<string[] | undefined, string[] | import("@langchain/langgraph").OverwriteValue<string[] | undefined> | undefined, unknown>;
+    /** Archive route: expire every id in `targetIntentIds`. Requires `targetIntentIds`. */
+    archive: import("@langchain/langgraph").BaseChannel<boolean, boolean | import("@langchain/langgraph").OverwriteValue<boolean>, unknown>;
+    /** Transition route: pause/resume the single id in `targetIntentIds`. Requires `targetIntentIds`. */
+    status: import("@langchain/langgraph").BaseChannel<"ACTIVE" | "PAUSED" | undefined, "ACTIVE" | "PAUSED" | import("@langchain/langgraph").OverwriteValue<"ACTIVE" | "PAUSED" | 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).
+     * Optional network scope (network ID) for read operations. Prep always
+     * fetches ALL user intents via getActiveIntents(userId) regardless of network
+     * scope (for explicit update ownership).
      */
     networkId: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
+    /**
+     * Create route: the networks a newly created intent is linked to. Exactly
+     * this list is written to `intent_networks`, each one membership-checked;
+     * nothing is inferred or scored. An empty list creates an unlinked intent.
+     */
+    networkIds: 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>;
+    scopeType: import("@langchain/langgraph").BaseChannel<ScopeType | undefined, ScopeType | import("@langchain/langgraph").OverwriteValue<ScopeType | 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>;
     /**
@@ -137,14 +199,16 @@ export declare const IntentGraphState: import("@langchain/langgraph").Annotation
     /** 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).
+     * Final actions to be performed on the DB (Create, Update, Expire, Transition).
      */
-    actions: import("@langchain/langgraph").BaseChannel<import("../intent.reconciler.js").NormalizedIntentAction[], import("../intent.reconciler.js").NormalizedIntentAction[] | import("@langchain/langgraph").OverwriteValue<import("../intent.reconciler.js").NormalizedIntentAction[]>, unknown>;
+    actions: import("@langchain/langgraph").BaseChannel<IntentGraphAction[], IntentGraphAction[] | import("@langchain/langgraph").OverwriteValue<IntentGraphAction[]>, 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>;
+    /** Detailed outcome of a `transition` action, for host-side status mapping. */
+    transitionResult: import("@langchain/langgraph").BaseChannel<TransitionOutcome | undefined, TransitionOutcome | import("@langchain/langgraph").OverwriteValue<TransitionOutcome | undefined> | undefined, 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).
@@ -174,9 +238,9 @@ export declare const IntentGraphState: import("@langchain/langgraph").Annotation
      * 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.
+     * default path). Derived by the host from the scope envelope plus memberships.
      */
-    indexScope: import("@langchain/langgraph").BaseChannel<string[] | undefined, string[] | import("@langchain/langgraph").OverwriteValue<string[] | undefined> | undefined, unknown>;
+    networkScope: 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.
@@ -184,7 +248,7 @@ export declare const IntentGraphState: import("@langchain/langgraph").Annotation
     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.
+     * ignoring network scope. Used when the caller requests a global list.
      */
     allUserIntents: import("@langchain/langgraph").BaseChannel<boolean, boolean | import("@langchain/langgraph").OverwriteValue<boolean>, unknown>;
     /**