@indexnetwork/protocol 11.0.1-rc.455.1 → 11.0.2-rc.456.1

package/CHANGELOG.md

@@ -51,6 +51,7 @@ pin a supported release, use `latest`.
   enrichment are unchanged.
 
 ### Added
+- Add a live answer-first signal-intake eval with unrelated, relevant, and no-bridge profile cases plus provider-free corpus, runner, and scorer checks.
 - Add the protocol-only Guided Atlas, deterministic architecture inventory
   generator, and source-evidenced Configuration Lab. The atlas explains
   normative concepts, the current `packages/protocol` reference implementation,
@@ -69,6 +70,7 @@ pin a supported release, use `latest`.
   `SynthesisResult` types. Minor bump: additive surface only.
 
 ### Changed
+- Make fast signal-intake follow-ups answer-first with a two-stage model boundary: an answer-only core call chooses the missing axis and supplies two or three concrete domain options, then an isolated bridge call may append at most one premise-derived profile option so an existing profile theme cannot dominate or reorder a newly stated intent.
 - Remove unsupported deprecated source/deep forwarding shims after migrating repository consumers to canonical modules; stable package-root exports are unchanged.
 - Add a fail-closed isolated provider-free test gate (10.1.1). Tooling-only
   safety foundation; no runtime or public API behavior changes.

package/dist/signals/application/intake.orchestrator.d.ts

