cognitive-core 0.2.5 → 0.3.1

package/dist/eval/retrieval/corpus.js

@@ -0,0 +1,158 @@
+import { createTask, createStep, createTrajectory, successOutcome, failureOutcome, } from '../../types/index.js';
+import { seededRng } from '../rng.js';
+export const TASK_TYPES = ['pick', 'clean', 'heat', 'cool', 'examine', 'pick-two'];
+const OBJECTS = [
+    'apple',
+    'potato',
+    'tomato',
+    'egg',
+    'lettuce',
+    'mug',
+    'cup',
+    'plate',
+    'bowl',
+    'spoon',
+    'knife',
+    'fork',
+    'soapbar',
+    'cloth',
+    'alarmclock',
+    'book',
+    'pen',
+    'cd',
+    'watch',
+    'keychain',
+    'pencil',
+    'creditcard',
+];
+const SOURCES = ['countertop 1', 'diningtable 1', 'sidetable 1', 'shelf 1', 'desk 1', 'drawer 1'];
+const RECEPS = ['fridge 1', 'cabinet 1', 'countertop 1', 'drawer 1', 'shelf 1', 'garbagecan 1'];
+/** Goal text + action recipe for a given task type. */
+function instantiate(type, obj, src, recep) {
+    switch (type) {
+        case 'heat':
+            return {
+                goal: `heat some ${obj} and put it in ${recep}`,
+                actions: [
+                    `go to ${src}`,
+                    `take ${obj} 1 from ${src}`,
+                    'go to microwave 1',
+                    `heat ${obj} 1 with microwave 1`,
+                    `go to ${recep}`,
+                    `put ${obj} 1 in/on ${recep}`,
+                ],
+            };
+        case 'cool':
+            return {
+                goal: `cool some ${obj} and put it in ${recep}`,
+                actions: [
+                    `go to ${src}`,
+                    `take ${obj} 1 from ${src}`,
+                    'go to fridge 1',
+                    `cool ${obj} 1 with fridge 1`,
+                    `go to ${recep}`,
+                    `put ${obj} 1 in/on ${recep}`,
+                ],
+            };
+        case 'clean':
+            return {
+                goal: `clean some ${obj} and put it in ${recep}`,
+                actions: [
+                    `go to ${src}`,
+                    `take ${obj} 1 from ${src}`,
+                    'go to sinkbasin 1',
+                    `clean ${obj} 1 with sinkbasin 1`,
+                    `go to ${recep}`,
+                    `put ${obj} 1 in/on ${recep}`,
+                ],
+            };
+        case 'pick':
+            return {
+                goal: `put some ${obj} in ${recep}`,
+                actions: [
+                    `go to ${src}`,
+                    `take ${obj} 1 from ${src}`,
+                    `go to ${recep}`,
+                    `put ${obj} 1 in/on ${recep}`,
+                ],
+            };
+        case 'examine':
+            return {
+                goal: `examine the ${obj} with the desklamp`,
+                actions: [
+                    `go to ${src}`,
+                    `take ${obj} 1 from ${src}`,
+                    'go to desklamp 1',
+                    'use desklamp 1',
+                ],
+            };
+        case 'pick-two':
+            return {
+                goal: `put two ${obj} in ${recep}`,
+                actions: [
+                    `go to ${src}`,
+                    `take ${obj} 1 from ${src}`,
+                    `go to ${recep}`,
+                    `put ${obj} 1 in/on ${recep}`,
+                    `go to ${src}`,
+                    `take ${obj} 2 from ${src}`,
+                    `go to ${recep}`,
+                    `put ${obj} 2 in/on ${recep}`,
+                ],
+            };
+    }
+}
+function pick(arr, rng) {
+    return arr[Math.floor(rng() * arr.length)];
+}
+/**
+ * Build a labeled corpus: `perType` tasks per task type, deterministic by seed.
+ * A fraction are marked failed (to exercise success-biased retrieval).
+ */
+export function buildAlfworldCorpus(opts = {}) {
+    const perType = opts.perType ?? 6;
+    const failRate = opts.failRate ?? 0.3;
+    const rng = seededRng('corpus', opts.seed ?? 1);
+    const out = [];
+    for (const type of TASK_TYPES) {
+        for (let i = 0; i < perType; i++) {
+            const obj = pick(OBJECTS, rng);
+            const { goal, actions } = instantiate(type, obj, pick(SOURCES, rng), pick(RECEPS, rng));
+            out.push({ goal, type, actions, success: rng() >= failRate });
+        }
+    }
+    return out;
+}
+/**
+ * Held-out query tasks (new object draws), labeled by type. These are NOT in
+ * the corpus — they're what we retrieve against.
+ */
+export function buildAlfworldQueries(opts = {}) {
+    const perType = opts.perType ?? 3;
+    const rng = seededRng('queries', opts.seed ?? 99);
+    const out = [];
+    for (const type of TASK_TYPES) {
+        for (let i = 0; i < perType; i++) {
+            const { goal } = instantiate(type, pick(OBJECTS, rng), pick(SOURCES, rng), pick(RECEPS, rng));
+            out.push({ goal, type });
+        }
+    }
+    return out;
+}
+/** Convert a labeled task to a Trajectory (so storeTrajectory populates steps). */
+export function taskToTrajectory(task) {
+    const steps = task.actions.map((a) => createStep({ action: a, observation: 'You arrive at the location. (obs)' }));
+    const transcript = `Your task is to: ${task.goal}\n` + task.actions.map((a) => `> ${a}`).join('\n');
+    return createTrajectory({
+        task: createTask({
+            domain: 'embodied',
+            description: task.goal,
+            context: { taskType: task.type },
+            metadata: { skillTag: 'alfworld', taskType: task.type },
+        }),
+        steps,
+        outcome: task.success ? successOutcome(transcript) : failureOutcome('did not complete'),
+        agentId: 'corpus',
+    });
+}
+//# sourceMappingURL=corpus.js.map

