@weftlet/toolkit 0.7.2 → 0.7.4

package/README.md

@@ -14,7 +14,7 @@ Proposed future capabilities are recorded in the [Weftlet 2.0 product plan](docs
 ## Set up a project
 
 <!-- weftlet:release:start -->
-Package versions in this checkout/archive: `@weftlet/toolkit@0.7.2` and `@weftlet/core@0.7.2`.
+Package versions in this checkout/archive: `@weftlet/toolkit@0.7.4` and `@weftlet/core@0.7.4`.
 <!-- weftlet:release:end -->
 
 Weftlet uses `@weftlet/toolkit`; its neutral `@weftlet/core` dependency is installed
@@ -486,10 +486,14 @@ pending re-extraction. Queries compare captured file digests with current workin
 report subsequent edits separately from captured and excluded changes. Older overlays without
 capture metadata have unknown freshness. Historical or draft evidence cannot validate a current diff.
 
-Impact queries [rank nearby consumers and varied evidence sources](docs/ADR-041-bounded-relationship-retrieval.md)
+Impact queries [give near and indirect relationships bounded turns](docs/ADR-042-indirect-local-relationships.md)
 ahead of repeated detail and shared-import context. Ranking changes ordering, not saved facts or
-the reachable scope. Saved local calls, their exact references and consumer relationships precede dense local-variable
-detail within each source; unindexed symbol hubs receive a penalty unless explicitly queried.
+the reachable scope. Calls, cross-file references (including those without call proof) and file
+consumers share turns across distance groups, with source diversity within each group. Local
+detail has its own turns; unindexed symbol hubs follow local evidence unless explicitly queried.
+[Shared-symbol specificity](docs/ADR-043-shared-symbol-specificity.md) also gives turns to
+indexed consumers sharing a selectively referenced symbol with the producer. File-scope
+joins alone do not supply that signal. Equal evidence can still exceed a bounded page budget.
 These are ordering signals, not new assertions or proof of execution. All evidence remains in
 the reachable set. Responses identify the ranking version; after a ranking upgrade, restart
 scans whose old continuation tokens are rejected. No snapshot refresh is needed for new ordering.

package/dist/graph/impact-affinity-order.d.ts

@@ -0,0 +1,11 @@
+import type { GraphFact } from '@weftlet/core';
+import { type ImpactOrderRow } from './impact-order.js';
+/** Interleave specificity with baseline waves, retaining every assertion exactly
+ * once and preserving evidence-lane balancing. No affinity means exact v3 order. */
+export declare function interleaveAffinity(rows: ImpactOrderRow[], baseline: readonly {
+    fact: GraphFact;
+    score: number;
+}[], affinity: ReadonlyMap<string, number>): readonly {
+    fact: GraphFact;
+    score: number;
+}[];

package/dist/graph/impact-affinity-order.js

@@ -0,0 +1,53 @@
+import { sourceQueue } from './impact-order.js';
+/** Balance reference/consumer families and sources within a specificity cohort.
+ * A later occurrence can surface without waiting for every unrelated local file. */
+function affinityQueue(rows, affinity) {
+    const cohorts = new Map();
+    for (const row of rows) {
+        const degree = affinity.get(row.fact.id);
+        if (degree === undefined || row.contextOnly || !['references', 'consumes'].includes(row.fact.predicate))
+            continue;
+        const group = cohorts.get(degree) ?? [];
+        group.push(row);
+        cohorts.set(degree, group);
+    }
+    const ordered = [];
+    for (const [, cohort] of [...cohorts].sort(([a], [b]) => a - b)) {
+        const queues = ['references', 'consumes'].map(predicate => sourceQueue(cohort.filter(row => row.fact.predicate === predicate)));
+        let remaining = cohort.length;
+        while (remaining > 0)
+            for (const next of queues) {
+                const row = next();
+                if (row) {
+                    ordered.push(row.fact);
+                    remaining--;
+                }
+            }
+    }
+    return ordered;
+}
+/** Interleave specificity with baseline waves, retaining every assertion exactly
+ * once and preserving evidence-lane balancing. No affinity means exact v3 order. */
+export function interleaveAffinity(rows, baseline, affinity) {
+    if (!affinity.size)
+        return baseline;
+    const queue = affinityQueue(rows, affinity), emitted = new Set();
+    const result = [];
+    let cursor = 0;
+    const push = (fact, score) => {
+        if (!emitted.has(fact.id)) {
+            result.push({ fact, score });
+            emitted.add(fact.id);
+        }
+    };
+    for (const { fact, score } of baseline) {
+        if (emitted.has(fact.id))
+            continue;
+        while (cursor < queue.length && emitted.has(queue[cursor].id))
+            cursor++;
+        if (cursor < queue.length)
+            push(queue[cursor++], score);
+        push(fact, score);
+    }
+    return result;
+}

package/dist/graph/impact-affinity.d.ts

@@ -0,0 +1,6 @@
+import { type GraphFact } from '@weftlet/core';
+/** Structural relevance from producer -> shared symbol <- other indexed symbol.
+ * Smaller distinct production referrer counts are more specific, not more true.
+ * File/module anchors, locations alone and unknown projections cannot supply this
+ * signal. All assertions (including tests) remain in the baseline ordering. */
+export declare function sharedSymbolAffinity(facts: readonly GraphFact[], direct: readonly GraphFact[], anchorTerms: readonly string[]): ReadonlyMap<string, number>;

package/dist/graph/impact-affinity.js

@@ -0,0 +1,91 @@
+import { repositoryFileNode, sha256 } from '@weftlet/core';
+const sameExtraction = (a, b) => a.snapshotId === b.snapshotId &&
+    a.provenance.commitSha === b.provenance.commitSha && a.extractor.id === b.extractor.id &&
+    a.extractor.version === b.extractor.version;
+const indexedName = (node) => node.kind === 'CodeSymbol' &&
+    node.codeSymbol?.provider === 'scip-typescript' && node.codeSymbol.identityScope === 'repository' &&
+    node.codeSymbol.resolution === 'indexed-definition' && !node.codeSymbol.nativeSymbol.endsWith('/');
+// Keys describe corroborating saved evidence, never a new native/legacy identity edge.
+const projectionKey = (fact, native) => JSON.stringify([fact.snapshotId,
+    fact.provenance.commitSha, fact.provenance.digest, fact.provenance.path,
+    fact.extractor.id, fact.extractor.version, native]);
+const witnessKey = (fact) => JSON.stringify([fact.snapshotId, fact.provenance.commitSha,
+    fact.extractor.id, fact.extractor.version, fact.object.id]);
+/** Structural relevance from producer -> shared symbol <- other indexed symbol.
+ * Smaller distinct production referrer counts are more specific, not more true.
+ * File/module anchors, locations alone and unknown projections cannot supply this
+ * signal. All assertions (including tests) remain in the baseline ordering. */
+export function sharedSymbolAffinity(facts, direct, anchorTerms) {
+    if (!anchorTerms.length)
+        return new Map();
+    const definitions = new Map();
+    for (const fact of facts) {
+        if (fact.extractor.id !== 'scip-symbol-extractor' || fact.predicate !== 'definedBy' ||
+            fact.codeOccurrence?.role !== 'definition' || fact.codeOccurrence.locationKind !== 'name' ||
+            !indexedName(fact.subject) || fact.object.id !== repositoryFileNode(fact.provenance.path).id)
+            continue;
+        const group = definitions.get(fact.subject.id) ?? [];
+        group.push(fact);
+        definitions.set(fact.subject.id, group);
+    }
+    const eligible = (node, fact) => indexedName(node) &&
+        definitions.get(node.id)?.some(def => sameExtraction(def, fact)) === true;
+    const production = (node, fact) => definitions.get(node.id)?.some(def => sameExtraction(def, fact) && repositoryFileNode(def.provenance.path).kind === 'Component') === true;
+    const origins = new Set(direct.filter(fact => fact.predicate === 'definedBy' &&
+        definitions.get(fact.subject.id)?.some(def => def.id === fact.id)).map(fact => fact.subject.id));
+    if (!origins.size)
+        return new Map();
+    const references = facts.filter(fact => fact.predicate === 'references' &&
+        fact.codeOccurrence?.role === 'reference' && fact.codeOccurrence.locationKind === 'name' &&
+        fact.extractor.id === 'scip-symbol-extractor' && eligible(fact.subject, fact) && eligible(fact.object, fact) &&
+        fact.subject.codeSymbol.repositoryId === fact.object.codeSymbol.repositoryId);
+    const shared = new Map();
+    for (const fact of references)
+        if (origins.has(fact.subject.id)) {
+            shared.set(witnessKey(fact), { referrers: new Set(), members: [] });
+        }
+    for (const fact of references) {
+        const group = shared.get(witnessKey(fact));
+        if (!group)
+            continue;
+        if (production(fact.subject, fact))
+            group.referrers.add(fact.subject.id);
+        if (!origins.has(fact.subject.id))
+            group.members.push(fact);
+    }
+    // Include the extraction scope: stale evidence cannot become a current witness.
+    const subjectKey = (fact) => JSON.stringify([fact.snapshotId, fact.provenance.commitSha,
+        fact.extractor.id, fact.extractor.version, fact.subject.id]);
+    const affinity = new Map();
+    for (const group of shared.values())
+        for (const fact of group.members) {
+            const key = subjectKey(fact), count = Math.max(1, group.referrers.size);
+            affinity.set(key, Math.min(affinity.get(key) ?? Infinity, count));
+        }
+    const result = new Map(), projections = new Map();
+    for (const fact of references) {
+        const degree = affinity.get(subjectKey(fact));
+        if (degree === undefined)
+            continue;
+        result.set(fact.id, degree);
+        const key = projectionKey(fact, fact.object.codeSymbol.nativeSymbol);
+        projections.set(key, Math.min(projections.get(key) ?? Infinity, degree));
+    }
+    const legacyIds = new Map();
+    for (const fact of facts) {
+        if (fact.predicate !== 'consumes' || fact.extractor.id !== 'scip-symbol-extractor' ||
+            fact.subject.id !== repositoryFileNode(fact.provenance.path).id || fact.object.kind !== 'Contract')
+            continue;
+        const degree = projections.get(projectionKey(fact, fact.object.label));
+        if (degree === undefined)
+            continue;
+        let id = legacyIds.get(fact.object.label);
+        if (!id) {
+            id = `symbol:scip:${sha256(fact.object.label)}`;
+            legacyIds.set(fact.object.label, id);
+        }
+        if (fact.object.id === id)
+            result.set(fact.id, degree);
+    }
+    return result;
+}

package/dist/graph/impact-order.d.ts

@@ -0,0 +1,21 @@
+import type { GraphFact } from '@weftlet/core';
+export interface ImpactOrderRow {
+    readonly fact: GraphFact;
+    readonly proximity: number;
+    readonly relationshipOrder: number;
+    readonly contextOnly: boolean;
+    readonly focus: number;
+    readonly tie: string;
+}
+/** One source per turn within a distance/family bucket, without adding an
+ * unbounded source ordinal to graph distance. Every input row is retained. */
+export declare function sourceQueue(rows: ImpactOrderRow[]): () => ImpactOrderRow | undefined;
+/** Ordering waves preserve evidence-lane balancing in the query facade. Near
+ * and indirect relationships each get turns (two slots for calls, references
+ * and consumers, one for other relations); local detail also gets one slot
+ * per wave. Unindexed/shared-import context follows local evidence unless it
+ * was explicitly queried. No assertion, citation or authority is rewritten. */
+export declare function orderImpactRows(rows: ImpactOrderRow[]): {
+    fact: GraphFact;
+    score: number;
+}[];

package/dist/graph/impact-order.js

@@ -0,0 +1,77 @@
+/** Fixed distance bands prevent thousands of first-hop sources from exhausting
+ * every page before any second-hop evidence gets a turn. They do not bound scope. */
+function distanceBand(distance) {
+    return distance < 4 ? distance : distance < 8 ? 4 : 5;
+}
+function family(fact) {
+    if (fact.predicate === 'calls' || fact.predicate === 'references' || fact.predicate === 'consumes')
+        return fact.predicate;
+    return 'other';
+}
+const lexical = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+const compare = (a, b) => b.focus - a.focus ||
+    a.proximity - b.proximity || lexical(a.tie, b.tie) || lexical(a.fact.id, b.fact.id);
+/** One source per turn within a distance/family bucket, without adding an
+ * unbounded source ordinal to graph distance. Every input row is retained. */
+export function sourceQueue(rows) {
+    const sources = new Map();
+    for (const row of rows.sort(compare)) {
+        const group = sources.get(row.fact.provenance.path) ?? [];
+        group.push(row);
+        sources.set(row.fact.provenance.path, group);
+    }
+    let active = [...sources.values()].map(rows => ({ rows, offset: 0 }));
+    let cursor = 0;
+    return () => {
+        if (!active.length)
+            return undefined;
+        if (cursor === active.length) {
+            active = active.filter(source => source.offset < source.rows.length);
+            cursor = 0;
+        }
+        const source = active[cursor++];
+        return source?.rows[source.offset++];
+    };
+}
+/** Ordering waves preserve evidence-lane balancing in the query facade. Near
+ * and indirect relationships each get turns (two slots for calls, references
+ * and consumers, one for other relations); local detail also gets one slot
+ * per wave. Unindexed/shared-import context follows local evidence unless it
+ * was explicitly queried. No assertion, citation or authority is rewritten. */
+export function orderImpactRows(rows) {
+    const result = [];
+    let wave = 0;
+    for (const contextOnly of [false, true]) {
+        const selected = rows.filter(row => row.contextOnly === contextOnly);
+        const buckets = new Map();
+        const details = [];
+        for (const row of selected) {
+            if (row.relationshipOrder > 0) {
+                details.push(row);
+                continue;
+            }
+            const key = `${distanceBand(row.proximity)}:${family(row.fact)}`;
+            const bucket = buckets.get(key) ?? [];
+            bucket.push(row);
+            buckets.set(key, bucket);
+        }
+        const queues = [...buckets].sort(([a], [b]) => lexical(a, b))
+            .map(([key, group]) => ({ next: sourceQueue(group), slots: key.endsWith(':other') ? 1 : 2 }));
+        if (details.length)
+            queues.push({ next: sourceQueue(details), slots: 1 });
+        let remaining = selected.length;
+        while (remaining > 0) {
+            for (const { next, slots } of queues) {
+                for (let slot = 0; slot < slots; slot++) {
+                    const row = next();
+                    if (row) {
+                        result.push({ fact: row.fact, score: wave });
+                        remaining--;
+                    }
+                }
+            }
+            wave++;
+        }
+    }
+    return result;
+}

package/dist/graph/impact-signals.d.ts

@@ -3,5 +3,6 @@ import type { GraphFact, GraphNode } from '@weftlet/core';
 export declare function impactRankingSignals(facts: readonly GraphFact[], anchorTerms: readonly string[]): {
     penalty: (fact: GraphFact) => 0 | 8;
     seedNodes: (fact: GraphFact) => GraphNode[];
-    relationshipOrder: (fact: GraphFact) => 0 | 2 | 1;
+    relationshipOrder: (fact: GraphFact) => 0 | 2;
+    contextOnly: (fact: GraphFact) => boolean;
 };

package/dist/graph/impact-signals.js

@@ -2,7 +2,6 @@
 export function impactRankingSignals(facts, anchorTerms) {
     const definitions = new Map();
     const callsiteReferences = new Set();
-    const callableNativeSymbols = new Set();
     const localCall = (fact) => fact.predicate === 'calls' && fact.codeCall !== undefined &&
         fact.codeCall.target !== 'external' && fact.codeCall.targetDefinitions.length > 0;
     for (const fact of facts) {
@@ -14,8 +13,6 @@ export function impactRankingSignals(facts, anchorTerms) {
         if (localCall(fact)) {
             for (const proof of fact.codeCall.targetOccurrences)
                 callsiteReferences.add(proof.factId);
-            if (fact.object.codeSymbol)
-                callableNativeSymbols.add(fact.object.codeSymbol.nativeSymbol);
         }
     }
     const explicit = (node) => anchorTerms.some(term => `${node.id} ${node.label} ${node.codeSymbol?.nativeSymbol ?? ''}`.toLowerCase().includes(term));
@@ -36,19 +33,22 @@ export function impactRankingSignals(facts, anchorTerms) {
     const relationshipOrder = (fact) => {
         if (localCall(fact) || callsiteReferences.has(fact.id))
             return 0;
-        if (fact.predicate === 'consumes' && fact.object.id.startsWith('symbol:scip:') &&
-            callableNativeSymbols.has(fact.object.label))
-            return 0;
         if (fact.codeOccurrence?.role === 'reference') {
             if (explicit(fact.object))
                 return 0;
             const targetPaths = definitions.get(fact.object.id);
+            // A saved reference across repository files is useful without a native
+            // call proof. This only changes its query order, never its predicate.
             if (targetPaths && [...targetPaths].some(path => path !== fact.provenance.path))
-                return 1;
+                return 0;
         }
         if (fact.codeOccurrence || fact.codeCall)
             return 2;
+        if (fact.predicate === 'contains' && (fact.subject.kind === 'Project' ||
+            fact.object.kind === 'CodeSymbol' || fact.object.id.startsWith('symbol:scip:')))
+            return 2;
         return 0; // Keep intent, queue/data contracts, validation and legacy adapter relations available.
     };
-    return { penalty, seedNodes, relationshipOrder };
+    const contextOnly = (fact) => [fact.subject, fact.object].some(node => hub(node) || (node.id.startsWith('contract:module:') && !explicit(node)));
+    return { penalty, seedNodes, relationshipOrder, contextOnly };
 }

package/dist/graph/query.js

@@ -203,7 +203,7 @@ export class SnapshotImpactQueryService {
             tier.push(fact);
             tiers.set(score, tier);
         }
-        // Balance evidence lanes among similarly ranked facts, not across unrelated distance tiers.
+        // Balance evidence lanes within each ordering wave; retain the scorer's wave boundaries.
         const allBalanced = [...tiers.values()].flatMap((tier) => [
             ...selectBalancedFacts(tier, tier.length),
             ...tier.filter((fact) => contextPackLaneForFact(fact) === undefined),

package/dist/graph/ranking.d.ts

@@ -1,6 +1,6 @@
 import type { GraphFact } from '@weftlet/core';
 /** Binds continuation offsets to the ordering policy; changing this requires restarting a scan. */
-export declare const IMPACT_RANKING_VERSION = "local-relationships-diversity-v2";
+export declare const IMPACT_RANKING_VERSION = "shared-symbol-witnesses-v4";
 export declare function factSearchText(fact: GraphFact): string;
 export interface RankedImpactFact {
     readonly fact: GraphFact;

package/dist/graph/ranking.js

@@ -1,7 +1,10 @@
 import { stableJson } from '../infrastructure/util.js';
 import { impactRankingSignals } from './impact-signals.js';
+import { orderImpactRows } from './impact-order.js';
+import { sharedSymbolAffinity } from './impact-affinity.js';
+import { interleaveAffinity } from './impact-affinity-order.js';
 /** Binds continuation offsets to the ordering policy; changing this requires restarting a scan. */
-export const IMPACT_RANKING_VERSION = 'local-relationships-diversity-v2';
+export const IMPACT_RANKING_VERSION = 'shared-symbol-witnesses-v4';
 export function factSearchText(fact) {
     return [fact.subject.id, fact.subject.label, fact.predicate, fact.object.id,
         fact.object.label, fact.provenance.path].join(' ').toLowerCase();
@@ -69,25 +72,10 @@ export function rankImpactFacts(facts, direct, anchorTerms, focus) {
             fact,
             proximity: costs.get(fact) + (directIds.has(fact.id) ? 0 : Math.min((distance.get(fact.subject.id) ?? Infinity) + cost(fact, true), (distance.get(fact.object.id) ?? Infinity) + cost(fact, false))),
             relationshipOrder: signals.relationshipOrder(fact),
+            contextOnly: signals.contextOnly(fact),
             focus: focus.filter((term) => text.includes(term)).length,
             tie: stableTie(fact),
         };
     });
-    const lexical = (a, b) => a < b ? -1 : a > b ? 1 : 0;
-    const compare = (a, b) => a.relationshipOrder - b.relationshipOrder || b.focus - a.focus || lexical(a.tie, b.tie) || lexical(a.fact.id, b.fact.id);
-    // Allocate each source's early slots to relationships before local occurrence
-    // detail. Otherwise hundreds of nearer variable references consume a file's
-    // diversity allowance before its file-to-symbol consumer can be considered.
-    // Final ordering below still charges distance and shared-library penalties.
-    rows.sort((a, b) => costs.get(a.fact) - costs.get(b.fact) ||
-        a.relationshipOrder - b.relationshipOrder || a.proximity - b.proximity || compare(a, b));
-    const counts = new Map();
-    const diverse = rows.map((row) => {
-        const seen = counts.get(row.fact.provenance.path) ?? 0;
-        counts.set(row.fact.provenance.path, seen + 1);
-        // Each additional fact from one source costs one ordinary edge. Details stay on later pages.
-        return { ...row, score: row.proximity + seen };
-    });
-    return diverse.sort((a, b) => a.score - b.score || compare(a, b))
-        .map(({ fact, score }) => ({ fact, score }));
+    return interleaveAffinity(rows, orderImpactRows(rows), sharedSymbolAffinity(facts, direct, anchorTerms));
 }

package/dist/interfaces/graph-paths.js

@@ -3,7 +3,7 @@ import { graphPredicates } from '@weftlet/core';
 import { parseGraphPathsRequest } from '../graph/path-request.js';
 export const graphPathsTool = {
     name: 'graph.paths',
-    description: 'Explore simple cited paths between exact node IDs in an explicit saved snapshot. Depth-first assertion order, not shortest/causal paths. Follow continuation with identical selectors; inspect depth/work limits and unexplored frontier. No hydration or model calls.',
+    description: 'Explore simple cited paths between exact node IDs in an explicit saved snapshot. Shortest-first traversal, prioritizing edges to the exact target; static paths are not proof of causality. Follow continuation with identical selectors; inspect depth/work limits and unexplored frontier. No hydration or model calls.',
     inputSchema: {
         type: 'object', additionalProperties: false, required: ['snapshotId', 'fromNodeId', 'toNodeId'],
         properties: {

package/docs/1.0-WORK-QUEUE.md

@@ -28,6 +28,28 @@ known direct paths and specific worker `references`/`consumes` assertions were d
 fixed retrieval budgets. [ADR 041](ADR-041-bounded-relationship-retrieval.md) tracks the bounded
 query-order patch and its public regression; no extraction refresh is needed for that patch.
 
+0.7.2 private replay: **direct-path acceptance is closed**; exact stored single-edge references
+and calls surface at the original budget. Keep **one indirect-ranking ticket open**: retrieve
+second-hop local references and legacy consumers without a saved call proof despite broad local
+competition. Library share and file discovery improved, but neither private target reached the
+first three 60-fact pages. Preserve extraction, authority, reachable totals and immutable evidence;
+record public and private denominators separately. See the latest [validation record](VALIDATION.md).
+The [ADR 042 patch](ADR-042-indirect-local-relationships.md) retrieves both exact public targets
+on the first page with the same saved evidence; private acceptance still requires the original replay.
+
+0.7.3 private replay: **the same ticket remains open**. Target ranks improve to 3,364 / 456 but
+both still miss 180 slots. The failure is competition within populated distance/predicate groups;
+file suggestion also regresses while library share remains 0/540. Before another ranking release,
+freeze a public within-group competition case and inspect whether saved evidence distinguishes
+the downstream targets from peers. Do not increase budgets, infer calls, or promise recall for
+indistinguishable consumers. Details and preserved controls are in [VALIDATION.md](VALIDATION.md).
+
+The next sanitized handoff identifies a selective exact-symbol witness for the two targets;
+the sampled peers have file-scope approaches instead. [ADR 043](ADR-043-shared-symbol-specificity.md)
+uses that saved structural evidence in a query-only candidate. The frozen within-group positive
+case returns both targets at 141 / 10; a symmetric control still misses them, documenting the
+limit rather than promising universal recall. Preserve the original private replay as the gate.
+
 All three public 554,516-fact strict SHACL passes succeeded but took about 35–37 minutes each
 in this cloud. This is a capacity result, not a 30-minute hydration qualification. B6b must record
 full hydration and agent-query latency on the consumer workload as well as correctness.

package/docs/ADR-041-bounded-relationship-retrieval.md

@@ -1,6 +1,7 @@
 # ADR 041: useful relationships within bounded retrieval
 
 Status: query-only patch; validation and publication status are recorded in VALIDATION.md.
+Impact ordering is superseded by [ADR 042](ADR-042-indirect-local-relationships.md); path ordering remains in effect.
 
 ## Evidence and scope
 

package/docs/ADR-042-indirect-local-relationships.md

@@ -0,0 +1,61 @@
+# ADR 042: indirect local relationships under broad anchors
+
+Status: query-only patch. Qualification and consumer status are recorded in VALIDATION.md.
+Supersedes ADR 041's impact ordering; its shortest-first path search is unchanged.
+The 0.7.3 private replay still misses both targets at 180 facts; the public result below is not
+private acceptance. Investigation now focuses on competition within the same groups.
+
+## Evidence
+
+The 0.7.2 private replay closes the direct-path report and confirms improved file discovery
+and library share. It does **not** close relationship recall: two exact second-hop assertions
+remain outside the original 180-fact budget despite zero hub penalty. One is a symbol reference
+without a saved call proof; the other is a legacy file consumer. No extraction loss is reported.
+
+The frozen [public regression](../evaluations/indirect-retrieval/protocol.md) independently
+reproduces this shape with actual extraction, broad catalog anchors and 192 competing local
+setup files. Both assertions exist and are reachable in round two. The baseline returns
+178 provenance files but misses both assertions. Per-source diversity alone is insufficient.
+
+## Decision
+
+Use `local-relationship-waves-v3` ordering over the **unchanged reachable set**:
+
+- Retain weighted graph distance and explicit-anchor exceptions from ADR 041. A saved cross-file
+  reference with an indexed definition receives the relationship category even without native
+  call proof. Do not change its predicate, confidence, authority or citations.
+- Separate relationships by weighted distance (0, 1, 2, 3, 4–7, 8+) and predicate family
+  (`calls`, `references`, `consumes`, other). Each wave takes two assertions from each populated
+  code-relationship bucket and one from each other-relationship bucket. Distances 0–3 each get
+  turns so broad near-anchor competition cannot consume every turn before indirect evidence.
+- Round-robin provenance sources **within** each bucket. Order each source by focus match,
+  distance and stable semantic tie key. Remove the unbounded per-source ordinal added to graph
+  distance in v2. All saved facts remain eligible, including repeated-source assertions.
+- Local symbol occurrence/definition and project/file membership detail get a separate single
+  slot per wave. Unindexed-symbol and generic module-import context follow local evidence unless
+  explicitly queried. These are retrieval signals, not proof that an unindexed symbol is external.
+- Give every assertion in a wave the same ordering score, then retain the query facade's existing
+  evidence-lane balancing. The score is now a wave number, not a distance-plus-diversity value.
+  Version continuation tokens and reject prior policies with instructions to restart the scan.
+
+There are no consumer names, target IDs or corpus-specific file selectors in the scorer.
+The fixed bucket proportions are a retrieval heuristic, not a universal relevance guarantee.
+Larger or equally competitive buckets can still displace relevant assertions. Intent, contracts
+and validation retain their evidence lanes; the returned page is not complete product coverage.
+
+## Tradeoffs and boundaries
+
+The same 9,038-fact saved public graph now returns the exact reference at position 17 and consumer
+at 15. All 180 output slots remain in the denominator. Source diversity falls from 178 to 71 files;
+that is an explicit tradeoff for relationship recall, not lost reachable evidence. Both facts
+remain as originally stored, including omitted authority fields on the legacy consumer. The
+reference still has no saved call proof; do not describe it as proven invocation or execution.
+
+The existing 36-target call-backed regression and direct-path acceptance remain separate checks.
+The private two-target ranking ticket stays open until the original queries are replayed at their
+original budgets. Public success cannot establish the private result positions.
+
+No extractor, assembly, semantic-cache, snapshot, persistence, RDF or strict-validation identity
+changes. Existing snapshots can be queried immediately without hydration or model calls. The
+0.7.1 capacity fix remains intact. The MCP path description is corrected to shortest-first with
+exact-target priority, retaining its static-path/non-causality warning.

package/docs/ADR-043-shared-symbol-specificity.md

@@ -0,0 +1,67 @@
+# ADR 043: shared-symbol specificity in bounded impact retrieval
+
+Status: query-only candidate; private two-assertion acceptance remains open.
+Extends [ADR 042](ADR-042-indirect-local-relationships.md). Does not change path search.
+
+## Evidence
+
+0.7.3 still misses the private unconfirmed symbol reference and legacy consumer at 180 facts.
+The subsequent sanitized chains supply a more specific signal than distance/family alone:
+producer → shared indexed symbol ← worker indexed symbol. The shared object has three distinct
+production referrers. The preselected median peers instead approach through file-scope symbols.
+A reverse reference is not a forward call. This is pairwise evidence, not a universal ranking proof.
+
+The [frozen public comparison](../evaluations/same-group-retrieval/protocol.md) uses actual
+SCIP extraction and strict publication. Both exact targets are reached in round two, inside the
+same populated distance/predicate groups as competitors. The reference is seventh within its
+source/group; the consumer is first. Baseline ranks are 3,074 and 323. A symmetric control gives
+all 136 workers the same producer connection; it cannot establish a unique preferred worker.
+
+## Decision
+
+Use `shared-symbol-witnesses-v4` to interleave a structural specificity queue with the unchanged
+v3 baseline waves, over the same reachable set. Each previously unreturned baseline assertion
+gets one opportunity for an additional specificity selection. Deduplicate by assertion ID and
+retain baseline wave boundaries for the existing evidence-lane balancing. With no usable
+witnesses, baseline order and scores are exactly unchanged.
+
+Eligible witnesses require saved SCIP named definitions for repository-scoped indexed symbols,
+and exact typed reference endpoints in the same snapshot, commit and extractor version. A direct
+matched definition supplies the producer origin. File-scope/module anchors, declaration-only or
+unindexed targets, local ordinal identities and unknown adapters cannot supply this signal.
+Rank shared objects by the number of distinct production indexed referrers in the reachable
+query scope. Repeated occurrences, file-scope imports and test referrers do not inflate that
+count. Test assertions remain available, including supported references in their existing
+validation lane; this does not certify production implementation.
+
+Within equal specificity, balance references and consumers and round-robin cited source files,
+using existing focus/distance/stable ties. A later occurrence from a selectively related worker
+can receive a turn before hundreds of unrelated local sources. Every assertion remains eligible;
+this adds no fact, confidence, authority, approval, call proof or runtime claim.
+
+A legacy file consumer receives corroborating priority only when its saved SCIP native symbol
+key/hash matches a supported typed reference in the same cited file, digest, commit, snapshot and
+extractor version. Its first citation may be an import before the later method reference. A shared
+file/start line alone is insufficient. This projection-specific ordering does **not** assert a
+native-to-legacy identity edge or make the file consumer an exact invocation. Unknown projections
+retain baseline ordering. There are no consumer names or fixture target IDs in production code.
+
+## Results, limits and compatibility
+
+On the unchanged positive public graph, the reference/consumer move to **141 / 10**, within the
+same 3 × 60 slots at depth three. All 6,417 reachable facts and stored bytes remain identical.
+Source diversity falls from 63 to 38 files; this is an explicit relevance/diversity tradeoff.
+Two of all 136 predeclared reference/consumer pairs are retrieved together; the denominator is
+272 assertions, not just the chosen successful targets.
+
+On the symmetric graph, the targets remain outside the budget at **2,892 / 309**. Zero of 136
+pairs appear together. Specificity cannot distinguish equal witnesses, nor promise retrieval
+of every relevant occurrence in large groups. The two-mode comparison is evidence for a bounded
+heuristic, not private acceptance or a completeness guarantee. Degree is query-scope relative,
+not a repository-global count or a confidence score.
+
+Continuation tokens identify v4 and reject prior offsets with restart instructions. No extractor,
+assembly, semantic-cache, snapshot, persistence, RDF, SHACL or core contract identity changes.
+Existing evidence can be queried without hydration or model calls. The 0.7.1 capacity fix and
+shortest-first direct paths remain untouched. Keep the private original queries, exact assertion
+IDs, 180-result budget, reachable totals and stored fingerprints as the next acceptance check.

package/docs/RELEASING.md

@@ -202,14 +202,14 @@ Verify the matching public version in a fresh disposable project after publicati
 
 ```sh
 npm init -y
-npx --yes @weftlet/toolkit@0.7.2 init --yes
-npx --yes @weftlet/toolkit@0.7.2 config validate
+npx --yes @weftlet/toolkit@0.7.4 init --yes
+npx --yes @weftlet/toolkit@0.7.4 config validate
 ```
 
 For local installation, use both prepared archives from the same reviewed release:
 
 ```sh
-npm install --save-dev "/path/to/weftlet/.release/weftlet-core-0.7.2.tgz" "/path/to/weftlet/.release/weftlet-toolkit-0.7.2.tgz"
+npm install --save-dev "/path/to/weftlet/.release/weftlet-core-0.7.4.tgz" "/path/to/weftlet/.release/weftlet-toolkit-0.7.4.tgz"
 ```
 <!-- weftlet:release:end -->
 

package/docs/VALIDATION.md

@@ -1,5 +1,113 @@
 # Validation evidence
 
+## Shared-symbol candidate: public evidence, 2026-11-03
+
+[ADR 043](ADR-043-shared-symbol-specificity.md) and its
+[frozen within-group comparison](../evaluations/same-group-retrieval/README.md) address the
+newly supplied chain evidence without changing extraction. On one unchanged 6,417-fact saved
+graph, both round-two targets move from 3,074 / 323 to **141 / 10** at depth three / 3 × 60.
+All reachable facts, exact citations/authority and four stored files remain unchanged. Source
+diversity changes from 63 to 38; two of all 136 predeclared pairs are returned together.
+The symmetric control still misses the targets at 2,892 / 309 and retrieves zero complete pairs.
+That negative result is retained; equal witnesses cannot guarantee universal bounded recall.
+
+The built CLI and a fresh stdio MCP server reproduce all 180 candidate IDs in order across
+three pages, including both exact stored target facts. No hydration/model calls or saved-byte
+changes occur during that comparison. Focused ranking, projection-mismatch, strict hydration,
+repeat, prior relationship and shortest-first path checks pass; full release qualification is
+recorded separately on the change PR. Repeat hydration creates a fresh identical RDF work file
+while preserving every prior evidence file. **The private two-assertion ticket remains open.**
+
+## 0.7.3 private replay: same indirect-ranking ticket remains open, 2026-11-03
+
+Maintainer-reported, sanitized evidence. At the original depth three / three pages of 60,
+the same `references` and `consumes` assertions improve from ranks 23,052 / 3,447 in 0.7.2
+to **3,364 / 456** in 0.7.3 (calculated pages 57 / 8). Both still miss the predeclared 180
+slots. This is the same ranking ticket, not another extraction, scale or authority failure.
+The earlier public two-target pass does not transfer to this larger graph.
+
+Snapshot digest remains `53e2e3a024125389685d5bc9183f428b4e749dc7021df87623f54e32af4c7f56`;
+360 direct matches and 420,837 reachable facts are unchanged. Both targets are reached in
+round two. The released ranker reproduces all 180 CLI fact IDs in order; later ranks were
+calculated without fetching additional pages. Neither target has a hub penalty or belongs
+to the context-only phase. No saved call in the reachable set cites the reference as target proof.
+
+| Target group | Assertions / sources | Target group rank / source ordinal | Slots in first 180 | Target wave |
+| --- | ---: | ---: | ---: | ---: |
+| Weighted distance 2, `references` | 1,038 / 136 | 284 / 5 | 10 | 141 |
+| Weighted distance 3, `consumes` | 284 / 47 | 29 / 1 | 10 | 14 |
+
+These measurements locate displacement within populated groups and their turn allocation;
+they do not establish a universally better weighting scheme. Across the three original cases,
+page-one expected file suggestion/citation changes from 12/12 / 12/12 in 0.7.2 to 10/12 / 11/12;
+through three pages it is 11/12 / 12/12. Library-target references remain 0/540 and no named
+noise control appears. The PM first 180 cover 63 provenance sources, versus 158 previously.
+File discovery and source diversity are separate measurements from exact relationship recall.
+
+The direct-path report stays closed: both exact one-hop assertions retain their predicates,
+citations and original 1,000-step budget. The MCP description is now accurate. Fresh MCP agrees
+with the released CLI; all 35 consumer checks and all 20 stored-byte fingerprints pass, without
+private rehydration or model calls. The 0.7.1 capacity fix remains accepted for the reported run.
+
+The subsequent saved-chain handoff distinguishes the targets from preselected median peers.
+Both targets have a producer → indexed shared symbol ← indexed worker witness, with **three
+distinct production referrer symbols**. The reference's sampled peer instead approaches through
+file-scope symbols; the consumer's peer also has no such shared-symbol witness. Peers were chosen
+as the fifth of ten first-page results in their respective groups, before comparing paths.
+This establishes pairwise structural specificity, not a universally optimal ranking or execution.
+There is no all-forward indexed reference/call path within four approach hops in that diagnostic.
+
+Native and legacy projections have no explicit identity edge. Matching usage/definition file and
+start line are corroboration only; they must not become graph joins or fabricated calls. The
+stored-byte SHA-256 in the handoff is
+`e92e3c2c4b6ec65a4767fe20697657cd566c15fbdff9732af58999d8ff09554d`.
+The query-only candidate and its positive/ambiguous public controls are tracked in
+[ADR 043](ADR-043-shared-symbol-specificity.md). **Private acceptance remains open.**
+
+## Indirect-ranking patch: public comparison, 2026-11-03
+
+[ADR 042](ADR-042-indirect-local-relationships.md) and the
+[frozen comparison](../evaluations/indirect-retrieval/README.md) cover the remaining query-only
+ranking change. Actual TypeScript extraction produces both second-hop assertions without a
+saved call proof for the reference. At unchanged depth three / 3 × 60 facts, their ranks move
+from 3,704 / 1,760 to **17 / 15**. The 9,038 stored/reachable assertions and 150 direct matches
+are unchanged. All 180 results remain in the denominator; source diversity changes from 178
+to 71 files. The four saved evidence files retain exact bytes during the comparison. No private
+source, semantic/model calls, new extraction or larger query budgets enter that comparison.
+
+The prior 36-target call-backed regression and direct-path/exhaustive-oracle/viewer parity tests
+pass locally. The MCP path description now reflects shortest-first traversal with exact-target
+priority and retains the warning that static paths are not causality. Full release qualification
+is recorded separately on the change PR. **Private two-target ranking acceptance stays open.**
+Existing snapshots and caches need no refresh; impact continuation must restart after upgrading.
+
+## 0.7.2 private replay: paths closed, indirect ranking open, 2026-11-03
+
+The maintainer reports that the same saved endpoints now return two exact stored single-edge
+paths (`references` and `calls`) on page one at outgoing depth three / 1,000 steps. The CLI and
+fresh stdio MCP agree, and truncation/continuation remains truthful. **Close the direct-path
+consumer report.** This establishes cited static paths, not exhaustive discovery or runtime causality.
+
+The remaining ranking ticket concerns second-hop local `references` and legacy file `consumes`
+assertions without a saved call whose target-occurrence proof cites the reference. Both still
+exist and are reachable in expansion round two. Neither receives the unindexed-symbol penalty.
+Do not invent a `calls` fact or change extraction to address this query-order finding.
+
+On unchanged private inputs and budgets, 0.7.1 → 0.7.2 improves page-one file suggestion/source
+citation from 11/12 to 12/12 and library assertions from 378/540 to 0/540. The two target
+assertions remain absent from the first 180 PM results. Their calculated ranks improve from
+24,801 / 69,207 to 23,052 / 3,447; v2 scores are 34 / 9, relationship-order values 1 / 0, and
+22,791 / 3,295 assertions have strictly lower scores. The first 180 cover 158 provenance files.
+These measurements implicate the interaction of distance, relationship category and source
+diversity under broad local competition; they do not identify one scoring term as the sole cause.
+
+The consumer reproduced all 180 CLI fact IDs in order, with 360 direct matches and 420,837
+reachable assertions. All three queries retain their prior reachable counts. All 20 stored-file
+fingerprints match; no rehydration, model calls or extra pages were used. This private two-target
+case is distinct from the earlier public 36-relationship denominator, which remains valid for its
+call-backed fixture. A new public regression must include broad anchors, many local competitor
+files, and both exact second-hop assertions without call proof at depth three / 3 × 60 facts.
+
 ## 0.7.1 consumer follow-up and bounded retrieval patch, 2026-11-03
 
 **Maintainer-reported consumer pass:** the published 0.7.1 toolkit hydrates, strictly validates,

package/docs/extraction-manifest.json

@@ -108,7 +108,7 @@
       "destinationPath": "package.json",
       "sourceSha256": "a575dbb2fed8c554b95e8e9b3e03a0c21cab1be7249860bbebc18e046b2ff78d",
       "modified": true,
-      "destinationSha256": "5ca2ea1f62e6b8393e731f761a1732a8ccf464948a905ab9fe246ae5d941dda8"
+      "destinationSha256": "e7287cbf5f7182b8c16c073dcc097a26616ae85868a518fc8e8966a8072b83ae"
     },
     {
       "sourcePath": "tools/context-graph/packages/core/LICENSE",
@@ -129,7 +129,7 @@
       "destinationPath": "packages/core/README.md",
       "sourceSha256": "6044bf7b9a3dc793f41e2ff048546ed11938957d10a5b143eb1739ac4cd7477c",
       "modified": true,
-      "destinationSha256": "1c0c80c8a85f9240ace5a2f01d102646fa293ef246a5f056eb94c7efa0f6e401"
+      "destinationSha256": "cd458ed031e0109f5b8455cc5e0d948a42a64f7e4d67f79b12e28a1450c7be51"
     },
     {
       "sourcePath": "tools/context-graph/packages/core/THIRD_PARTY_NOTICES.md",
@@ -143,7 +143,7 @@
       "destinationPath": "packages/core/package.json",
       "sourceSha256": "2a29066eb8452f22fafcb06bb035a84dda93c5705dba32aba600a1b7e5aaf19c",
       "modified": true,
-      "destinationSha256": "4a17cd04c7ec5a3a96ec0767d3883d588dfe6724822f254ed91f452b30b939bc"
+      "destinationSha256": "825072a8f61911034ae7784935b66368eb0c945c19d68bad8fb6acecc6f5981b"
     },
     {
       "sourcePath": "tools/context-graph/packages/core/src/core.ts",
@@ -388,14 +388,14 @@
       "destinationPath": "src/graph/query.test.ts",
       "sourceSha256": "ba07c52566da979fcbb451b0c0c99b466521993cb49415ff8b35df2b01d4ecaf",
       "modified": true,
-      "destinationSha256": "20f0766299e66d4b5e7bc4577b6b0937c5bf87f2f1858f7b0205172231f0bb4c"
+      "destinationSha256": "11b59d7e1936c66cf453136dc01908e3c19287926a29e881effd7b631cce518c"
     },
     {
       "sourcePath": "tools/context-graph/src/query.ts",
       "destinationPath": "src/graph/query.ts",
       "sourceSha256": "4d67f87ca660cefe9686fb5b775f86a997a25d539819ea81d321c8bd1e0aaa39",
       "modified": true,
-      "destinationSha256": "b689b2285cc22fdcc89d5dd64ee91d0395a1751004c7970bf62f9edebd7162ce"
+      "destinationSha256": "8c13b32499f0b830cd02bfc281c37c32fd6387aa3b98a325e6a60d3706b64528"
     },
     {
       "sourcePath": "tools/context-graph/src/request.test.ts",
@@ -635,6 +635,8 @@
     "docs/ADR-039-mapping-proposals.md",
     "docs/ADR-040-bounded-graph-io.md",
     "docs/ADR-041-bounded-relationship-retrieval.md",
+    "docs/ADR-042-indirect-local-relationships.md",
+    "docs/ADR-043-shared-symbol-specificity.md",
     "docs/CLOUD-ENVIRONMENT.md",
     "docs/CONSUMER-TRIAL.md",
     "docs/ENVIRONMENT-VALIDATION.md",
@@ -748,6 +750,10 @@
     "evaluations/dispatch/routing-baseline.json",
     "evaluations/dispatch/routing-protocol.md",
     "evaluations/dispatch/routing.config.json",
+    "evaluations/indirect-retrieval/README.md",
+    "evaluations/indirect-retrieval/baseline.json",
+    "evaluations/indirect-retrieval/candidate.json",
+    "evaluations/indirect-retrieval/protocol.md",
     "evaluations/mapping-gaps/README.md",
     "evaluations/mapping-gaps/inputs.lock.json",
     "evaluations/mapping-gaps/project/.gitattributes",
@@ -784,6 +790,13 @@
     "evaluations/relationship-retrieval/baseline.json",
     "evaluations/relationship-retrieval/candidate.json",
     "evaluations/relationship-retrieval/protocol.md",
+    "evaluations/same-group-retrieval/README.md",
+    "evaluations/same-group-retrieval/prior-36-control.json",
+    "evaluations/same-group-retrieval/protocol.md",
+    "evaluations/same-group-retrieval/v3-specific.json",
+    "evaluations/same-group-retrieval/v3-symmetric.json",
+    "evaluations/same-group-retrieval/v4-specific.json",
+    "evaluations/same-group-retrieval/v4-symmetric.json",
     "evaluations/static-calls/README.md",
     "evaluations/static-calls/results/2026-10-29.json",
     "evaluations/weftlet/baseline.json",
@@ -872,6 +885,8 @@
     "scripts/evaluation/score.ts",
     "scripts/git-content.d.mts",
     "scripts/git-content.mjs",
+    "scripts/indirect-retrieval-study/measure.ts",
+    "scripts/indirect-retrieval-study/run.ts",
     "scripts/inventory.test.ts",
     "scripts/large-graph/lifecycle.ts",
     "scripts/large-graph/run.ts",
@@ -901,6 +916,12 @@
     "scripts/restore-publication-state.mjs",
     "scripts/retrieval-study/preservation.ts",
     "scripts/retrieval-study/run.ts",
+    "scripts/same-group-study/entrypoints.ts",
+    "scripts/same-group-study/measure.ts",
+    "scripts/same-group-study/run.ts",
+    "scripts/same-group-study/v3-order.ts",
+    "scripts/same-group-study/v3-rows.ts",
+    "scripts/same-group-study/v3-signals.ts",
     "scripts/smoke-mapping-proposals.mjs",
     "scripts/smoke-traversal.mjs",
     "scripts/update-inventory.mjs",
@@ -1019,6 +1040,11 @@
     "src/graph/evidence-description.ts",
     "src/graph/identity-preflight.test.ts",
     "src/graph/identity-preflight.ts",
+    "src/graph/impact-affinity-order.ts",
+    "src/graph/impact-affinity.test.ts",
+    "src/graph/impact-affinity.ts",
+    "src/graph/impact-order.test.ts",
+    "src/graph/impact-order.ts",
     "src/graph/impact-signals.ts",
     "src/graph/neighborhood-renderer.ts",
     "src/graph/neighborhood-request.ts",
@@ -1098,12 +1124,14 @@
     "tests/fixtures/code-evidence-project.ts",
     "tests/fixtures/compatibility-cases.ts",
     "tests/fixtures/compatibility-project.ts",
+    "tests/fixtures/indirect-retrieval-project.ts",
     "tests/fixtures/large-typescript-project.ts",
     "tests/fixtures/mapping-project.ts",
     "tests/fixtures/monorepo-project.ts",
     "tests/fixtures/obligation-project.ts",
     "tests/fixtures/rdf-070-reference.ts",
     "tests/fixtures/relationship-retrieval-project.ts",
+    "tests/fixtures/same-group-project.ts",
     "tests/fixtures/shacl.ts",
     "tests/fixtures/static-call-project.ts",
     "tests/fixtures/symbol-bindings.ts",
@@ -1112,6 +1140,7 @@
     "tests/hydration-plan.test.ts",
     "tests/identity-preflight.test.ts",
     "tests/implementation-coverage.test.ts",
+    "tests/indirect-retrieval.test.ts",
     "tests/large-graph-lifecycle.test.ts",
     "tests/mapping-proposals.test.ts",
     "tests/module-boundaries.test.ts",
@@ -1123,6 +1152,7 @@
     "tests/relationship-retrieval.test.ts",
     "tests/routing.test.ts",
     "tests/runtime.test.ts",
+    "tests/same-group-retrieval.test.ts",
     "tests/semantic-cache-reuse.test.ts",
     "tests/semantic-identity.test.ts",
     "tests/shacl-validation.test.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weftlet/toolkit",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "Evidence-backed context graphs for AI development agents: product intent, contracts, code, tests and runtime behavior",
   "license": "Apache-2.0",
   "type": "module",
@@ -66,7 +66,7 @@
     "rdf-validate-shacl": "0.6.5",
     "sparqljs": "3.7.4",
     "typescript": "5.5.4",
-    "@weftlet/core": "^0.7.2"
+    "@weftlet/core": "^0.7.4"
   },
   "devDependencies": {
     "@changesets/cli": "3.0.3",
@@ -131,6 +131,8 @@
     "benchmark:validation": "node scripts/validation-benchmark/run.mjs",
     "evaluate:mappings": "tsx scripts/mapping-study/run.ts",
     "evaluate:calls": "tsx scripts/call-study/run.ts",
-    "evaluate:proposals": "tsx scripts/mapping-proposal-study/run.ts"
+    "evaluate:proposals": "tsx scripts/mapping-proposal-study/run.ts",
+    "evaluate:indirect": "tsx scripts/indirect-retrieval-study/run.ts",
+    "evaluate:same-group": "tsx scripts/same-group-study/run.ts"
   }
 }