@@ -56,9 +56,10 @@ export interface SynthesisResult {
 }
 declare const followUpPlanSchema: z.ZodObject<{
     questions: z.ZodArray<z.ZodObject<{
+        missingAxis: z.ZodEnum<["purpose", "desired_attributes", "exchange", "constraint"]>;
         title: z.ZodString;
         prompt: z.ZodString;
-        options: z.ZodArray<z.ZodObject<{
+        answerGroundedOptions: z.ZodArray<z.ZodObject<{
             label: z.ZodString;
             description: z.ZodString;
         }, "strip", z.ZodTypeAny, {
@@ -71,45 +72,92 @@ declare const followUpPlanSchema: z.ZodObject<{
         multiSelect: z.ZodBoolean;
     }, "strip", z.ZodTypeAny, {
         prompt: string;
-        options: {
+        title: string;
+        multiSelect: boolean;
+        missingAxis: "purpose" | "desired_attributes" | "exchange" | "constraint";
+        answerGroundedOptions: {
             label: string;
             description: string;
         }[];
-        title: string;
-        multiSelect: boolean;
     }, {
         prompt: string;
-        options: {
+        title: string;
+        multiSelect: boolean;
+        missingAxis: "purpose" | "desired_attributes" | "exchange" | "constraint";
+        answerGroundedOptions: {
             label: string;
             description: string;
         }[];
-        title: string;
-        multiSelect: boolean;
     }>, "many">;
     plannedFollowUpCount: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     questions: {
         prompt: string;
-        options: {
+        title: string;
+        multiSelect: boolean;
+        missingAxis: "purpose" | "desired_attributes" | "exchange" | "constraint";
+        answerGroundedOptions: {
             label: string;
             description: string;
         }[];
-        title: string;
-        multiSelect: boolean;
     }[];
     plannedFollowUpCount: number;
 }, {
     questions: {
         prompt: string;
-        options: {
+        title: string;
+        multiSelect: boolean;
+        missingAxis: "purpose" | "desired_attributes" | "exchange" | "constraint";
+        answerGroundedOptions: {
             label: string;
             description: string;
         }[];
-        title: string;
-        multiSelect: boolean;
     }[];
     plannedFollowUpCount: number;
 }>;
+declare const profileBridgePlanSchema: z.ZodObject<{
+    bridges: z.ZodArray<z.ZodObject<{
+        questionIndex: z.ZodNumber;
+        profileBridgeOption: z.ZodNullable<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            label: string;
+            description: string;
+        }, {
+            label: string;
+            description: string;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        questionIndex: number;
+        profileBridgeOption: {
+            label: string;
+            description: string;
+        } | null;
+    }, {
+        questionIndex: number;
+        profileBridgeOption: {
+            label: string;
+            description: string;
+        } | null;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    bridges: {
+        questionIndex: number;
+        profileBridgeOption: {
+            label: string;
+            description: string;
+        } | null;
+    }[];
+}, {
+    bridges: {
+        questionIndex: number;
+        profileBridgeOption: {
+            label: string;
+            description: string;
+        } | null;
+    }[];
+}>;
 /** Static round-1 question used only when pack generation fails outright. */
 export declare const FALLBACK_WHO_QUESTION: IntakePackQuestion;
 /** Static round-2 question used when live generation fails. */
@@ -124,12 +172,14 @@ export declare function answerLabel(answer: IntakeAnswer): string;
 /** Runs the two live stages of the fast intake funnel: follow-up planning and synthesis. */
 export declare class SignalIntakeOrchestrator {
     private readonly plannerModel;
+    private readonly profileBridgeModel;
     private readonly synthesisModel;
     /**
      * @param models - Optional injected structured models. Tests pass stubs.
      */
     constructor(models?: {
         planner?: Runnable<BaseLanguageModelInput, z.infer<typeof followUpPlanSchema>>;
+        profileBridge?: Runnable<BaseLanguageModelInput, z.infer<typeof profileBridgePlanSchema>>;
         synthesis?: Runnable<BaseLanguageModelInput, SynthesisResult>;
     });
     /**

package/dist/signals/application/intake.orchestrator.js

@@ -10,16 +10,35 @@ import { HumanMessage, SystemMessage } from "@langchain/core/messages";
 import { z } from "zod";
 import { createStructuredModel } from "../../shared/agent/model.config.js";
 import { normalizeIntakePack } from "./intake.pack.generator.js";
-const questionSchema = z.object({
+const optionSchema = z.object({
+    label: z.string().min(1),
+    description: z.string(),
+});
+const answerFirstQuestionSchema = z.object({
+    missingAxis: z
+        .enum(["purpose", "desired_attributes", "exchange", "constraint"])
+        .describe("The unanswered decision axis selected only from the answered intake rounds."),
     title: z.string(),
     prompt: z.string().min(1),
-    options: z.array(z.object({ label: z.string().min(1), description: z.string() })),
+    answerGroundedOptions: z
+        .array(optionSchema)
+        .min(2)
+        .max(3)
+        .describe("Two or three distinct choices derived only from the answered intake rounds."),
     multiSelect: z.boolean(),
 });
 const followUpPlanSchema = z.object({
-    questions: z.array(questionSchema),
+    questions: z.array(answerFirstQuestionSchema),
     plannedFollowUpCount: z.number().int().min(0),
 });
+const profileBridgePlanSchema = z.object({
+    bridges: z.array(z.object({
+        questionIndex: z.number().int().min(0),
+        profileBridgeOption: optionSchema
+            .nullable()
+            .describe("One natural profile intersection, or null when the bridge would be forced."),
+    })),
+});
 const synthesisSchema = z.object({
     description: z.string().min(1),
     lookingFor: z.string().min(1),
@@ -49,18 +68,37 @@ export const FALLBACK_BRING_QUESTION = {
     ],
     multiSelect: false,
 };
-const PLAN_SYSTEM_PROMPT = `You plan and write follow-up intake questions for a networking product.
+const PLAN_SYSTEM_PROMPT = `You plan and write answer-first follow-up intake questions for a networking product.
+
+You receive ONLY the answered intake rounds. Use them to choose the next missing
+axis, write a standalone prompt that names the newly stated person or domain, and
+create 2-3 meaningfully distinct answerGroundedOptions. Choose the most useful
+unanswered axis from: purpose, desired_attributes, exchange, or constraint. Never
+re-ask an axis the rounds already answer. Do not infer a professional background,
+industry, capability, or commercial goal that the rounds do not state.
+
+Every answerGroundedOption must be visibly anchored to the stated person or domain
+in its label or description and represent a concrete, distinct path. Generic labels
+such as "Learn", "Share", "Collaborate", or "Networking" are invalid when they do
+not say what the user would learn, share, collaborate on, or network about.
+- Scuba divers: "Learn diving techniques", "Find dive buddies", "Share dive stories".
+- Climate founders: "Compare climate sectors", "Find climate peers", "Discuss adaptation".
 
-Given a brief about the person and the intake rounds they already answered, decide
-how many further questions (up to the stated maximum) would make their signal
-specific enough to match on, and write them. Each question is one concise prompt
-with 3-4 concrete options grounded in the brief and the previous answers; each
-option has a short label and a one-line description. Set multiSelect true only
-when several options can genuinely apply together. Never re-ask a dimension that
-is already answered; skip a dimension the brief already covers. Never expose raw
-JSON, IDs, or internal vocabulary. plannedFollowUpCount is the TOTAL number of
-follow-up questions the interview should contain, including any returned now;
-when the input already fixes it, echo that value unchanged.`;
+Each option needs a short label and a one-line description. Set multiSelect true
+only when several options can genuinely apply together. Never expose raw JSON,
+IDs, or internal vocabulary. plannedFollowUpCount is the TOTAL number of follow-up
+questions the interview should contain, including any returned now; when the input
+already fixes it, echo that value unchanged.`;
+const PROFILE_BRIDGE_SYSTEM_PROMPT = `You may append one optional profile bridge to each already-written signal-intake question.
+
+The question, missing axis, and answer-grounded options are immutable. For each
+questionIndex, compare them with the profile brief and return either one genuinely
+useful profileBridgeOption or null. A bridge is useful only when it creates a
+natural additional path that is not already represented. Never rewrite, replace,
+remove, or reclassify a core option. Never return more than one bridge per question.
+When the profile theme is unrelated or the intersection would feel forced, return
+null. Running club + investor may support one sponsorship bridge; scuba divers +
+pianist should return null.`;
 const SYNTHESIS_SYSTEM_PROMPT = `You write one clear signal for a networking product.
 
 Combine the brief and the person's answers into a specific description of who they
@@ -79,6 +117,37 @@ community constraint. Never invent facts beyond the brief and the answers.`;
 export function answerLabel(answer) {
     return [...answer.selectedOptions, answer.freeText?.trim() ?? ""].filter(Boolean).join(", ");
 }
+function normalizeFollowUpQuestion(question, profileBridge, brief) {
+    const seen = new Set();
+    const normalizeOption = (option) => {
+        const label = option.label.trim();
+        const key = label.toLocaleLowerCase();
+        if (!label || seen.has(key))
+            return null;
+        seen.add(key);
+        return { label, description: option.description.trim() };
+    };
+    const answerGroundedOptions = question.answerGroundedOptions
+        .map(normalizeOption)
+        .filter((option) => option !== null)
+        .slice(0, 3);
+    if (answerGroundedOptions.length < 2) {
+        throw new Error("Follow-up question needs at least two answer-grounded options.");
+    }
+    const profileBridgeOption = profileBridge ? normalizeOption(profileBridge) : null;
+    return normalizeIntakePack({
+        brief,
+        question: {
+            title: question.title,
+            prompt: question.prompt,
+            options: [
+                ...answerGroundedOptions,
+                ...(profileBridgeOption ? [profileBridgeOption] : []),
+            ],
+            multiSelect: question.multiSelect,
+        },
+    }).question;
+}
 /** Runs the two live stages of the fast intake funnel: follow-up planning and synthesis. */
 export class SignalIntakeOrchestrator {
     /**
@@ -87,6 +156,8 @@ export class SignalIntakeOrchestrator {
     constructor(models) {
         this.plannerModel = models?.planner
             ?? createStructuredModel("signalIntakePack", followUpPlanSchema);
+        this.profileBridgeModel = models?.profileBridge
+            ?? createStructuredModel("signalIntakePack", profileBridgePlanSchema, { name: "signal_intake_profile_bridges" });
         this.synthesisModel = models?.synthesis
             ?? createStructuredModel("signalIntakePack", synthesisSchema);
     }
@@ -107,11 +178,29 @@ export class SignalIntakeOrchestrator {
         try {
             const raw = await this.plannerModel.invoke([
                 new SystemMessage(PLAN_SYSTEM_PROMPT),
-                new HumanMessage(`Brief:\n${input.brief}\n\n${roundsText}\n\nWrite up to ${input.maxFollowUps} follow-up question(s).${lockedLine}`),
+                new HumanMessage(`ANSWERED ROUNDS:\n${roundsText}\n\nWrite up to ${input.maxFollowUps} follow-up question(s).${lockedLine}`),
             ]);
-            const questions = raw.questions
-                .slice(0, input.maxFollowUps)
-                .map((q) => normalizeIntakePack({ brief: input.brief, question: q }).question);
+            const coreQuestions = raw.questions.slice(0, input.maxFollowUps);
+            const bridgeByQuestion = new Map();
+            if (coreQuestions.length > 0 && input.brief.trim()) {
+                try {
+                    const bridgePlan = await this.profileBridgeModel.invoke([
+                        new SystemMessage(PROFILE_BRIDGE_SYSTEM_PROMPT),
+                        new HumanMessage(`ANSWERED ROUNDS:\n${roundsText}\n\nPROFILE BRIEF:\n${input.brief}\n\nIMMUTABLE CORE QUESTIONS:\n${JSON.stringify(coreQuestions, null, 2)}\n\nReturn one bridge decision for each questionIndex.`),
+                    ]);
+                    for (const bridge of bridgePlan.bridges) {
+                        if (bridge.questionIndex < coreQuestions.length
+                            && !bridgeByQuestion.has(bridge.questionIndex)) {
+                            bridgeByQuestion.set(bridge.questionIndex, bridge.profileBridgeOption);
+                        }
+                    }
+                }
+                catch {
+                    // Profile personalization is optional. A bridge-model failure must not
+                    // discard valid answer-grounded questions from the primary model.
+                }
+            }
+            const questions = coreQuestions.map((question, index) => normalizeFollowUpQuestion(question, bridgeByQuestion.get(index) ?? null, input.brief));
             // Backstop: while budget remains, a successful empty plan must not
             // silently shrink the interview; serve the static fallback instead.
             if (questions.length === 0 && input.maxFollowUps > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indexnetwork/protocol",
-  "version": "11.0.1-rc.455.1",
+  "version": "11.0.2-rc.456.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -40,6 +40,7 @@
     "eval:profile": "bun --env-file=../../.env.test ./eval/profile/profile.eval.ts",
     "eval:opportunity": "bun --env-file=../../.env.test ./eval/opportunity/opportunity.eval.ts",
     "eval:clarification": "bun --env-file=../../.env.test ./eval/clarification/clarification.eval.ts",
+    "eval:intake": "bun --env-file=../../.env.test ./eval/intake/intake.eval.ts",
     "eval:discovery-retrieval": "bun --env-file=../../.env.test ./eval/discovery-retrieval/discovery-retrieval.eval.ts",
     "eval:canary": "bun --env-file=../../.env.test ./eval/canary/canary.eval.ts",
     "eval:stance": "bun --env-file=../../.env.test ./eval/stance/stance.eval.ts",