package/dist/eval/retrieval/corpus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"corpus.js","sourceRoot":"","sources":["../../../src/eval/retrieval/corpus.ts"],"names":[],"mappings":"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"}

package/dist/eval/retrieval/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Offline retrieval-quality harness: measures whether goal-keyed memory
+ * retrieval surfaces the right task type / excludes failures / renders a usable
+ * recipe — deterministically, with no live agent. Used to tune k / thresholds /
+ * embeddings and as a regression guard on the retrieval mechanism.
+ */
+export * from './corpus.js';
+export * from './quality.js';
+export * from './knowledge-corpus.js';
+export * from './knowledge-quality.js';
+export * from './ladder.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/eval/retrieval/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/eval/retrieval/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAG7B,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AAGvC,cAAc,aAAa,CAAC"}

package/dist/eval/retrieval/index.js

@@ -0,0 +1,14 @@
+/**
+ * Offline retrieval-quality harness: measures whether goal-keyed memory
+ * retrieval surfaces the right task type / excludes failures / renders a usable
+ * recipe — deterministically, with no live agent. Used to tune k / thresholds /
+ * embeddings and as a regression guard on the retrieval mechanism.
+ */
+export * from './corpus.js';
+export * from './quality.js';
+// A-MEM-inspired knowledge-note retrieval benchmarking (lexical vs embedding).
+export * from './knowledge-corpus.js';
+export * from './knowledge-quality.js';
+// Proxy → outcome ladder: composes retrieval gain + utilization + success lift.
+export * from './ladder.js';
+//# sourceMappingURL=index.js.map

package/dist/eval/retrieval/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/eval/retrieval/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAE7B,+EAA+E;AAC/E,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AAEvC,gFAAgF;AAChF,cAAc,aAAa,CAAC"}

package/dist/eval/retrieval/knowledge-corpus.d.ts

