@indexnetwork/protocol 22.0.0-rc.499.1 → 64.0.0

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

@@ -16,9 +16,13 @@ export const IntentGraphState = Annotation.Root({
     userProfile: (Annotation),
     /**
      * Explicit input content (e.g., user message).
-     * Optional - graph might run on implicit only.
+     * Omitted for read, archive, and status operations.
      */
     inputContent: (Annotation),
+    /** Host-authorized preparation, reused without admission. Null metadata means the final text was edited. Never pass client-supplied objects here. */
+    preparation: (Annotation),
+    /** The full preparation outcome for an unprepared create, including repairable feedback. */
+    preparationResult: (Annotation),
     /**
      * Conversation history for context-aware intent inference.
      * Used to resolve anaphoric references ("that intent", "this goal").
@@ -30,24 +34,25 @@ export const IntentGraphState = Annotation.Root({
         default: () => undefined,
     }),
     /**
-     * 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.
+     * 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.
      */
-    operationMode: Annotation({
+    targetIntentIds: Annotation({
         reducer: (curr, next) => next ?? curr,
-        default: () => 'create',
+        default: () => undefined,
     }),
-    /**
-     * For update/delete operations, specifies which intent IDs to target.
-     * Optional - used when modifying or removing specific intents.
-     */
-    targetIntentIds: Annotation({
+    /** Archive route: expire every id in `targetIntentIds`. Requires `targetIntentIds`. */
+    archive: Annotation({
+        reducer: (curr, next) => next ?? curr,
+        default: () => false,
+    }),
+    /** Transition route: pause/resume the single id in `targetIntentIds`. Requires `targetIntentIds`. */
+    status: Annotation({
         reducer: (curr, next) => next ?? curr,
         default: () => undefined,
     }),
@@ -60,14 +65,23 @@ export const IntentGraphState = Annotation.Root({
         default: () => undefined,
     }),
     /**
-     * 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: Annotation({
         reducer: (curr, next) => next ?? curr,
         default: () => undefined,
     }),
+    /**
+     * 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: Annotation({
+        reducer: (curr, next) => next ?? curr,
+        default: () => undefined,
+    }),
     /** Focused request scope type for write-side assignment and follow-up queues. */
     scopeType: Annotation({
         reducer: (curr, next) => next ?? curr,
@@ -79,14 +93,6 @@ export const IntentGraphState = Annotation.Root({
         default: () => undefined,
     }),
     // --- Populated by Graph (Prep Node) ---
-    /**
-     * The formatted string of currently active intents.
-     * Always populated by prep via getActiveIntents(userId).
-     */
-    activeIntents: Annotation({
-        reducer: (curr, next) => next,
-        default: () => "",
-    }),
     /** IDs of active intents owned by the graph user, used to fail closed on explicit updates. */
     activeIntentIds: Annotation({
         reducer: (curr, next) => next,
@@ -115,7 +121,7 @@ export const IntentGraphState = Annotation.Root({
     }),
     // --- Output ---
     /**
-     * Final actions to be performed on the DB (Create, Update, Expire).
+     * Final actions to be performed on the DB (Create, Update, Expire, Transition).
      */
     actions: Annotation({
         reducer: (curr, next) => next,
@@ -129,6 +135,11 @@ export const IntentGraphState = Annotation.Root({
         reducer: (curr, next) => next,
         default: () => [],
     }),
+    /** Detailed outcome of a `transition` action, for host-side status mapping. */
+    transitionResult: Annotation({
+        reducer: (curr, next) => next ?? curr,
+        default: () => undefined,
+    }),
     // --- Error State ---
     /**
      * If set, indicates a fatal error that should short-circuit the graph to END.
@@ -158,9 +169,9 @@ export const IntentGraphState = Annotation.Root({
      * 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: Annotation({
+    networkScope: Annotation({
         reducer: (_curr, next) => next,
         default: () => undefined,
     }),
@@ -174,7 +185,7 @@ export const IntentGraphState = Annotation.Root({
     }),
     /**
      * 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: Annotation({
         reducer: (curr, next) => next ?? curr,

package/dist/internal/intents/intent.admission.d.ts

@@ -0,0 +1,16 @@
+import type { SemanticVerifierOutput } from "./intent.verifier.js";
+import type { IntentValidationFailure } from "./graph/intent.graph.state.js";
+/** The admission policy shared by preparation and explicit updates. */
+export declare function admissionFailure(description: string, verdict: SemanticVerifierOutput, isExplicitUpdate?: boolean): IntentValidationFailure | undefined;
+/** Measurements of exactly one description, independent of admission. */
+export interface IntentSemanticMetadata {
+    semanticEntropy: number;
+    referentialAnchor: string | null;
+    felicityAuthority: number;
+    felicitySincerity: number;
+    felicityClarity: number;
+    intentMode: "REFERENTIAL" | "ATTRIBUTIVE";
+    speechActType: "COMMISSIVE" | "DIRECTIVE" | null;
+}
+/** Map even a negative verdict to measurements without applying admission. */
+export declare function semanticMetadata(verdict: SemanticVerifierOutput): IntentSemanticMetadata;

package/dist/internal/intents/intent.admission.js

@@ -0,0 +1,30 @@
+const MAX_PERMISSIBLE_ENTROPY = 0.75;
+const MIN_CLEAR_INTENT_SCORE = 40;
+// Match the whole request so qualified job searches use the verifier's verdict.
+const GENERIC_JOB_PHRASE = /^(?:(?:i(?:['’]m|\s+am)?\s+)?(?:want|need|seek(?:ing)?|looking\s+for)\s+)?(?:a|any|some)\s+job[.!?]*$/i;
+const DEFAULT_SPECIFICITY_WARNING = "This signal is broad and may produce many weak matches. Add a more concrete role, outcome, location, timeframe, domain, or specific need to get better recommendations.";
+/** The admission policy shared by preparation and explicit updates. */
+export function admissionFailure(description, verdict, isExplicitUpdate = false) {
+    const details = { classification: verdict.classification, referentialBreadth: verdict.referential_breadth };
+    if (!["COMMISSIVE", "DIRECTIVE", "DECLARATION"].includes(verdict.classification)) {
+        return { ...details, category: "non_actionable", message: "Describe who you want to reach and what you want to do together." };
+    }
+    if (GENERIC_JOB_PHRASE.test(description.trim()) || verdict.semantic_entropy > MAX_PERMISSIBLE_ENTROPY || verdict.felicity_scores.clarity < MIN_CLEAR_INTENT_SCORE) {
+        return { ...details, category: "vague_or_invalid", message: "Make the goal more concrete: specify the role, outcome, or particular help you need." };
+    }
+    if (!isExplicitUpdate && verdict.referential_breadth === "broad") {
+        return { ...details, category: "vague_or_invalid", message: verdict.specificity_warning?.trim() || DEFAULT_SPECIFICITY_WARNING };
+    }
+}
+/** Map even a negative verdict to measurements without applying admission. */
+export function semanticMetadata(verdict) {
+    return {
+        semanticEntropy: verdict.semantic_entropy,
+        referentialAnchor: verdict.referential_anchor,
+        felicityAuthority: verdict.felicity_scores.authority,
+        felicitySincerity: verdict.felicity_scores.sincerity,
+        felicityClarity: verdict.felicity_scores.clarity,
+        intentMode: verdict.referential_anchor ? "REFERENTIAL" : "ATTRIBUTIVE",
+        speechActType: verdict.classification === "COMMISSIVE" || verdict.classification === "DIRECTIVE" ? verdict.classification : null,
+    };
+}

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

@@ -5,18 +5,6 @@ import { z } from "zod";
  * Used to implement safety controls for read/write separation.
  */
 export interface InferrerOptions {
-    /**
-     * Whether to fallback to profile inference when content is empty.
-     * Should be TRUE for create operations without explicit content.
-     * Should be FALSE for query operations.
-     * Default: true (for backward compatibility).
-     */
-    allowProfileFallback?: boolean;
-    /**
-     * The operation mode for context.
-     * Helps inferrer understand the user's intent.
-     */
-    operationMode?: 'create' | 'update' | 'delete';
     /**
      * Conversation history for anaphoric resolution.
      * Used to resolve references like "that intent", "this goal", etc.
@@ -48,7 +36,7 @@ export declare class ExplicitIntentInferrer {
      * Main entry point. Invokes the agent with input and returns structured output.
      * @param content - The raw string content to analyze.
      * @param profileContext - The formatted profile context string.
-     * @param options - Options controlling inference behavior (fallback, operation mode, conversation context).
+     * @param options - Conversation context for the explicit update.
      */
     invoke(content: string | null, profileContext: string, options?: InferrerOptions): Promise<{
         intents: {
@@ -63,32 +51,5 @@ export declare class ExplicitIntentInferrer {
      * Converts BaseMessage[] to readable string format.
      */
     private formatConversationHistory;
-    /**
-     * Factory method to expose the agent as a LangChain tool.
-     * Useful for composing agents into larger graphs.
-     */
-    static asTool(): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
-        content: z.ZodNullable<z.ZodString>;
-        profileContext: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        profileContext: string;
-        content: string | null;
-    }, {
-        profileContext: string;
-        content: string | null;
-    }>, {
-        profileContext: string;
-        content: string | null;
-    }, {
-        profileContext: string;
-        content: string | null;
-    }, {
-        intents: {
-            reasoning: string;
-            type: "goal" | "tombstone";
-            confidence: "low" | "medium" | "high";
-            description: string;
-        }[];
-    }, unknown, "explicit_intent_inferrer">;
 }
 export {};

package/dist/{intents → internal/intents}/intent.inferrer.js

@@ -8,7 +8,6 @@ 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";
@@ -42,7 +41,6 @@ const systemPrompt = `
   - Be precise and self-contained in descriptions (e.g., "Learn Rust programming" instead of "Learn it").
   - Do NOT try to manage existing IDs or check for duplicates.
   - IGNORE purely phatic communication (e.g., "Hello", "Hi", "Good morning") - return empty intents.
-  - For CREATE operations: Extract what the user wants to ADD.
   - For UPDATE operations: Extract what the user wants to CHANGE.
   - For queries/questions: You should not see these - return empty intents.
 
@@ -76,11 +74,6 @@ const systemPrompt = `
   - Example: If history mentions "text-based RPG game" and user says "make that intent have LLM narration",
     the output should be "Create a text-based RPG game with LLM-enhanced narration" (preserving "text-based").
 
-  WHEN TO FALLBACK TO PROFILE:
-  - Only when explicitly instructed: "(No content provided. Please infer intents from Profile Narrative and Aspirations)"
-  - This should ONLY happen for CREATE operations with no explicit user input
-  - Never infer from profile for query operations
-  - When content IS present: profile may inform HOW to describe the intent (e.g., adding domain context), but must NOT change WHAT the intent is about
 `;
 // ──────────────────────────────────────────────────────────────
 // 2. RESPONSE SCHEMA (Zod)
@@ -107,22 +100,17 @@ export class ExplicitIntentInferrer {
      * Main entry point. Invokes the agent with input and returns structured output.
      * @param content - The raw string content to analyze.
      * @param profileContext - The formatted profile context string.
-     * @param options - Options controlling inference behavior (fallback, operation mode, conversation context).
+     * @param options - Conversation context for the explicit update.
      */
     async invoke(content, profileContext, options = {}) {
-        const { allowProfileFallback = true, // Default TRUE for backward compatibility
-        operationMode = 'create', conversationContext = undefined } = options;
+        const { conversationContext = undefined } = options;
         logger.verbose("invoke: received input", {
             contentPreview: content?.substring(0, 50),
-            allowProfileFallback,
-            operationMode,
             hasConversationContext: !!conversationContext,
             conversationMessageCount: conversationContext?.length || 0,
         });
-        // CRITICAL: Don't fallback to profile when explicitly disabled
-        // This prevents auto-generation of intents from profile during query operations
-        if (!content && !allowProfileFallback) {
-            logger.verbose("invoke: no content and fallback disabled, returning empty");
+        if (!content) {
+            logger.verbose("invoke: no content, returning empty");
             return { intents: [] };
         }
         // Build conversation history section for anaphoric resolution
@@ -132,24 +120,20 @@ export class ExplicitIntentInferrer {
         const conversationSection = formattedHistory
             ? `# Conversation History (for reference resolution)\n${formattedHistory}\n`
             : '';
-        // Build content section based on fallback setting
-        const contentSection = content
-            ? `## New Content\n\n${content}`
-            : allowProfileFallback
-                ? '(No content provided. Please infer intents from Profile Narrative and Aspirations)'
-                : '(No content to analyze. Return empty intents list.)';
+        const contentSection = `## New Content\n\n${content}`;
+        // No profile means no profile section at all. Callers that deliberately run
+        // profile-blind must not see an empty heading the model could try to fill in.
+        const profileSection = profileContext?.trim()
+            ? `# User Memory Profile\n      ${profileContext}\n`
+            : '';
         const prompt = `
       Context:
-      # User Memory Profile
-      ${profileContext}
-
+      ${profileSection}
       ${conversationSection}${contentSection}
 
       # Operation Context
-      This analysis is for a ${operationMode} operation.
-      ${operationMode === 'create' ? 'Extract NEW intents the user wants to add.' : ''}
-      ${operationMode === 'update' ? 'Extract MODIFICATIONS to existing intents. Use conversation history to resolve references like "that intent".' : ''}
-      ${operationMode === 'delete' ? 'This should not execute - delete operations skip inference.' : ''}
+      This analysis is for an update operation.
+      Extract MODIFICATIONS to existing intents. Use conversation history to resolve references like "that intent".
     `;
         logger.debug("invoke: prompt details", {
             hasConversationHistory: !!conversationSection,
@@ -168,9 +152,6 @@ export class ExplicitIntentInferrer {
             const output = responseFormat.parse(result);
             logger.verbose('invoke: found intents', {
                 count: output.intents.length,
-                operationMode,
-                allowedFallback: allowProfileFallback,
-                usedFallback: !content && allowProfileFallback,
             });
             return output;
         }
@@ -207,23 +188,6 @@ export class ExplicitIntentInferrer {
         });
         return formatted;
     }
-    /**
-     * Factory method to expose the agent as a LangChain tool.
-     * Useful for composing agents into larger graphs.
-     */
-    static asTool() {
-        return tool(async (args) => {
-            const agent = new ExplicitIntentInferrer();
-            return await agent.invoke(args.content, args.profileContext);
-        }, {
-            name: 'explicit_intent_inferrer',
-            description: 'Extracts explicit intents from user content and profile context.',
-            schema: z.object({
-                content: z.string().nullable().describe('The new content to analyze'),
-                profileContext: z.string().describe('The user profile context')
-            })
-        });
-    }
 }
 __decorate([
     Timed(),

package/dist/internal/intents/intent.preparer.d.ts

@@ -0,0 +1,52 @@
+import { type IntentSemanticMetadata } from "./intent.admission.js";
+import { SemanticVerifier } from "./intent.verifier.js";
+/** One answer paired with the recovery field it fills. */
+export interface PrepareAnswer {
+    prompt: string;
+    answer: string;
+}
+/** The current draft and recovery answers not yet folded into it. */
+export interface PrepareInput {
+    payload: string;
+    answers?: PrepareAnswer[];
+}
+export interface RecoveryFieldOption {
+    label: string;
+    description: string;
+}
+export type RecoveryFieldKind = "single" | "multi" | "text";
+export interface RecoveryField {
+    id: string;
+    label: string;
+    kind: RecoveryFieldKind;
+    options?: RecoveryFieldOption[];
+    placeholder?: string;
+}
+/** Host-authorized preparation. Null metadata authorizes revisions needing fresh measurements. Never accept this object from an untrusted client. */
+export interface PreparedIntent {
+    metadata: IntentSemanticMetadata | null;
+}
+/** Review is available only after admission of the complete prepared draft. */
+export type PrepareResult = {
+    status: "ready";
+    payload: string;
+    metadata: IntentSemanticMetadata;
+} | {
+    status: "needs_revision";
+    payload: string;
+    feedback: string;
+    recovery: RecoveryField[];
+};
+/** Folds recovery answers into a draft, admits its final form, and returns a dynamic recovery form on failure. Model failures propagate for retry. */
+export declare class IntentPreparer {
+    private readonly verifier;
+    constructor(verifier?: Pick<SemanticVerifier, "invoke">);
+    /**
+     * Prepare one draft using the creation admission policy.
+     * @param input - Current payload and pending recovery answers.
+     * @param profileContext - The speaker's profile, if supplied by the host.
+     * @returns An admitted draft or admission feedback plus a recovery form.
+     * @throws When rewriting, verification, or recovery generation fails; callers must retain the input for retry.
+     */
+    invoke(input: PrepareInput, profileContext?: string): Promise<PrepareResult>;
+}

package/dist/internal/intents/intent.preparer.js

@@ -0,0 +1,87 @@
+import { HumanMessage, SystemMessage } from "@langchain/core/messages";
+import { z } from "zod";
+import { createStructuredModel } from "../shared/agent/model.config.js";
+import { invokeWithAbortSignal } from "../shared/agent/model-signal.js";
+import { admissionFailure, semanticMetadata } from "./intent.admission.js";
+import { SemanticVerifier } from "./intent.verifier.js";
+const payloadSchema = z.object({ payload: z.string().trim().min(1).max(65536) });
+const recoveryOptionSchema = z.object({
+    label: z.string().trim().min(1).max(120),
+    description: z.string().max(280).nullable().optional().transform((value) => value ?? ""),
+});
+const recoveryFieldSchema = z.object({
+    id: z.string().trim().min(1).max(40),
+    label: z.string().trim().min(1).max(120),
+    kind: z.enum(["single", "multi", "text"]),
+    options: z.array(recoveryOptionSchema).min(2).max(5).nullable().optional(),
+    placeholder: z.string().max(200).nullable().optional(),
+});
+const recoverySchema = z.object({
+    recovery: z.array(recoveryFieldSchema).min(2).max(6),
+});
+function parseRecoveryFields(result) {
+    return result.recovery.map((field) => {
+        const placeholder = field.placeholder?.trim() || undefined;
+        const options = field.options?.length ? field.options : undefined;
+        if (field.kind === "text") {
+            if (!placeholder) {
+                throw new Error("Text recovery fields require a placeholder.");
+            }
+            return { id: field.id, label: field.label, kind: field.kind, placeholder };
+        }
+        if (!options?.length) {
+            throw new Error("Single and multi recovery fields require options.");
+        }
+        return { id: field.id, label: field.label, kind: field.kind, options };
+    });
+}
+/** Folds recovery answers into a draft, admits its final form, and returns a dynamic recovery form on failure. Model failures propagate for retry. */
+export class IntentPreparer {
+    constructor(verifier = new SemanticVerifier()) {
+        this.verifier = verifier;
+    }
+    /**
+     * Prepare one draft using the creation admission policy.
+     * @param input - Current payload and pending recovery answers.
+     * @param profileContext - The speaker's profile, if supplied by the host.
+     * @returns An admitted draft or admission feedback plus a recovery form.
+     * @throws When rewriting, verification, or recovery generation fails; callers must retain the input for retry.
+     */
+    async invoke(input, profileContext = "") {
+        const answers = (input.answers ?? []).filter((answer) => answer.answer.trim());
+        let payload = input.payload;
+        if (answers.length > 0) {
+            const model = createStructuredModel("intentClarifier", payloadSchema, { name: "intent_draft" });
+            const result = await invokeWithAbortSignal(model, [
+                new SystemMessage("Fold every supplied answer into the signal in the person's own voice. Preserve all existing details unless an answer explicitly changes them. Every claim must trace to the draft or answers; never invent constraints or facts to make a signal pass validation. Return the complete draft, concise and concrete."),
+                new HumanMessage(JSON.stringify({ payload, answers })),
+            ]);
+            payload = payloadSchema.parse(result).payload;
+        }
+        const verdict = await this.verifier.invoke(payload, profileContext);
+        const failure = admissionFailure(payload, verdict);
+        if (!failure)
+            return { status: "ready", payload, metadata: semanticMetadata(verdict) };
+        const model = createStructuredModel("intentClarifier", recoverySchema, { name: "intent_recovery" });
+        const result = await invokeWithAbortSignal(model, [
+            new SystemMessage("Build one recovery form that helps the person concretize their signal. Return 2-6 fields. Each field needs a draft-specific label, a kind (single, multi, or text), and for single/multi 2-5 concrete options anchored to the draft. Text fields need a placeholder. Never re-ask what the draft or answers already settle. Options must be matchable and specific. Do not expose scores, classifications, JSON, or internal vocabulary."),
+            new HumanMessage(JSON.stringify({
+                payload,
+                answers,
+                feedback: failure.message,
+                category: failure.category,
+                classification: verdict.classification,
+                clarity: verdict.felicity_scores.clarity,
+                entropy: verdict.semantic_entropy,
+                referentialBreadth: verdict.referential_breadth,
+                missingConstraints: verdict.missing_selectional_constraints,
+            })),
+        ]);
+        return {
+            status: "needs_revision",
+            payload,
+            feedback: failure.message,
+            recovery: parseRecoveryFields(recoverySchema.parse(result)),
+        };
+    }
+}

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

@@ -34,7 +34,7 @@ declare const responseFormat: z.ZodObject<{
     semantic_entropy: number;
     referential_anchor: string | null;
     referential_breadth: "narrow" | "moderate" | "broad";
-    missing_selectional_constraints: ("location" | "role" | "outcome" | "timeframe" | "domain" | "concrete_need")[];
+    missing_selectional_constraints: ("location" | "outcome" | "role" | "timeframe" | "domain" | "concrete_need")[];
     specificity_warning: string | null;
     flags: string[];
 }, {
@@ -48,7 +48,7 @@ declare const responseFormat: z.ZodObject<{
     semantic_entropy: number;
     referential_anchor: string | null;
     referential_breadth: "narrow" | "moderate" | "broad";
-    missing_selectional_constraints: ("location" | "role" | "outcome" | "timeframe" | "domain" | "concrete_need")[];
+    missing_selectional_constraints: ("location" | "outcome" | "role" | "timeframe" | "domain" | "concrete_need")[];
     specificity_warning: string | null;
     flags: string[];
 }>;
@@ -74,42 +74,9 @@ export declare class SemanticVerifier {
         semantic_entropy: number;
         referential_anchor: string | null;
         referential_breadth: "narrow" | "moderate" | "broad";
-        missing_selectional_constraints: ("location" | "role" | "outcome" | "timeframe" | "domain" | "concrete_need")[];
+        missing_selectional_constraints: ("location" | "outcome" | "role" | "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: {
-            clarity: number;
-            authority: number;
-            sincerity: 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/{intents → internal/intents}/intent.verifier.js

@@ -8,7 +8,6 @@ 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";
@@ -237,22 +236,6 @@ export class SemanticVerifier {
             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(),