@@ -0,0 +1,91 @@
+import type { KnowledgeNote } from '../../types/knowledge.js';
+/**
+ * Labeled, stratified knowledge-note corpus for OFFLINE retrieval benchmarking
+ * of KnowledgeBank search providers (lexical vs neural embedding).
+ *
+ * The whole point of this corpus is to *isolate the synonymy effect* that
+ * embedding retrieval is supposed to buy. A flat query set does not do that:
+ * lexical Jaccard is already near-ceiling on queries that share vocabulary with
+ * their target note, so both providers look identical and you wrongly conclude
+ * "embeddings don't help." So every concept ships two queries:
+ *
+ *   - `lexicalQuery`     — shares content words with the note body. Lexical
+ *                          should win; embeddings should at least tie (do-no-harm).
+ *   - `paraphraseQuery`  — same meaning, DELIBERATELY DISJOINT vocabulary
+ *                          (synonyms only). Lexical should FAIL; a semantic
+ *                          embedder should WIN. This is where the signal lives.
+ *
+ * A subset of concepts additionally plant a `decoy` note in the bank: a note
+ * that shares SURFACE tokens with the paraphrase query but is semantically
+ * unrelated. A lexical scorer is tempted to rank the decoy above the correct
+ * note; a semantic embedder should not. That gives a precision / over-firing
+ * guard ("distractorBeatRate") distinct from recall.
+ *
+ * Authored without an LLM (deterministic, dependency-free) — the synonym pairs
+ * are written by hand precisely so the paraphrase stratum has low lexical
+ * overlap with its targets. `corpusIntegrity()` quantifies that property so the
+ * harness can assert the corpus actually has the trait it claims.
+ */
+export interface KnowledgeConcept {
+    /** Stable note id. */
+    id: string;
+    /** Coarse domain label (also used as the note's domain). */
+    domain: string;
+    /** Note title. */
+    title: string;
+    /** Note body — the canonical knowledge. */
+    body: string;
+    /** Query that shares content words with the body (lexical stratum). */
+    lexicalQuery: string;
+    /** Query with the same meaning but disjoint vocabulary (paraphrase stratum). */
+    paraphraseQuery: string;
+    /**
+     * Optional planted decoy: a note added to the bank that is lexically similar
+     * to `paraphraseQuery` but semantically unrelated to this concept.
+     */
+    decoy?: {
+        id: string;
+        title: string;
+        body: string;
+    };
+}
+export declare const KNOWLEDGE_CONCEPTS: KnowledgeConcept[];
+/** Build the full note bank: one note per concept plus every planted decoy. */
+export declare function buildKnowledgeNotes(concepts?: KnowledgeConcept[]): KnowledgeNote[];
+export type Stratum = 'lexical' | 'paraphrase';
+export interface LabeledKnowledgeQuery {
+    query: string;
+    stratum: Stratum;
+    /** Ground-truth relevant note ids. */
+    relevantIds: string[];
+    /** Planted lexical decoy ids (distractor guard); only set on some paraphrase queries. */
+    decoyIds?: string[];
+}
+/**
+ * Build the stratified query set: one lexical + one paraphrase query per
+ * concept. Paraphrase queries on decoy-bearing concepts carry `decoyIds` so the
+ * harness can measure whether the semantic match outranks the lexical trap.
+ */
+export declare function buildKnowledgeQueries(concepts?: KnowledgeConcept[]): LabeledKnowledgeQuery[];
+export interface CorpusIntegrity {
+    /** Mean lexical similarity of lexicalQuery → its target note body. */
+    lexicalQueryOverlap: number;
+    /** Mean lexical similarity of paraphraseQuery → its target note body. */
+    paraphraseQueryOverlap: number;
+    /**
+     * Among decoy-bearing concepts, the fraction where the planted decoy is at
+     * least as lexically similar to the paraphrase query as the true target is —
+     * i.e. the lexical trap is actually baited.
+     */
+    decoyBaitedRate: number;
+    decoyCount: number;
+}
+/**
+ * Quantify that the corpus has the property it claims: paraphrase queries share
+ * little vocabulary with their targets (so lexical retrieval genuinely fails),
+ * while lexical queries share a lot. If `paraphraseQueryOverlap` is not clearly
+ * below `lexicalQueryOverlap`, the paraphrase stratum cannot discriminate a
+ * semantic provider from a lexical one and the whole signal is invalid.
+ */
+export declare function corpusIntegrity(concepts?: KnowledgeConcept[]): CorpusIntegrity;
+//# sourceMappingURL=knowledge-corpus.d.ts.map

package/dist/eval/retrieval/knowledge-corpus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-corpus.d.ts","sourceRoot":"","sources":["../../../src/eval/retrieval/knowledge-corpus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAI9D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,WAAW,gBAAgB;IAC/B,sBAAsB;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,4DAA4D;IAC5D,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,uEAAuE;IACvE,YAAY,EAAE,MAAM,CAAC;IACrB,gFAAgF;IAChF,eAAe,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,KAAK,CAAC,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CACrD;AAED,eAAO,MAAM,kBAAkB,EAAE,gBAAgB,EAoNhD,CAAC;AAEF,+EAA+E;AAC/E,wBAAgB,mBAAmB,CACjC,QAAQ,GAAE,gBAAgB,EAAuB,GAChD,aAAa,EAAE,CA+BjB;AAED,MAAM,MAAM,OAAO,GAAG,SAAS,GAAG,YAAY,CAAC;AAE/C,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,sCAAsC;IACtC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,yFAAyF;IACzF,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,GAAE,gBAAgB,EAAuB,GAChD,qBAAqB,EAAE,CAYzB;AAED,MAAM,WAAW,eAAe;IAC9B,sEAAsE;IACtE,mBAAmB,EAAE,MAAM,CAAC;IAC5B,yEAAyE;IACzE,sBAAsB,EAAE,MAAM,CAAC;IAC/B;;;;OAIG;IACH,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,GAAE,gBAAgB,EAAuB,GAChD,eAAe,CAwBjB"}

package/dist/eval/retrieval/knowledge-corpus.js

@@ -0,0 +1,268 @@
+import { createObservation } from '../../types/knowledge.js';
+import { textSimilarity } from '../../utils/similarity.js';
+export const KNOWLEDGE_CONCEPTS = [
+    // ---- testing --------------------------------------------------------------
+    {
+        id: 'flaky-order-dependence',
+        domain: 'testing',
+        title: 'Flaky tests from shared mutable state',
+        body: 'Tests that pass alone but fail when run together usually share mutable state. Reset module-level variables between runs, or isolate each case so it cannot see another.',
+        lexicalQuery: 'tests pass alone but fail when run together because they share mutable state',
+        paraphraseQuery: 'specs intermittently break depending on execution sequence after earlier cases leak persistent data',
+    },
+    {
+        id: 'mock-network-calls',
+        domain: 'testing',
+        title: 'Stub external requests in unit tests',
+        body: 'Stub external HTTP requests in unit tests so they run offline and deterministically. A unit test should never reach a real server.',
+        lexicalQuery: 'stub external HTTP requests so unit tests run offline',
+        paraphraseQuery: 'replace outbound API connections with fakes so suites stay independent of the live internet',
+        decoy: {
+            id: 'decoy-offline-mode',
+            title: 'Offline mode for the mobile client',
+            body: 'The mobile client keeps a local connection cache so users can stay independent of the live internet and keep working when the network drops.',
+        },
+    },
+    {
+        id: 'test-coverage-gap',
+        domain: 'testing',
+        title: 'Coverage does not equal correctness',
+        body: 'High line coverage does not guarantee correctness. Branches and edge cases may stay unexercised even when most lines execute.',
+        lexicalQuery: 'high line coverage does not guarantee correctness',
+        paraphraseQuery: 'a large fraction of executed statements still leaves rare conditional paths and boundary inputs unchecked',
+    },
+    // ---- git ------------------------------------------------------------------
+    {
+        id: 'rebase-vs-merge',
+        domain: 'git',
+        title: 'Rebase rewrites history; merge preserves it',
+        body: 'Rebasing rewrites commit history into a linear sequence. Merging preserves the original branch topology by adding a merge commit.',
+        lexicalQuery: 'rebase rewrites commit history into a linear sequence versus merge',
+        paraphraseQuery: 'reapplying patches onto a fresh base yields a straight log, while joining forks keeps the divergent shape',
+        decoy: {
+            id: 'decoy-log-shipping',
+            title: 'Structured application logging',
+            body: 'Configure the application log to write straight to a file with a fresh base set of structured fields on every line.',
+        },
+    },
+    {
+        id: 'detached-head',
+        domain: 'git',
+        title: 'Detached HEAD orphans new commits',
+        body: 'Checking out a specific commit instead of a branch leaves HEAD detached. New commits made there become unreachable once you switch away.',
+        lexicalQuery: 'checking out a commit instead of a branch leaves HEAD detached',
+        paraphraseQuery: 'selecting a bare revision rather than a named pointer means fresh work is abandoned after moving on',
+    },
+    {
+        id: 'force-push-danger',
+        domain: 'git',
+        title: 'Force push can erase teammates work',
+        body: 'Force pushing overwrites the remote branch and can erase commits your teammates pushed. Prefer force-with-lease, which refuses if the remote moved.',
+        lexicalQuery: 'force pushing overwrites the remote branch and can erase teammates commits',
+        paraphraseQuery: 'overriding the upstream reference discards colleagues contributions unless you guard the operation against concurrent updates',
+    },
+    // ---- typescript -----------------------------------------------------------
+    {
+        id: 'structural-typing',
+        domain: 'typescript',
+        title: 'TypeScript uses structural typing',
+        body: 'TypeScript checks types by shape, not by name. Two interfaces with identical members are interchangeable regardless of what they are called.',
+        lexicalQuery: 'TypeScript checks types by shape not by name so identical interfaces are interchangeable',
+        paraphraseQuery: 'the compiler compares object layout rather than declared identity, so equivalently-formed contracts unify',
+        decoy: {
+            id: 'decoy-legal-contracts',
+            title: 'Service contract templates',
+            body: 'Standard service contracts define a clear layout for obligations; identical clauses unify both parties under one agreement.',
+        },
+    },
+    {
+        id: 'any-vs-unknown',
+        domain: 'typescript',
+        title: 'any disables checking; unknown forces narrowing',
+        body: 'The any type disables type checking entirely. The unknown type forces a narrowing check before the value can be used, keeping safety.',
+        lexicalQuery: 'any disables type checking but unknown forces a narrowing check before use',
+        paraphraseQuery: 'one escape hatch switches off verification completely while the other still demands a guard before access',
+    },
+    {
+        id: 'enum-runtime-cost',
+        domain: 'typescript',
+        title: 'Numeric enums emit runtime code',
+        body: 'Numeric enums emit a reverse-mapping object at runtime. Const enums and union literals avoid that overhead by leaving nothing behind.',
+        lexicalQuery: 'numeric enums emit a reverse mapping object at runtime overhead',
+        paraphraseQuery: 'ordinary enumerations generate extra produced output, whereas literal unions stay free at execution',
+    },
+    // ---- database -------------------------------------------------------------
+    {
+        id: 'n-plus-one',
+        domain: 'database',
+        title: 'The N+1 query problem',
+        body: 'Fetching a list and then querying related rows once per item causes N+1 queries. Use a join or a batched eager load to collapse them.',
+        lexicalQuery: 'fetching a list then querying related rows per item causes N+1 queries',
+        paraphraseQuery: 'iterating over results and hitting the datastore separately for each record explodes round-trips; gather associations at once instead',
+        decoy: {
+            id: 'decoy-retail-store',
+            title: 'Retail store restocking',
+            body: 'Each retail store keeps a record of stock per item and gathers seasonal restock orders into one weekly batch.',
+        },
+    },
+    {
+        id: 'index-write-tradeoff',
+        domain: 'database',
+        title: 'Indexes speed reads, slow writes',
+        body: 'Adding an index speeds up reads but slows inserts and updates, because every write must also maintain the index structure.',
+        lexicalQuery: 'adding an index speeds reads but slows inserts and updates',
+        paraphraseQuery: 'an extra lookup structure accelerates retrieval yet penalizes mutations since it requires ongoing upkeep',
+    },
+    {
+        id: 'transaction-isolation',
+        domain: 'database',
+        title: 'Isolation levels trade safety for concurrency',
+        body: 'Lower isolation levels allow dirty reads and phantom rows. Serializable prevents them but reduces concurrency by serializing conflicting transactions.',
+        lexicalQuery: 'lower isolation levels allow dirty reads and phantom rows unlike serializable',
+        paraphraseQuery: 'relaxed consistency settings permit observing uncommitted or newly-appearing records, while the strictest tier blocks that at the price of parallelism',
+    },
+    // ---- async / runtime ------------------------------------------------------
+    {
+        id: 'event-loop-blocking',
+        domain: 'async',
+        title: 'Synchronous CPU work blocks the event loop',
+        body: 'Long synchronous CPU work blocks the Node event loop and stalls every pending callback. Offload heavy computation to a worker thread.',
+        lexicalQuery: 'long synchronous CPU work blocks the Node event loop and stalls callbacks',
+        paraphraseQuery: 'heavy in-line computation freezes the single-threaded scheduler and delays every queued task; move it to a separate worker',
+        decoy: {
+            id: 'decoy-calendar-scheduler',
+            title: 'Calendar task scheduler',
+            body: 'The calendar scheduler lets users arrange tasks into time blocks and view every queued item in a weekly thread.',
+        },
+    },
+    {
+        id: 'promise-unhandled',
+        domain: 'async',
+        title: 'Unhandled promise rejections can crash',
+        body: 'A rejected promise with no catch handler triggers an unhandled rejection, which in newer Node versions can terminate the process.',
+        lexicalQuery: 'a rejected promise with no catch handler triggers an unhandled rejection',
+        paraphraseQuery: 'an asynchronous failure lacking a recovery clause surfaces as an uncaught error and may shut down the runtime',
+    },
+    {
+        id: 'race-condition-cache',
+        domain: 'async',
+        title: 'Cache stampede from concurrent misses',
+        body: 'Two concurrent requests can both miss the cache and recompute the same expensive value. Use a single-flight lock so only one computes while others wait.',
+        lexicalQuery: 'concurrent requests both miss the cache and recompute the same value',
+        paraphraseQuery: 'simultaneous lookups each find nothing stored and redundantly redo the costly work; collapse them behind one shared sentinel',
+        decoy: {
+            id: 'decoy-security-guard',
+            title: 'Security guard shift coverage',
+            body: 'One shared sentinel covers simultaneous shifts at the entrance, and redundant badge swipes are collapsed at the gate.',
+        },
+    },
+    // ---- security / http ------------------------------------------------------
+    {
+        id: 'sql-injection',
+        domain: 'security',
+        title: 'SQL injection from string interpolation',
+        body: 'Interpolating user input directly into SQL strings allows injection attacks. Use parameterized queries so input is treated as data, never as code.',
+        lexicalQuery: 'interpolating user input into SQL strings allows injection use parameterized queries',
+        paraphraseQuery: 'splicing untrusted submitted fields straight into database commands enables exploits; bind the arguments instead of concatenating',
+        decoy: {
+            id: 'decoy-form-validation',
+            title: 'Client-side form validation',
+            body: 'Validate submitted fields in the browser and bind each input to the model before sending the database the final record.',
+        },
+    },
+    {
+        id: 'cors-preflight',
+        domain: 'security',
+        title: 'CORS preflight for cross-origin requests',
+        body: 'Browsers send an OPTIONS preflight before cross-origin requests that carry custom headers. The server must respond allowing the method and headers.',
+        lexicalQuery: 'browsers send an OPTIONS preflight for cross-origin requests with custom headers',
+        paraphraseQuery: 'the client issues a preliminary probe ahead of non-simple cross-site calls, and the backend has to whitelist that handshake',
+    },
+    {
+        id: 'jwt-expiry',
+        domain: 'security',
+        title: 'JWTs cannot be revoked before expiry',
+        body: 'Stateless JWTs cannot be revoked before they expire. Keep token lifetimes short and pair them with a refresh token to limit the blast radius.',
+        lexicalQuery: 'stateless JWTs cannot be revoked before expiry keep lifetimes short',
+        paraphraseQuery: 'self-contained bearer credentials stay valid until they lapse, so use brief windows plus a renewal mechanism to bound exposure',
+    },
+];
+/** Build the full note bank: one note per concept plus every planted decoy. */
+export function buildKnowledgeNotes(concepts = KNOWLEDGE_CONCEPTS) {
+    const notes = [];
+    for (const c of concepts) {
+        notes.push(createObservation({
+            id: c.id,
+            title: c.title,
+            body: c.body,
+            domain: [c.domain],
+            entities: [],
+            tags: [],
+            confidence: 0.8,
+            source: { origin: 'extracted' },
+        }));
+        if (c.decoy) {
+            notes.push(createObservation({
+                id: c.decoy.id,
+                title: c.decoy.title,
+                body: c.decoy.body,
+                domain: [c.domain],
+                entities: [],
+                tags: [],
+                confidence: 0.8,
+                source: { origin: 'extracted' },
+            }));
+        }
+    }
+    return notes;
+}
+/**
+ * Build the stratified query set: one lexical + one paraphrase query per
+ * concept. Paraphrase queries on decoy-bearing concepts carry `decoyIds` so the
+ * harness can measure whether the semantic match outranks the lexical trap.
+ */
+export function buildKnowledgeQueries(concepts = KNOWLEDGE_CONCEPTS) {
+    const queries = [];
+    for (const c of concepts) {
+        queries.push({ query: c.lexicalQuery, stratum: 'lexical', relevantIds: [c.id] });
+        queries.push({
+            query: c.paraphraseQuery,
+            stratum: 'paraphrase',
+            relevantIds: [c.id],
+            ...(c.decoy ? { decoyIds: [c.decoy.id] } : {}),
+        });
+    }
+    return queries;
+}
+/**
+ * Quantify that the corpus has the property it claims: paraphrase queries share
+ * little vocabulary with their targets (so lexical retrieval genuinely fails),
+ * while lexical queries share a lot. If `paraphraseQueryOverlap` is not clearly
+ * below `lexicalQueryOverlap`, the paraphrase stratum cannot discriminate a
+ * semantic provider from a lexical one and the whole signal is invalid.
+ */
+export function corpusIntegrity(concepts = KNOWLEDGE_CONCEPTS) {
+    let lexSum = 0;
+    let paraSum = 0;
+    let decoyBaited = 0;
+    let decoyCount = 0;
+    for (const c of concepts) {
+        lexSum += textSimilarity(c.lexicalQuery, c.body);
+        paraSum += textSimilarity(c.paraphraseQuery, c.body);
+        if (c.decoy) {
+            decoyCount++;
+            const targetSim = textSimilarity(c.paraphraseQuery, c.body);
+            const decoySim = textSimilarity(c.paraphraseQuery, c.decoy.body);
+            if (decoySim >= targetSim)
+                decoyBaited++;
+        }
+    }
+    const n = concepts.length || 1;
+    return {
+        lexicalQueryOverlap: lexSum / n,
+        paraphraseQueryOverlap: paraSum / n,
+        decoyBaitedRate: decoyCount ? decoyBaited / decoyCount : 0,
+        decoyCount,
+    };
+}
+//# sourceMappingURL=knowledge-corpus.js.map

package/dist/eval/retrieval/knowledge-corpus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-corpus.js","sourceRoot":"","sources":["../../../src/eval/retrieval/knowledge-corpus.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAiD3D,MAAM,CAAC,MAAM,kBAAkB,GAAuB;IACpD,8EAA8E;IAC9E;QACE,EAAE,EAAE,wBAAwB;QAC5B,MAAM,EAAE,SAAS;QACjB,KAAK,EAAE,uCAAuC;QAC9C,IAAI,EAAE,yKAAyK;QAC/K,YAAY,EAAE,8EAA8E;QAC5F,eAAe,EACb,qGAAqG;KACxG;IACD;QACE,EAAE,EAAE,oBAAoB;QACxB,MAAM,EAAE,SAAS;QACjB,KAAK,EAAE,sCAAsC;QAC7C,IAAI,EAAE,oIAAoI;QAC1I,YAAY,EAAE,uDAAuD;QACrE,eAAe,EACb,6FAA6F;QAC/F,KAAK,EAAE;YACL,EAAE,EAAE,oBAAoB;YACxB,KAAK,EAAE,oCAAoC;YAC3C,IAAI,EAAE,8IAA8I;SACrJ;KACF;IACD;QACE,EAAE,EAAE,mBAAmB;QACvB,MAAM,EAAE,SAAS;QACjB,KAAK,EAAE,qCAAqC;QAC5C,IAAI,EAAE,+HAA+H;QACrI,YAAY,EAAE,mDAAmD;QACjE,eAAe,EACb,2GAA2G;KAC9G;IAED,8EAA8E;IAC9E;QACE,EAAE,EAAE,iBAAiB;QACrB,MAAM,EAAE,KAAK;QACb,KAAK,EAAE,6CAA6C;QACpD,IAAI,EAAE,mIAAmI;QACzI,YAAY,EAAE,oEAAoE;QAClF,eAAe,EACb,2GAA2G;QAC7G,KAAK,EAAE;YACL,EAAE,EAAE,oBAAoB;YACxB,KAAK,EAAE,gCAAgC;YACvC,IAAI,EAAE,qHAAqH;SAC5H;KACF;IACD;QACE,EAAE,EAAE,eAAe;QACnB,MAAM,EAAE,KAAK;QACb,KAAK,EAAE,mCAAmC;QAC1C,IAAI,EAAE,0IAA0I;QAChJ,YAAY,EAAE,gEAAgE;QAC9E,eAAe,EACb,qGAAqG;KACxG;IACD;QACE,EAAE,EAAE,mBAAmB;QACvB,MAAM,EAAE,KAAK;QACb,KAAK,EAAE,qCAAqC;QAC5C,IAAI,EAAE,qJAAqJ;QAC3J,YAAY,EAAE,4EAA4E;QAC1F,eAAe,EACb,+HAA+H;KAClI;IAED,8EAA8E;IAC9E;QACE,EAAE,EAAE,mBAAmB;QACvB,MAAM,EAAE,YAAY;QACpB,KAAK,EAAE,mCAAmC;QAC1C,IAAI,EAAE,8IAA8I;QACpJ,YAAY,EACV,0FAA0F;QAC5F,eAAe,EACb,2GAA2G;QAC7G,KAAK,EAAE;YACL,EAAE,EAAE,uBAAuB;YAC3B,KAAK,EAAE,4BAA4B;YACnC,IAAI,EAAE,6HAA6H;SACpI;KACF;IACD;QACE,EAAE,EAAE,gBAAgB;QACpB,MAAM,EAAE,YAAY;QACpB,KAAK,EAAE,iDAAiD;QACxD,IAAI,EAAE,uIAAuI;QAC7I,YAAY,EAAE,4EAA4E;QAC1F,eAAe,EACb,2GAA2G;KAC9G;IACD;QACE,EAAE,EAAE,mBAAmB;QACvB,MAAM,EAAE,YAAY;QACpB,KAAK,EAAE,iCAAiC;QACxC,IAAI,EAAE,uIAAuI;QAC7I,YAAY,EAAE,iEAAiE;QAC/E,eAAe,EACb,qGAAqG;KACxG;IAED,8EAA8E;IAC9E;QACE,EAAE,EAAE,YAAY;QAChB,MAAM,EAAE,UAAU;QAClB,KAAK,EAAE,uBAAuB;QAC9B,IAAI,EAAE,uIAAuI;QAC7I,YAAY,EAAE,wEAAwE;QACtF,eAAe,EACb,uIAAuI;QACzI,KAAK,EAAE;YACL,EAAE,EAAE,oBAAoB;YACxB,KAAK,EAAE,yBAAyB;YAChC,IAAI,EAAE,+GAA+G;SACtH;KACF;IACD;QACE,EAAE,EAAE,sBAAsB;QAC1B,MAAM,EAAE,UAAU;QAClB,KAAK,EAAE,kCAAkC;QACzC,IAAI,EAAE,4HAA4H;QAClI,YAAY,EAAE,4DAA4D;QAC1E,eAAe,EACb,0GAA0G;KAC7G;IACD;QACE,EAAE,EAAE,uBAAuB;QAC3B,MAAM,EAAE,UAAU;QAClB,KAAK,EAAE,+CAA+C;QACtD,IAAI,EAAE,wJAAwJ;QAC9J,YAAY,EAAE,+EAA+E;QAC7F,eAAe,EACb,wJAAwJ;KAC3J;IAED,8EAA8E;IAC9E;QACE,EAAE,EAAE,qBAAqB;QACzB,MAAM,EAAE,OAAO;QACf,KAAK,EAAE,4CAA4C;QACnD,IAAI,EAAE,uIAAuI;QAC7I,YAAY,EAAE,2EAA2E;QACzF,eAAe,EACb,4HAA4H;QAC9H,KAAK,EAAE;YACL,EAAE,EAAE,0BAA0B;YAC9B,KAAK,EAAE,yBAAyB;YAChC,IAAI,EAAE,iHAAiH;SACxH;KACF;IACD;QACE,EAAE,EAAE,mBAAmB;QACvB,MAAM,EAAE,OAAO;QACf,KAAK,EAAE,wCAAwC;QAC/C,IAAI,EAAE,mIAAmI;QACzI,YAAY,EAAE,0EAA0E;QACxF,eAAe,EACb,+GAA+G;KAClH;IACD;QACE,EAAE,EAAE,sBAAsB;QAC1B,MAAM,EAAE,OAAO;QACf,KAAK,EAAE,uCAAuC;QAC9C,IAAI,EAAE,0JAA0J;QAChK,YAAY,EAAE,sEAAsE;QACpF,eAAe,EACb,8HAA8H;QAChI,KAAK,EAAE;YACL,EAAE,EAAE,sBAAsB;YAC1B,KAAK,EAAE,+BAA+B;YACtC,IAAI,EAAE,uHAAuH;SAC9H;KACF;IAED,8EAA8E;IAC9E;QACE,EAAE,EAAE,eAAe;QACnB,MAAM,EAAE,UAAU;QAClB,KAAK,EAAE,yCAAyC;QAChD,IAAI,EAAE,oJAAoJ;QAC1J,YAAY,EACV,sFAAsF;QACxF,eAAe,EACb,mIAAmI;QACrI,KAAK,EAAE;YACL,EAAE,EAAE,uBAAuB;YAC3B,KAAK,EAAE,6BAA6B;YACpC,IAAI,EAAE,yHAAyH;SAChI;KACF;IACD;QACE,EAAE,EAAE,gBAAgB;QACpB,MAAM,EAAE,UAAU;QAClB,KAAK,EAAE,0CAA0C;QACjD,IAAI,EAAE,qJAAqJ;QAC3J,YAAY,EACV,kFAAkF;QACpF,eAAe,EACb,6HAA6H;KAChI;IACD;QACE,EAAE,EAAE,YAAY;QAChB,MAAM,EAAE,UAAU;QAClB,KAAK,EAAE,sCAAsC;QAC7C,IAAI,EAAE,+IAA+I;QACrJ,YAAY,EAAE,qEAAqE;QACnF,eAAe,EACb,gIAAgI;KACnI;CACF,CAAC;AAEF,+EAA+E;AAC/E,MAAM,UAAU,mBAAmB,CACjC,WAA+B,kBAAkB;IAEjD,MAAM,KAAK,GAAoB,EAAE,CAAC;IAClC,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;QACzB,KAAK,CAAC,IAAI,CACR,iBAAiB,CAAC;YAChB,EAAE,EAAE,CAAC,CAAC,EAAE;YACR,KAAK,EAAE,CAAC,CAAC,KAAK;YACd,IAAI,EAAE,CAAC,CAAC,IAAI;YACZ,MAAM,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;YAClB,QAAQ,EAAE,EAAE;YACZ,IAAI,EAAE,EAAE;YACR,UAAU,EAAE,GAAG;YACf,MAAM,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE;SAChC,CAAC,CACH,CAAC;QACF,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC;YACZ,KAAK,CAAC,IAAI,CACR,iBAAiB,CAAC;gBAChB,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,EAAE;gBACd,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK;gBACpB,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,IAAI;gBAClB,MAAM,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;gBAClB,QAAQ,EAAE,EAAE;gBACZ,IAAI,EAAE,EAAE;gBACR,UAAU,EAAE,GAAG;gBACf,MAAM,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE;aAChC,CAAC,CACH,CAAC;QACJ,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAaD;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CACnC,WAA+B,kBAAkB;IAEjD,MAAM,OAAO,GAA4B,EAAE,CAAC;IAC5C,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;QACzB,OAAO,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,YAAY,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QACjF,OAAO,CAAC,IAAI,CAAC;YACX,KAAK,EAAE,CAAC,CAAC,eAAe;YACxB,OAAO,EAAE,YAAY;YACrB,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACnB,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAC/C,CAAC,CAAC;IACL,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAgBD;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAC7B,WAA+B,kBAAkB;IAEjD,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,IAAI,WAAW,GAAG,CAAC,CAAC;IACpB,IAAI,UAAU,GAAG,CAAC,CAAC;IAEnB,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;QACzB,MAAM,IAAI,cAAc,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC;QACjD,OAAO,IAAI,cAAc,CAAC,CAAC,CAAC,eAAe,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC;QACrD,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC;YACZ,UAAU,EAAE,CAAC;YACb,MAAM,SAAS,GAAG,cAAc,CAAC,CAAC,CAAC,eAAe,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC;YAC5D,MAAM,QAAQ,GAAG,cAAc,CAAC,CAAC,CAAC,eAAe,EAAE,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACjE,IAAI,QAAQ,IAAI,SAAS;gBAAE,WAAW,EAAE,CAAC;QAC3C,CAAC;IACH,CAAC;IAED,MAAM,CAAC,GAAG,QAAQ,CAAC,MAAM,IAAI,CAAC,CAAC;IAC/B,OAAO;QACL,mBAAmB,EAAE,MAAM,GAAG,CAAC;QAC/B,sBAAsB,EAAE,OAAO,GAAG,CAAC;QACnC,eAAe,EAAE,UAAU,CAAC,CAAC,CAAC,WAAW,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;QAC1D,UAAU;KACX,CAAC;AACJ,CAAC"}