diff --git a/README.md b/README.md index 2038323..c8478e0 100644 --- a/README.md +++ b/README.md @@ -298,6 +298,8 @@ Confirmed-outcome feedback reinforcementは、同じ candidate class の `confir Soft-start feedback reinforcementは、`soft_start_feedback_reinforcement=True`、`soft_start_feedback_ratio`、`confirmation_decay_ratio` を明示する別の default-off candidate です。credited relation edge の最初の新規 `used` は通常 bounded update の一部だけを provisional に適用し、最初の独立 `confirmed` が残りを補完します。後続 confirmation は既存 geometric decay に従い、same-source sibling normalization は `used` ではなく各 confirmation の actual delta だけへ適用します。confirmed-only candidate、hard quorum と同時には有効化できず、既存 q1/s0、q3/s1、confirmed-only、凍結評価 artifact と default fingerprint は変更しません。詳細は[Confirmed-outcome feedback reinforcement](docs/confirmed-outcome-feedback-reinforcement.md#soft-start-successor-candidate)を参照してください。 +local database上の比較は、[Soft-start snapshot evaluation](docs/soft-start-snapshot-evaluation.md)でtransaction-consistent private snapshot、固定4 arm、result-free manifest、one-time development、conditional holdout、privacy / mutation / rank hard gateとして分離しています。評価はsnapshotのfresh cloneだけを変更し、source database、live config、snapshot本体、private本文をpublic artifactへ含めません。支持結果も固定local snapshot上のcutover候補に限定し、このissue内でconfigやdefaultを変更しません。 + 後続の feedback policy comparison に使う public source は、[feedback-policy-comparison-v1](corpora/feedback-policy-comparison-v1/README.md) に corpus-only で固定しています。development / holdout 各二 cluster の明示 link topology、source-only manifest、raw SHA-256、LF 改行規則、provenance、既存 fixture との identity contamination audit だけを含み、評価の選択入力と観測物は含めません。この source merge commit を後続の別 issue が唯一の入力として扱います。 この corpus を使う `used + q3 + sibling normalization 1.0` と `confirmed + decay 0.5 + sibling normalization 1.0` の比較は、[Feedback policy comparison evaluation](docs/feedback-policy-comparison-evaluation.md) に result-free protocol、one-time development、conditional holdout、exclusive observed result、再計算可能な hard gate を固定しています。controlled result は default adoption や production quality を意味しません。 diff --git a/docs/Decision-Structure.md b/docs/Decision-Structure.md index 69526b5..e48d170 100644 --- a/docs/Decision-Structure.md +++ b/docs/Decision-Structure.md @@ -18,7 +18,7 @@ | [longitudinal-feedback-adaptation](https://github.com/Liplus-Project/neuron-graph-rag/wiki/longitudinal-feedback-adaptation) | active | longitudinal feedback-adaptation は、repository-native controlled corpus v3 の相互に独立した cluster と、その source 文書に明記した 0、1、3、10 credit ceiling を用いる。corpus phase は query、gold、schedule、runner、gate、manifest、result、既定値を定義・変更しない。 | | [single-corpus-real-feedback-validation](https://github.com/Liplus-Project/neuron-graph-rag/wiki/single-corpus-real-feedback-validation) | superseded | [repository-native-controlled-corpus](https://github.com/Liplus-Project/neuron-graph-rag/wiki/repository-native-controlled-corpus) がこの node を supersede する。以後の evaluation は、NGR repository に公開する固定 SHA の controlled corpus を source とし、D1 single-corpus experiment は capacity が増えるまで waiting とする。 | | [repository-native-controlled-corpus](https://github.com/Liplus-Project/neuron-graph-rag/wiki/repository-native-controlled-corpus) | active | repository-native controlled corpus v2 は、固定 SHA の公開 documentation と本文中の明示的な同一 directory 相対 link だけから、node、doc path、source URL、credited edge identity が相互に分離した development / holdout の各 3-edge path を導出する。v1 は provenance として保持する。これは controlled benchmark であり、外部 corpus への一般化、評価 query、gold、result、既定値変更を含まない。 | -| [soft-start-feedback-reinforcement](https://github.com/Liplus-Project/neuron-graph-rag/wiki/soft-start-feedback-reinforcement) | active | 最初の credited `used` に通常 bounded update の小さな provisional fraction を適用し、最初の独立 `confirmed` が remainder、後続 confirmation が geometric decay を適用する。sibling normalization は confirmation の actual delta だけを使い、default と凍結 artifact は変更しない。 | +| [soft-start-feedback-reinforcement](https://github.com/Liplus-Project/neuron-graph-rag/wiki/soft-start-feedback-reinforcement) | active | 最初の credited `used` に通常 bounded update の小さな provisional fractionを適用し、最初の独立 `confirmed` が remainder、後続 confirmation が geometric decayを適用する。transaction-consistent private snapshotの固定4 arm評価はdevelopment全hard gate通過時だけholdoutを一度開き、結果をlocal cutover候補に限定してsource database、live config、defaultを変更しない。 | | [github-rag-mcp-replacement-compatibility](https://github.com/Liplus-Project/neuron-graph-rag/wiki/github-rag-mcp-replacement-compatibility) | active | public GitHub repository一つのread-only snapshotをNGR local indexへ接続する。github-rag-mcp `search` の保存済み raw capture と source URL、根拠を比較する。共有 source identity を確認しても最小 doc 検索 path の候補に限り、production github-rag-mcp、MCP authentication / transport、remote deployment、default変更は含まない。 | ## Entry format diff --git a/docs/requirements.md b/docs/requirements.md index 5f2291c..016a772 100644 --- a/docs/requirements.md +++ b/docs/requirements.md @@ -100,6 +100,7 @@ 81. sibling normalization controlled evaluation は、評価対象 source commit / hash、相互に identity-disjoint な development / holdout cluster、明示 edge、baseline `0.0` / treatment `1.0`、query、used node、credited path、mutation scope、rollback、係数 / 時刻 schedule、hard gate、exclusive output を観測前に固定する。実 `NeuronGraphRAG` の `search_channels` relation trace ID を `record_success` に渡し、headroom strict improvement、ceiling・direct・lexical・directional-negative non-regression、path・mutation・atomicity・determinism の全 development gate 通過時だけ holdout を一度開く。観測後は protocol artifact と docs を変更せず、既定値と external D1 claim を変更しない。 82. frozen evaluation の historical source hash は、manifest path の初回追加 commit または manifest が明示する lowercase full 40-hex source / baseline / prior commit の exact blob bytes に対して検証する。後続の committed manifest rewrite、mutable ref / revision expression、未知 commit、非 ancestor commit、manifest bytes差、欠落 path、hash 不一致を fail closed にし、同名 path の current working tree を過去の evidence として扱わない。既存 protocol が明記する raw-first LF / CRLF whole-file alternate だけを維持し、本文差、mixed newline、bare CR、その他の byte 差を拒否する。 83. soft-start feedback reinforcement は明示 opt-in の relation-only candidate とし、最初の新規 `used` で通常 bounded increment の固定 ratio 分だけを credited path へ適用する。最初の独立 `confirmed` は同じ schedule の残量を一回分の通常 increment まで補い、後続 confirmation は固定 decay ratio で加算する。used 時は sibling normalization を行わず、confirmation の actual delta だけを同一 source の uncredited sibling へ配分する。duplicate、lexical、zero-hop、別 source、uncredited edge、negative outcome は変更せず、candidate mechanics の合格だけで default や local serving policy を変更しない。 +84. soft-start snapshot evaluation は、local source database を read-only URI と SQLite backup API で一度だけ transaction-consistent snapshot へ複製し、同じ snapshot のfresh clone上で `control`、`used_q3_s1`、`confirmed_r05_s1`、`soft_start_r025_r05_s1` の固定4 armを比較する。query、public node / edge identifier、outcome、3回のfresh trace schedule、checkpoint、metric、hard gate、exclusive output、snapshot / protocol hashを登録result生成前に固定する。source database、live config、snapshot本体、private本文、absolute private pathをpublic artifactへ含めず、developmentを一度だけ実行し、全hard gate通過時だけholdoutを一度開く。不支持または判定不能を保存してもprotocolを調整せず、local cutover、library default、external corpus、production qualityへ自動で一般化しない。 75. v3 implementation、prompt、manifest、query override、schema、集約、path audit、hash規則、gate、stop rule、testsをresult-free commitでpushした後、development stage / 4 case packet / 12 responses / resultを各一度だけ生成する。 76. development全12 gate通過時だけholdout stageを一度生成し、異なるfresh 12 judgesで同じgateを評価する。packet、response、resultの上書き、観測後の規則変更、実LLM品質値のCI再生成を拒否する。 @@ -136,3 +137,4 @@ - [Sibling normalization controlled evaluation](sibling-normalization-controlled-evaluation.md) が repository-native corpus、result-free hash freeze、実 relation trace feedback、mutation / rollback gate、conditional holdout を定義する。 - [Historical source verification](historical-source-verification.md) が frozen manifest path の初回追加 commit、明示 full source commit ID、exact blob、ancestor、path、newline portability、fail-closed 境界を定義する。 - [Confirmed-outcome feedback reinforcement](confirmed-outcome-feedback-reinforcement.md) が confirmed-only と soft-start の明示 policy、永続 schedule、transaction、receipt、default-preserving boundary を定義する。 +- [Soft-start snapshot evaluation](soft-start-snapshot-evaluation.md) が transaction-consistent private snapshot、固定4 arm、result-free freeze、privacy、one-time development、conditional holdout、local cutover境界を定義する。 diff --git a/docs/soft-start-snapshot-evaluation.md b/docs/soft-start-snapshot-evaluation.md new file mode 100644 index 0000000..27f67e2 --- /dev/null +++ b/docs/soft-start-snapshot-evaluation.md @@ -0,0 +1,70 @@ +# Soft-start snapshot evaluation + +## 目的と判断範囲 + +この評価は、現在のlocal NGR databaseから一度だけ取得したtransaction-consistent snapshotを使い、次の4 armを同じquery、node role、event順序、checkpointで比較する。 + +1. `control`: source-useとoutcomeを監査保存するがserving edgeを変更しない。 +2. `used_q3_s1`: relation feedback evidence quorum `3`、sibling normalization `1.0`。 +3. `confirmed_r05_s1`: confirmed-only、confirmation decay `0.5`、sibling normalization `1.0`。 +4. `soft_start_r025_r05_s1`: soft-start ratio `0.25`、confirmation decay `0.5`、sibling normalization `1.0`。 + +判断対象は、この固定snapshot上でsoft-startがlocal serving cutover候補になれるかだけである。`0.25`と`0.5`は観測前に固定した比較値であり、library defaultや最終採用値ではない。このissueはsource database、live config、project defaultを変更しない。 + +## Snapshotとprivacy境界 + +acquisitionはsource databaseをSQLite URI `mode=ro`と`query_only`で開き、SQLite backup APIでprivate destinationへ一度だけ複製する。複製前後のsource container SHA-256が一致し、snapshotの`integrity_check`が`ok`であることを要求する。各armとfresh replayはsnapshotの別temporary cloneだけを開く。 + +public manifestにはsource locator、capture timestamp、container / snapshot / schema hash、size、table name、選択tableのrow countだけを登録する。snapshot本体、source / snapshotのabsolute path、node本文、credentialを登録しない。fixtureは既にpublicであるnode / edge identifier、固定query、outcome role、mutation許可集合だけを保持する。runnerとverifierはpublic payloadを再帰走査し、private field、absolute path、credential-shaped valueを拒否する。 + +## Result-free freeze + +`soft_start_snapshot_v1` namespaceはfixture、schedule、gate、result schema、result-free audit、manifestを新規作成し、既存の凍結評価artifactを読み替えも変更もしない。manifest pathを初めて追加したcommitのexact blob bytesがhistorical source of truthであり、登録stage実行とresult verificationはcurrent working treeの同名bytesではなく、そのcommitから検証済みbytesを読む。 + +freeze commitをpushする前は、登録development / holdout outputが存在しないことを確認する。writer / verifierは登録外のplaceholder identityとtemporary outputだけでround-tripを証明する。registered outputはexclusive createし、上書き、再実行、再集計を拒否する。 + +developmentはfreezeとCI確認後に一度だけ実行する。developmentの全hard gateがpassした場合だけholdoutを一度実行する。失敗または不支持でもquery、ratio、schedule、metric、gate、caseを変更しない。 + +## Caseとschedule + +developmentとholdoutは、それぞれconfirmed cohort、corrected cohort、lexical control、zero-hop controlを持つ。各caseはbaseline後、異なるfresh search traceを使って次を固定順で実行する。 + +`used_1` → `outcome_1` → `used_2` → `outcome_2` → `used_3` → `outcome_3` + +全eventでsource-use / outcome receiptとidempotency replayを保存する。各armは同じsnapshotのfresh cloneで再実行し、runtime identityを除くsemantic payloadが一致することを要求する。 + +## Metricとhard gate + +各checkpointはrelation rank / MRR / Hit@k、score margin、top-k entry / exit、non-target churn、direct rank、reverse relation rankを保存する。全edgeについてweight、reinforced count、evidence count、confirmation countを保存し、credited edge、same-source sibling、unrelated edgeの変化を再計算可能にする。 + +hard gateは次の7件である。 + +1. snapshot、case、schedule、receipt、idempotency、fresh-clone replay、exclusive outputのintegrity。 +2. 最初の`used`で正のprovisional deltaを適用し、最初のconfirmedとの合計が通常bounded update一回分で、後続confirmationが固定decayへ従うこと。 +3. q3/s1が3回目前に不変、confirmed-onlyがconfirmed前に不変で、controlが不変であること。 +4. soft-startがcheckpoint 1で先に学習を開始し、最終confirmed cohortのrelation MRRがq3/s1へnon-regressionであること。 +5. corrected cohortのprovisional costを保存し、通常bounded incrementの`0.25`以下に限定し、自動negative reinforcementやrollbackを行わないこと。 +6. lexical、zero-hop、direct、reverse controlへmutationまたはrank regressionを漏らさないこと。 +7. mutationをcredited edgeとconfirmation時のsame-source siblingだけへ限定し、source snapshotを変更しないこと。 + +## Result解釈 + +全hard gateがpassしたstageだけを`支持`とする。一件でも不合格なら`不支持`、protocolを完走できなければ`判定不能`をexclusive observed resultへそのまま保存する。developmentが`支持`でない場合はholdoutを開かず、local cutoverを支持しない。holdoutまで`支持`でも、結論は固定local snapshot上のcandidate支持に限定し、別のconfig変更判断なしにlive configを変更しない。 + +実行入口は次のとおりである。`SNAPSHOT`はpublic repository外のprivate pathを呼出側だけが渡す。 + +```bash +python tools/run_soft_start_snapshot_evaluation.py --probe --snapshot "$SNAPSHOT" +python tools/run_soft_start_snapshot_evaluation.py --stage development --snapshot "$SNAPSHOT" +python tools/run_soft_start_snapshot_evaluation.py --verify development +``` + +holdout commandはdevelopment resultの全hard gate passをpreflightが確認した場合だけ同じ形で一度実行する。 + +## 関連 + +- [Requirements](requirements.md) +- [Confirmed-outcome feedback reinforcement](confirmed-outcome-feedback-reinforcement.md) +- [Historical source verification](historical-source-verification.md) +- [Decision Structure](Decision-Structure.md) +- [Issue #104](https://github.com/Liplus-Project/neuron-graph-rag/issues/104) diff --git a/src/neuron_graph_rag/soft_start_snapshot_evaluation.py b/src/neuron_graph_rag/soft_start_snapshot_evaluation.py new file mode 100644 index 0000000..3e6b08e --- /dev/null +++ b/src/neuron_graph_rag/soft_start_snapshot_evaluation.py @@ -0,0 +1,1017 @@ +from __future__ import annotations + +import hashlib +import json +import os +import re +import shutil +import sqlite3 +from collections.abc import Mapping, Sequence +from dataclasses import asdict +from datetime import datetime, timezone +from pathlib import Path +from tempfile import TemporaryDirectory +from typing import Any + +from .config_provenance import effective_config_provenance +from .corpus_integrity import verify_manifest_source_hashes +from .evidence_feedback import EngineConfig, NeuronGraphRAG +from .feedback import FeedbackLedger +from .models import FeedbackReceipt, SourceUseEvent + + +ROOT = Path(__file__).resolve().parents[2] +STEM = "soft_start_snapshot_v1" +MANIFEST_PATH = ROOT / "tests" / "fixtures" / f"{STEM}.manifest.json" +EDGE_FIELDS = ("source_id", "target_id", "edge_type") +STAGES = ("development", "holdout") +POLICIES = ( + "control", + "used_q3_s1", + "confirmed_r05_s1", + "soft_start_r025_r05_s1", +) +_ABSOLUTE_PRIVATE_PATH = re.compile( + r"(?:[A-Za-z]:[\\/]|/Users/|/home/|\\\\[^\\]+\\[^\\]+)" +) +_CREDENTIAL = re.compile( + r"(?i)(?:gh[pousr]_[A-Za-z0-9_]{20,}|github_pat_[A-Za-z0-9_]{20,}|" + r"(?:token|password|secret|api[_-]?key)\s*[:=]\s*[^\s,}]+)" +) + + +def _encoded(payload: Any) -> bytes: + return (json.dumps(payload, ensure_ascii=False, indent=2) + "\n").encode("utf-8") + + +def _sha256_bytes(raw: bytes) -> str: + return hashlib.sha256(raw).hexdigest() + + +def _sha256(path: Path) -> str: + return _sha256_bytes(path.read_bytes()) + + +def read_json(path: Path) -> Any: + raw = path.read_bytes() + text = raw.decode("utf-8", errors="strict") + payload = json.loads(text) + if text != json.dumps(payload, ensure_ascii=False, indent=2) + "\n": + raise ValueError(f"non-canonical JSON artifact: {path}") + return payload + + +def write_json_exclusive(path: Path, payload: Mapping[str, Any]) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o644) + try: + with os.fdopen(descriptor, "wb") as stream: + stream.write(_encoded(payload)) + stream.flush() + os.fsync(stream.fileno()) + except BaseException: + path.unlink(missing_ok=True) + raise + + +def assert_public_payload(payload: Any) -> None: + """Reject private paths, database text, and common credential shapes.""" + + def walk(value: Any, path: tuple[str, ...]) -> None: + if isinstance(value, Mapping): + for key, item in value.items(): + name = str(key) + if name.lower() in { + "node_text", + "document_text", + "raw_text", + "private_path", + "source_path", + "snapshot_path", + }: + raise ValueError(f"private field is forbidden: {'.'.join((*path, name))}") + walk(item, (*path, name)) + elif isinstance(value, (list, tuple)): + for index, item in enumerate(value): + walk(item, (*path, str(index))) + elif isinstance(value, str): + if value.startswith(("/", "\\")) or _ABSOLUTE_PRIVATE_PATH.search(value): + raise ValueError(f"absolute private path is forbidden: {'.'.join(path)}") + if _CREDENTIAL.search(value): + raise ValueError(f"credential-shaped value is forbidden: {'.'.join(path)}") + + walk(payload, ()) + + +def _schema_identity(connection: sqlite3.Connection) -> dict[str, Any]: + rows = [ + {"name": str(row[0]), "sql": str(row[1])} + for row in connection.execute( + """ + SELECT name, sql FROM sqlite_master + WHERE type = 'table' AND name NOT LIKE 'sqlite_%' + ORDER BY name + """ + ) + ] + return { + "schema_sha256": _sha256_bytes(_encoded(rows)), + "table_names": [row["name"] for row in rows], + } + + +def acquire_transactional_snapshot(source: Path, destination: Path) -> dict[str, Any]: + """Create one exclusive SQLite backup without exposing either local path.""" + source = source.resolve(strict=True) + destination = destination.resolve(strict=False) + if source == destination: + raise ValueError("source and snapshot must differ") + destination.parent.mkdir(parents=True, exist_ok=True) + reservation = os.open(destination, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600) + os.close(reservation) + source_before = _sha256(source) + captured_at = datetime.now(timezone.utc).replace(microsecond=0).isoformat() + try: + source_connection = sqlite3.connect(source.as_uri() + "?mode=ro", uri=True) + destination_connection = sqlite3.connect(destination) + try: + source_connection.execute("PRAGMA query_only = ON") + source_connection.backup(destination_connection) + destination_connection.commit() + if destination_connection.execute("PRAGMA integrity_check").fetchone()[0] != "ok": + raise RuntimeError("snapshot integrity check failed") + schema = _schema_identity(destination_connection) + counts = { + name: int(destination_connection.execute(f"SELECT count(*) FROM {name}").fetchone()[0]) + for name in ("nodes", "edges", "retrievals", "success_feedback", "delayed_outcomes") + } + finally: + destination_connection.close() + source_connection.close() + source_after = _sha256(source) + if source_after != source_before: + raise RuntimeError("source database container changed during snapshot acquisition") + provenance = { + "source_locator": "local_codex_ngr_database", + "source_access": "sqlite-uri-mode-ro-query-only", + "capture_method": "sqlite-backup-api", + "captured_at": captured_at, + "source_container_sha256_before": source_before, + "source_container_sha256_after": source_after, + "snapshot_sha256": _sha256(destination), + "snapshot_size": destination.stat().st_size, + **schema, + "row_counts": counts, + } + assert_public_payload(provenance) + return provenance + except BaseException: + destination.unlink(missing_ok=True) + raise + + +def prove_writer_verifier_round_trip(path: Path) -> None: + payload = { + "probe_id": "temporary-soft-start-snapshot-placeholder", + "identities": ["zulu-placeholder", "alpha-placeholder", "mike-placeholder"], + "semantic_round_trip": True, + } + write_json_exclusive(path, payload) + try: + if read_json(path) != payload: + raise ValueError("placeholder semantics changed") + finally: + path.unlink(missing_ok=True) + + +def _load_protocol() -> tuple[dict[str, Any], dict[str, dict[str, Any]]]: + manifest = read_json(MANIFEST_PATH) + registered = verify_manifest_source_hashes( + ROOT, MANIFEST_PATH, manifest["artifact_sha256"] + ) + artifacts = { + name: json.loads(registered.artifact_bytes[relative].decode("utf-8", errors="strict")) + for name, relative in manifest["protocol_artifacts"].items() + } + assert_public_payload(manifest) + assert_public_payload(artifacts) + return manifest, artifacts + + +def _load_current_protocol() -> tuple[dict[str, Any], dict[str, dict[str, Any]]]: + """Load current bytes for the result-free pre-commit probe only.""" + manifest = read_json(MANIFEST_PATH) + for relative, expected in manifest["artifact_sha256"].items(): + path = ROOT / relative + if _sha256(path) != expected: + raise ValueError(f"current artifact hash mismatch: {relative}") + artifacts = { + name: read_json(ROOT / relative) + for name, relative in manifest["protocol_artifacts"].items() + } + assert_public_payload(manifest) + assert_public_payload(artifacts) + return manifest, artifacts + + +def _config( + arm: Mapping[str, Any], base_engine_config: Mapping[str, Any] | None = None +) -> EngineConfig: + values = dict(base_engine_config or {}) + values.update(arm["engine_config"]) + return EngineConfig(**values) + + +def _edge_key(value: Mapping[str, Any] | Sequence[str]) -> str: + if isinstance(value, Mapping): + return "|".join(str(value[field]) for field in EDGE_FIELDS) + return "|".join(str(item) for item in value) + + +def _edge_state(engine: NeuronGraphRAG) -> list[dict[str, Any]]: + states: list[dict[str, Any]] = [] + for edge in engine.store.list_edges(): + identity = (edge.source_id, edge.target_id, edge.edge_type) + confirmed = engine.store.connection.execute( + """ + SELECT confirmation_count, base_increment FROM confirmed_edge_state + WHERE source_id = ? AND target_id = ? AND edge_type = ? + """, + identity, + ).fetchone() + soft = engine.store.connection.execute( + """ + SELECT confirmation_count, base_increment, soft_start_ratio + FROM soft_start_edge_state + WHERE source_id = ? AND target_id = ? AND edge_type = ? + """, + identity, + ).fetchone() + states.append( + { + "source_id": edge.source_id, + "target_id": edge.target_id, + "edge_type": edge.edge_type, + "weight": edge.weight, + "reinforced_count": edge.reinforced_count, + "evidence_count": engine.store.feedback_evidence_count(*identity), + "confirmation_count": ( + int(soft["confirmation_count"]) + if soft is not None + else 0 if confirmed is None else int(confirmed["confirmation_count"]) + ), + "base_increment": ( + float(soft["base_increment"]) + if soft is not None + else None if confirmed is None else float(confirmed["base_increment"]) + ), + "soft_start_ratio": None if soft is None else float(soft["soft_start_ratio"]), + } + ) + return sorted(states, key=_edge_key) + + +def _rank(items: Sequence[Mapping[str, Any]], node_id: str, limit: int) -> int: + return next((int(item["rank"]) for item in items if item["node_id"] == node_id), limit + 1) + + +def _metrics(engine: NeuronGraphRAG, case: Mapping[str, Any], now: float) -> dict[str, Any]: + limit = int(case["retrieval_limit"]) + channels = engine.search_channels(str(case["query"]), limit=limit, now=now) + relation = [ + { + "node_id": hit.node.node_id, + "rank": hit.rank, + "score": hit.channel_score, + } + for hit in channels.relation.hits + ] + target_id = str(case["used_node_id"]) + target_rank = _rank(relation, target_id, limit) + target_score = next((float(item["score"]) for item in relation if item["node_id"] == target_id), 0.0) + competitor = max( + (float(item["score"]) for item in relation if item["node_id"] != target_id), + default=0.0, + ) + direct = engine.search(str(case["direct_query"]), limit=limit, now=now + 0.01) + direct_items = [ + {"node_id": hit.node.node_id, "rank": rank} + for rank, hit in enumerate(direct.hits, 1) + ] + reverse = engine.search_channels(str(case["reverse_query"]), limit=limit, now=now + 0.02) + reverse_items = [ + {"node_id": hit.node.node_id, "rank": hit.rank} + for hit in reverse.relation.hits + ] + return { + "target_rank": target_rank, + "target_mrr": 1.0 / target_rank, + "target_hit_at_k": target_rank <= int(case["hit_k"]), + "score_margin": target_score - competitor, + "top_k": [item["node_id"] for item in relation[: int(case["hit_k"])]], + "direct_rank": _rank(direct_items, str(case["direct_node_id"]), limit), + "reverse_rank": _rank(reverse_items, str(case["reverse_node_id"]), limit), + } + + +def _feedback_semantics(feedback: FeedbackReceipt | None) -> dict[str, Any] | None: + if feedback is None: + return None + return { + "channel": feedback.channel, + "reinforced": [asdict(item) for item in feedback.reinforced_edges], + "normalized": [asdict(item) for item in feedback.normalized_sibling_edges], + "evidence": [asdict(item) for item in feedback.evidence], + } + + +def _source_use( + engine: NeuronGraphRAG, + arm_id: str, + trace_id: str, + node_id: str, + key: str, + now: float, +) -> dict[str, Any]: + events = tuple(SourceUseEvent(node_id, stage) for stage in ("selected", "validated", "used")) + if arm_id == "control": + payload = json.dumps( + {"trace_id": trace_id, "events": [asdict(event) for event in events]}, + sort_keys=True, + separators=(",", ":"), + ) + arguments = { + "idempotency_key": key, + "payload_json": payload, + "receipt_id": f"control-{key}", + "trace_id": trace_id, + "created_at": now, + "events": tuple((event.node_id, event.stage) for event in events), + "apply_feedback": None, + "confirmation_candidate": False, + } + receipt = engine.store.record_source_use(**arguments) + replay = engine.store.record_source_use(**arguments) + return { + "stages": [event["stage"] for event in receipt["events"]], + "changed": [bool(event["changed"]) for event in receipt["events"]], + "newly_used_node_ids": receipt["newly_used_node_ids"], + "feedback": None, + "idempotency_replay_equal": replay == receipt, + } + ledger = FeedbackLedger(engine) + receipt = ledger.record_source_use(trace_id, events, idempotency_key=key, now=now) + replay = ledger.record_source_use(trace_id, events, idempotency_key=key, now=now) + return { + "stages": [item.stage for item in receipt.events], + "changed": [item.changed for item in receipt.events], + "newly_used_node_ids": list(receipt.newly_used_node_ids), + "feedback": _feedback_semantics(receipt.feedback), + "idempotency_replay_equal": replay == receipt, + } + + +def _outcome( + engine: NeuronGraphRAG, + arm_id: str, + trace_id: str, + node_id: str, + outcome: str, + key: str, + now: float, +) -> dict[str, Any]: + summary = "fixed registered outcome" + if arm_id == "control": + payload = json.dumps( + { + "trace_id": trace_id, + "node_ids": [node_id], + "outcome": outcome, + "summary": summary, + "external_ref": None, + }, + sort_keys=True, + separators=(",", ":"), + ) + arguments = { + "idempotency_key": key, + "payload_json": payload, + "outcome_id": f"control-{key}", + "trace_id": trace_id, + "node_ids": (node_id,), + "outcome": outcome, + "summary": summary, + "external_ref": None, + "recorded_at": now, + } + receipt = engine.store.record_outcome(**arguments) + replay = engine.store.record_outcome(**arguments) + return { + "outcome": outcome, + "reinforcement_applied": False, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": replay == receipt, + } + ledger = FeedbackLedger(engine) + receipt = ledger.record_outcome( + trace_id, + [node_id], + outcome, + summary, + idempotency_key=key, + now=now, + ) + replay = ledger.record_outcome( + trace_id, + [node_id], + outcome, + summary, + idempotency_key=key, + now=now, + ) + return { + "outcome": receipt.outcome, + "reinforcement_applied": receipt.reinforcement_applied, + "confirmations": [asdict(item) for item in receipt.confirmations], + "credited_paths": [asdict(item) for item in receipt.credited_paths], + "normalized": [asdict(item) for item in receipt.normalized_sibling_edges], + "idempotency_replay_equal": replay == receipt, + } + + +def _checkpoint( + engine: NeuronGraphRAG, + case: Mapping[str, Any], + name: str, + now: float, + baseline: Mapping[str, Any] | None, +) -> dict[str, Any]: + metrics = _metrics(engine, case, now) + edges = _edge_state(engine) + if baseline is None: + changed_edges: list[str] = [] + entry: list[str] = [] + exit_items: list[str] = [] + non_target_churn = 0 + else: + previous = {_edge_key(item): item for item in baseline["edges"]} + changed_edges = [ + _edge_key(item) + for item in edges + if any( + item[field] != previous[_edge_key(item)][field] + for field in ("weight", "reinforced_count", "evidence_count", "confirmation_count") + ) + ] + current_top = set(metrics["top_k"]) + baseline_top = set(baseline["metrics"]["top_k"]) + entry = sorted(current_top - baseline_top) + exit_items = sorted(baseline_top - current_top) + excluded = {str(case["used_node_id"]), str(case["source_node_id"])} + non_target_churn = len((current_top ^ baseline_top) - excluded) + return { + "name": name, + "metrics": metrics, + "edges": edges, + "changed_edges": changed_edges, + "top_k_entry": entry, + "top_k_exit": exit_items, + "non_target_churn": non_target_churn, + } + + +def _select_trace(engine: NeuronGraphRAG, case: Mapping[str, Any], now: float) -> str: + channels = engine.search_channels( + str(case["query"]), limit=int(case["retrieval_limit"]), now=now + ) + trace = channels.relation if case["search_surface"] == "relation" else channels.lexical + node_id = str(case["used_node_id"]) + if node_id not in {hit.node.node_id for hit in trace.hits}: + raise RuntimeError("registered used node is absent from its search trace") + if case["search_surface"] == "relation" and case["case_role"] in {"confirmed", "corrected"}: + paths = engine.store.retrieval_paths(trace.trace_id, node_id) + expected = tuple( + str(case["credited_edge"][field]) for field in EDGE_FIELDS + ) + if not any( + any( + (step["source_id"], step["target_id"], step["edge_type"]) == expected + for step in path["steps"] + ) + for path in paths + ): + raise RuntimeError("registered credited edge is absent from relation provenance") + return trace.trace_id + + +def _run_case( + engine: NeuronGraphRAG, + arm_id: str, + case: Mapping[str, Any], + case_index: int, +) -> dict[str, Any]: + clock = 100_000.0 + case_index * 10_000.0 + baseline = _checkpoint(engine, case, "baseline", clock, None) + checkpoints = [baseline] + receipts: list[dict[str, Any]] = [] + for iteration in range(1, 4): + trace_id = _select_trace(engine, case, clock + iteration * 100.0) + use = _source_use( + engine, + arm_id, + trace_id, + str(case["used_node_id"]), + f"{arm_id}-{case['case_id']}-use-{iteration}", + clock + iteration * 100.0 + 0.1, + ) + checkpoints.append( + _checkpoint( + engine, + case, + f"used_{iteration}", + clock + iteration * 100.0 + 10.0, + baseline, + ) + ) + outcome = _outcome( + engine, + arm_id, + trace_id, + str(case["used_node_id"]), + str(case["outcome"]), + f"{arm_id}-{case['case_id']}-outcome-{iteration}", + clock + iteration * 100.0 + 20.0, + ) + receipts.append({"iteration": iteration, "source_use": use, "outcome": outcome}) + checkpoints.append( + _checkpoint( + engine, + case, + f"outcome_{iteration}", + clock + iteration * 100.0 + 30.0, + baseline, + ) + ) + return { + "case_id": case["case_id"], + "case_role": case["case_role"], + "checkpoints": checkpoints, + "receipts": receipts, + } + + +def _run_arm( + snapshot: Path, + arm: Mapping[str, Any], + base_engine_config: Mapping[str, Any], + cases: Sequence[Mapping[str, Any]], +) -> dict[str, Any]: + with TemporaryDirectory() as directory: + clone = Path(directory) / "arm.sqlite" + shutil.copyfile(snapshot, clone) + with NeuronGraphRAG(clone, config=_config(arm, base_engine_config)) as engine: + initial = _edge_state(engine) + observed_cases = [ + _run_case(engine, str(arm["arm_id"]), case, index) + for index, case in enumerate(cases) + ] + final = _edge_state(engine) + return { + "arm_id": arm["arm_id"], + "policy": arm["policy"], + "effective_config_provenance": effective_config_provenance( + _config(arm, base_engine_config) + ), + "initial_edges": initial, + "cases": observed_cases, + "final_edges": final, + } + + +def _checkpoint_by_name(case: Mapping[str, Any], name: str) -> Mapping[str, Any]: + return next(item for item in case["checkpoints"] if item["name"] == name) + + +def _case_by_role(arm: Mapping[str, Any], role: str) -> Mapping[str, Any]: + return next(item for item in arm["cases"] if item["case_role"] == role) + + +def _edge_at(checkpoint: Mapping[str, Any], key: str) -> Mapping[str, Any]: + return next(item for item in checkpoint["edges"] if _edge_key(item) == key) + + +def _delta(case: Mapping[str, Any], checkpoint: str, key: str) -> float: + baseline = _edge_at(_checkpoint_by_name(case, "baseline"), key) + current = _edge_at(_checkpoint_by_name(case, checkpoint), key) + return float(current["weight"]) - float(baseline["weight"]) + + +def evaluate_gates( + preflight: Mapping[str, Any], + cases: Sequence[Mapping[str, Any]], + arms: Mapping[str, Mapping[str, Any]], + thresholds: Mapping[str, Any], +) -> dict[str, bool]: + control = arms["control"] + used = arms["used_q3_s1"] + confirmed = arms["confirmed_r05_s1"] + soft = arms["soft_start_r025_r05_s1"] + registered = {str(case["case_id"]): case for case in cases} + all_receipts = [ + receipt + for arm in arms.values() + for case in arm["cases"] + for receipt in case["receipts"] + ] + protocol_integrity = bool(preflight["passed"]) and all( + bool(arm["fresh_clone_replay"]) for arm in arms.values() + ) and all( + receipt["source_use"]["idempotency_replay_equal"] + and receipt["outcome"]["idempotency_replay_equal"] + for receipt in all_receipts + ) + + confirmed_case = _case_by_role(soft, "confirmed") + confirmed_key = _edge_key(registered[str(confirmed_case["case_id"])]["credited_edge"]) + soft_receipts = confirmed_case["receipts"] + provisional = _delta(confirmed_case, "used_1", confirmed_key) + first_total = _delta(confirmed_case, "outcome_1", confirmed_key) + later = [ + receipt["outcome"]["confirmations"][0] + for receipt in soft_receipts[1:] + if receipt["outcome"]["confirmations"] + ] + confirmed_reference = _delta( + _case_by_role(confirmed, "confirmed"), "outcome_1", confirmed_key + ) + soft_schedule = ( + provisional > 0.0 + and first_total <= confirmed_reference + 1e-12 + and abs(first_total - confirmed_reference) <= 1e-12 + and [item["multiplier"] for item in later] == [0.5, 0.25] + and later[1]["actual_delta"] <= later[0]["actual_delta"] + ) + + used_case = _case_by_role(used, "confirmed") + confirmed_only_case = _case_by_role(confirmed, "confirmed") + policy_boundaries = ( + _delta(used_case, "used_1", confirmed_key) == 0.0 + and _delta(used_case, "used_2", confirmed_key) == 0.0 + and _delta(used_case, "used_3", confirmed_key) > 0.0 + and _delta(confirmed_only_case, "used_1", confirmed_key) == 0.0 + and _delta(confirmed_only_case, "outcome_1", confirmed_key) > 0.0 + and all(initial == final for initial, final in zip(control["initial_edges"], control["final_edges"])) + ) + + soft_first = _checkpoint_by_name(confirmed_case, "used_1")["metrics"]["target_mrr"] + used_first = _checkpoint_by_name(used_case, "used_1")["metrics"]["target_mrr"] + confirmed_first = _checkpoint_by_name(confirmed_only_case, "used_1")["metrics"]["target_mrr"] + soft_final = _checkpoint_by_name(confirmed_case, "outcome_3")["metrics"]["target_mrr"] + used_final = _checkpoint_by_name(used_case, "outcome_3")["metrics"]["target_mrr"] + latency_quality = ( + provisional > 0.0 + and _delta(used_case, "used_1", confirmed_key) == 0.0 + and _delta(confirmed_only_case, "used_1", confirmed_key) == 0.0 + and soft_first >= min(used_first, confirmed_first) + and soft_final >= used_final + ) + + corrected = _case_by_role(soft, "corrected") + corrected_config = registered[str(corrected["case_id"])] + corrected_key = _edge_key(corrected_config["credited_edge"]) + corrected_used = _edge_at(_checkpoint_by_name(corrected, "used_1"), corrected_key) + corrected_base = float(corrected_used["base_increment"] or 0.0) + corrected_cost = _delta(corrected, "outcome_3", corrected_key) + negative_cost = ( + corrected_cost > 0.0 + and corrected_cost <= corrected_base * float(thresholds["negative_provisional_ratio_max"]) + 1e-12 + and _delta(corrected, "used_1", corrected_key) == corrected_cost + and not any( + receipt["outcome"]["reinforcement_applied"] for receipt in corrected["receipts"] + ) + ) + + control_roles = {"lexical", "zero_hop"} + control_safety = True + for arm in arms.values(): + for case in arm["cases"]: + baseline = _checkpoint_by_name(case, "baseline") + final = _checkpoint_by_name(case, "outcome_3") + if case["case_role"] in control_roles and final["changed_edges"]: + control_safety = False + if ( + final["metrics"]["direct_rank"] > baseline["metrics"]["direct_rank"] + or final["metrics"]["reverse_rank"] > baseline["metrics"]["reverse_rank"] + ): + control_safety = False + + locality = True + for arm_id, arm in arms.items(): + initial = {_edge_key(item): item for item in arm["initial_edges"]} + final = {_edge_key(item): item for item in arm["final_edges"]} + changed = { + key + for key in initial + if any( + initial[key][field] != final[key][field] + for field in ("weight", "reinforced_count", "evidence_count", "confirmation_count") + ) + } + allowed = set() if arm_id == "control" else { + edge + for case in cases + if case["case_role"] in {"confirmed", "corrected"} + for edge in case["allowed_mutation_edges"] + } + if not changed <= allowed: + locality = False + locality = locality and bool(preflight["snapshot_unchanged"]) + return { + "protocol-integrity": protocol_integrity, + "soft-start-schedule": soft_schedule, + "policy-boundaries": policy_boundaries, + "learning-latency-and-quality": latency_quality, + "negative-provisional-bound": negative_cost, + "control-rank-and-mutation-safety": control_safety, + "mutation-locality-and-source-isolation": locality, + } + + +def _preflight( + snapshot: Path, + manifest: Mapping[str, Any], + artifacts: Mapping[str, Mapping[str, Any]], + stage: str, +) -> dict[str, Any]: + output = ROOT / str(manifest["outputs"][stage]) + development = ROOT / str(manifest["outputs"]["development"]) + holdout = ROOT / str(manifest["outputs"]["holdout"]) + fixture = artifacts["fixture"] + cases = fixture["stages"][stage] + snapshot_before = _sha256(snapshot) + with sqlite3.connect(snapshot.as_uri() + "?mode=ro", uri=True) as connection: + connection.execute("PRAGMA query_only = ON") + schema = _schema_identity(connection) + row_counts = { + name: int(connection.execute(f"SELECT count(*) FROM {name}").fetchone()[0]) + for name in manifest["snapshot"]["row_counts"] + } + node_ids = { + str(row[0]) for row in connection.execute("SELECT node_id FROM nodes") + } + edge_keys = { + "|".join(str(item) for item in row) + for row in connection.execute( + "SELECT source_id, target_id, edge_type FROM edges" + ) + } + registered_nodes = { + str(case[field]) + for case in cases + for field in ("used_node_id", "source_node_id", "direct_node_id", "reverse_node_id") + } + registered_edges = { + _edge_key(case["credited_edge"]) + for case in cases + if case["case_role"] in {"confirmed", "corrected"} + } + trace_eligibility = True + try: + with TemporaryDirectory() as directory: + probe = Path(directory) / "probe.sqlite" + shutil.copyfile(snapshot, probe) + probe_arm = next( + arm + for arm in artifacts["schedule"]["arms"] + if arm["arm_id"] == "soft_start_r025_r05_s1" + ) + with NeuronGraphRAG( + probe, + config=_config( + probe_arm, artifacts["schedule"]["base_engine_config"] + ), + ) as engine: + for index, case in enumerate(cases): + _select_trace(engine, case, 80_000.0 + index) + except Exception: # noqa: BLE001 - the public report records only pass/fail + trace_eligibility = False + checks = { + "snapshot_hash": snapshot_before == manifest["snapshot"]["snapshot_sha256"], + "snapshot_size": snapshot.stat().st_size == manifest["snapshot"]["snapshot_size"], + "snapshot_schema": schema["schema_sha256"] + == manifest["snapshot"]["schema_sha256"] + and schema["table_names"] == manifest["snapshot"]["table_names"], + "snapshot_row_counts": row_counts == manifest["snapshot"]["row_counts"], + "registered_nodes": registered_nodes <= node_ids, + "registered_edges": registered_edges <= edge_keys, + "trace_eligibility": trace_eligibility, + "arm_order": [arm["arm_id"] for arm in artifacts["schedule"]["arms"]] == list(POLICIES), + "case_identity": len({case["case_id"] for case in cases}) == len(cases), + "event_order": artifacts["schedule"]["event_order"] + == ["used_1", "outcome_1", "used_2", "outcome_2", "used_3", "outcome_3"], + "registered_output_absent": not output.exists(), + "result_free_stage_order": stage != "development" or not holdout.exists(), + "conditional_holdout": stage == "development" + or ( + development.exists() + and _verified_development_passed(development, manifest, artifacts) + ), + "privacy": True, + "placeholder_round_trip": artifacts["audit"]["placeholder_round_trip_passed"] is True, + } + return { + "checks": checks, + "passed": all(checks.values()), + "snapshot_sha256_before": snapshot_before, + "snapshot_sha256_after": _sha256(snapshot), + "snapshot_unchanged": _sha256(snapshot) == snapshot_before, + } + + +def _gate_ids(gate: Mapping[str, Any]) -> list[str]: + values = [str(item["gate_id"]) for item in gate["gates"]] + if not values or len(values) != len(set(values)): + raise ValueError("gate IDs must be non-empty and unique") + return values + + +def _semantic_hash(payload: Mapping[str, Any]) -> str: + return _sha256_bytes(_encoded(payload)) + + +def _verified_development_passed( + path: Path, + manifest: Mapping[str, Any], + artifacts: Mapping[str, Mapping[str, Any]], +) -> bool: + payload = read_json(path) + verify_observed_payload(payload, manifest, artifacts) + return payload["stage"] == "development" and payload["all_hard_gates_pass"] is True + + +def _interpretation(decision: str) -> dict[str, str]: + summaries = { + "支持": "固定したlocal snapshotとhard gateの範囲でsoft-start cutover候補を支持する。", + "不支持": "固定したlocal snapshotとhard gateの範囲でsoft-startの比較優位は成立しなかった。", + "判定不能": "固定protocolを完走できず、soft-start cutover可否は判定不能である。", + } + return { + "decision": decision, + "summary": summaries[decision], + "scope": "local snapshot限定。external corpus、production quality、library defaultへ一般化せず、source databaseとlive configを変更しない。", + } + + +def verify_observed_payload( + payload: Mapping[str, Any], + manifest: Mapping[str, Any], + artifacts: Mapping[str, Mapping[str, Any]], +) -> None: + assert_public_payload(payload) + if list(payload) != artifacts["result_schema"]["top_level_fields"]: + raise ValueError("observed top-level field order differs from frozen schema") + if payload["protocol_id"] != manifest["protocol_id"]: + raise ValueError("observed protocol identity differs") + if payload["stage"] not in STAGES: + raise ValueError("observed stage differs from registration") + if payload["snapshot"] != manifest["snapshot"]: + raise ValueError("observed snapshot identity differs from registration") + if payload["protocol_hashes"] != manifest["artifact_sha256"]: + raise ValueError("observed protocol hashes differ from registration") + gate_ids = _gate_ids(artifacts["gate"]) + if [item["gate_id"] for item in payload["gates"]] != gate_ids: + raise ValueError("observed gate order differs") + if payload["status"] == "completed": + expected_order = [ + arm["arm_id"] for arm in artifacts["schedule"]["arms"] + ] + if [arm["arm_id"] for arm in payload["arms"]] != expected_order: + raise ValueError("observed arm order differs from registration") + semantic_fields = ( + "arm_id", + "policy", + "effective_config_provenance", + "initial_edges", + "cases", + "final_edges", + ) + for arm in payload["arms"]: + semantic = {field: arm[field] for field in semantic_fields} + if arm["semantic_sha256"] != _semantic_hash(semantic): + raise ValueError("observed arm semantic hash differs") + arms = {arm["arm_id"]: arm for arm in payload["arms"]} + computed = evaluate_gates( + payload["preflight"], + artifacts["fixture"]["stages"][payload["stage"]], + arms, + artifacts["gate"]["thresholds"], + ) + if {item["gate_id"]: item["passed"] for item in payload["gates"]} != computed: + raise ValueError("gate results are not recomputable") + if payload["failure_code"] is not None: + raise ValueError("completed result cannot carry a failure code") + expected = "支持" if all(computed.values()) else "不支持" + elif payload["status"] == "indeterminate": + if payload["arms"] or any(item["passed"] for item in payload["gates"]): + raise ValueError("indeterminate result must not claim observations") + if payload["failure_code"] not in artifacts["result_schema"]["failure_codes"]: + raise ValueError("unknown failure code") + expected = "判定不能" + else: + raise ValueError("unknown result status") + if payload["all_hard_gates_pass"] is not all(item["passed"] for item in payload["gates"]): + raise ValueError("all_hard_gates_pass is not recomputable") + if payload["interpretation_ja"] != _interpretation(expected): + raise ValueError("interpretation differs from frozen decision mapping") + + +def run_registered_stage(stage: str, snapshot: Path) -> Path: + if stage not in STAGES: + raise ValueError("stage must be development or holdout") + manifest, artifacts = _load_protocol() + output = ROOT / str(manifest["outputs"][stage]) + if output.exists(): + raise FileExistsError(f"registered output already exists: {stage}") + preflight: dict[str, Any] = { + "checks": {}, + "passed": False, + "snapshot_sha256_before": None, + "snapshot_sha256_after": None, + "snapshot_unchanged": False, + } + arms: list[dict[str, Any]] = [] + failure_code: str | None = None + try: + preflight = _preflight(snapshot, manifest, artifacts, stage) + if not preflight["passed"]: + raise RuntimeError("preflight") + cases = artifacts["fixture"]["stages"][stage] + for arm in artifacts["schedule"]["arms"]: + primary = _run_arm( + snapshot, arm, artifacts["schedule"]["base_engine_config"], cases + ) + replay = _run_arm( + snapshot, arm, artifacts["schedule"]["base_engine_config"], cases + ) + primary["semantic_sha256"] = _semantic_hash(primary) + primary["fresh_clone_replay"] = replay == { + key: primary[key] + for key in ("arm_id", "policy", "effective_config_provenance", "initial_edges", "cases", "final_edges") + } + arms.append(primary) + preflight["snapshot_sha256_after"] = _sha256(snapshot) + preflight["snapshot_unchanged"] = ( + preflight["snapshot_sha256_after"] == preflight["snapshot_sha256_before"] + ) + computed = evaluate_gates( + preflight, + cases, + {arm["arm_id"]: arm for arm in arms}, + artifacts["gate"]["thresholds"], + ) + status = "completed" + decision = "支持" if all(computed.values()) else "不支持" + except Exception as error: # noqa: BLE001 - a one-time protocol failure is evidence + failure_code = "preflight-failed" if str(error) == "preflight" else "execution-failed" + arms = [] + computed = {gate_id: False for gate_id in _gate_ids(artifacts["gate"])} + status = "indeterminate" + decision = "判定不能" + gate_ids = _gate_ids(artifacts["gate"]) + payload = { + "protocol_id": manifest["protocol_id"], + "stage": stage, + "status": status, + "failure_code": failure_code, + "snapshot": manifest["snapshot"], + "protocol_hashes": manifest["artifact_sha256"], + "preflight": preflight, + "arms": arms, + "gates": [{"gate_id": gate_id, "passed": computed[gate_id]} for gate_id in gate_ids], + "all_hard_gates_pass": all(computed.values()), + "interpretation_ja": _interpretation(decision), + } + verify_observed_payload(payload, manifest, artifacts) + write_json_exclusive(output, payload) + verify_observed_payload(read_json(output), manifest, artifacts) + return output + + +def verify_registered_result(stage: str) -> None: + if stage not in STAGES: + raise ValueError("stage must be development or holdout") + manifest, artifacts = _load_protocol() + verify_observed_payload(read_json(ROOT / str(manifest["outputs"][stage])), manifest, artifacts) + + +def preflight_snapshot(snapshot: Path) -> dict[str, Any]: + manifest, artifacts = _load_current_protocol() + report = { + stage: _preflight(snapshot, manifest, artifacts, stage) + for stage in STAGES + if stage == "development" + } + assert_public_payload(report) + return report diff --git a/tests/fixtures/soft_start_snapshot_v1.development.observed.json b/tests/fixtures/soft_start_snapshot_v1.development.observed.json new file mode 100644 index 0000000..4b60493 --- /dev/null +++ b/tests/fixtures/soft_start_snapshot_v1.development.observed.json @@ -0,0 +1,45351 @@ +{ + "protocol_id": "soft-start-snapshot-v1", + "stage": "development", + "status": "completed", + "failure_code": null, + "snapshot": { + "source_locator": "local_codex_ngr_database", + "source_access": "sqlite-uri-mode-ro-query-only", + "capture_method": "sqlite-backup-api", + "captured_at": "2026-08-21T00:48:04+00:00", + "source_container_sha256_before": "90c664d345aab9a9ccf36943b5b503cf98e9588577db0e7ccd4f07b27cb33fe0", + "source_container_sha256_after": "90c664d345aab9a9ccf36943b5b503cf98e9588577db0e7ccd4f07b27cb33fe0", + "snapshot_sha256": "003f24478f8d18dd34ab6aee5d939202d116f195ac8db33c29e38ab7e0f456d1", + "snapshot_size": 425984, + "schema_sha256": "a4e58aa7675a6d9e3d9dd7fa778d5bbb4d0ec45eecc262e62f87e019a3ccae9f", + "table_names": [ + "activation_state", + "confirmed_edge_state", + "confirmed_relation_feedback", + "confirmed_source_uses", + "delayed_outcome_nodes", + "delayed_outcomes", + "edges", + "feedback_requests", + "nodes", + "relation_feedback_evidence", + "retrieval_channels", + "retrieval_results", + "retrievals", + "source_use_state", + "success_feedback", + "success_nodes" + ], + "row_counts": { + "nodes": 21, + "edges": 30, + "retrievals": 24, + "success_feedback": 10, + "delayed_outcomes": 3 + } + }, + "protocol_hashes": { + "src/neuron_graph_rag/soft_start_snapshot_evaluation.py": "d7f7b421315118c96ccb9e796524dd02c0edec2c0f6fb2f7398b7ad88be58f13", + "tools/run_soft_start_snapshot_evaluation.py": "c15a14b4b0d2c8498f70b01a7e75aa45a1c8a670690638bdc7c4b2aa3654c2da", + "tests/test_soft_start_snapshot_evaluation.py": "a43c5dcfa2afe4506bcf2966cfbe6fab4ce7e09f37c9eb82b6608a5310b21210", + "tests/fixtures/soft_start_snapshot_v1.fixture.json": "9d785ffa49c6cca590a088c50bb33cc1b55d3120063c7e0f9ef33603ea07ace9", + "tests/fixtures/soft_start_snapshot_v1.schedule.json": "932ea6636f81fe3e0a68a1e78e48ce423d08511a7235185d9d02b38d6421f331", + "tests/fixtures/soft_start_snapshot_v1.gate.json": "f38e1d052fede8380a86344b80332506405343f2e73d6efe40bf74addd5f907e", + "tests/fixtures/soft_start_snapshot_v1.result-schema.json": "65c380803004eafa6e2faae259108ea972ce26dafe1284590d8580703055b5b4", + "tests/fixtures/soft_start_snapshot_v1.result-free-audit.json": "3169c3fcef89bbe10d29c103e4e294887da13d81983d27dc7ccd9b3a697a69c2", + "docs/soft-start-snapshot-evaluation.md": "f19d578a3babb07a6a3c86dfe678bf0566e29871b80722a437bcb143a31ab980", + "docs/requirements.md": "8d39e4eb3da6e3fa27b4b57cc63e8e3951be28d539fcac71f258533a69d7249b", + "docs/Decision-Structure.md": "a35f485db4adc6b403fe8f3ff5db270df3d0da5aae94313f3d79e54762b0bb67", + "README.md": "1222d1146560719b19f5d1962f12740a4929cb02bf97ad93830723ac1845d08a" + }, + "preflight": { + "checks": { + "snapshot_hash": true, + "snapshot_size": true, + "snapshot_schema": true, + "snapshot_row_counts": true, + "registered_nodes": true, + "registered_edges": true, + "trace_eligibility": true, + "arm_order": true, + "case_identity": true, + "event_order": true, + "registered_output_absent": true, + "result_free_stage_order": true, + "conditional_holdout": true, + "privacy": true, + "placeholder_round_trip": true + }, + "passed": true, + "snapshot_sha256_before": "003f24478f8d18dd34ab6aee5d939202d116f195ac8db33c29e38ab7e0f456d1", + "snapshot_sha256_after": "003f24478f8d18dd34ab6aee5d939202d116f195ac8db33c29e38ab7e0f456d1", + "snapshot_unchanged": true + }, + "arms": [ + { + "arm_id": "control", + "policy": "audit-only", + "effective_config_provenance": { + "effective_config": { + "retrieval": { + "activation_budget": 1.0, + "activation_half_life_seconds": 3600.0, + "activation_strategy": "current_positive_additive", + "convergence_tolerance": 1e-09, + "dense_weight": 0.45, + "entry_weight": 0.55, + "final_fusion_strategy": "linear", + "graph_normalization": "max", + "graph_weight": 0.45, + "hop_decay": 0.7, + "inhibition_ratio": 0.0, + "inhibition_top_k": 0, + "max_active_paths_per_node": 4, + "max_hops": 2, + "max_paths_per_node": 4, + "max_propagation_expansions": 10000, + "maximum_activation": 10.0, + "query_transmission_floor": 0.4, + "query_transmission_power": 1.0, + "recurrent_decay": 0.5, + "recurrent_steps": 3, + "rrf_k": 60, + "seed_count": 3, + "sparse_weight": 0.55, + "use_dense_retrieval": true, + "use_graph_propagation": true + }, + "feedback": { + "confirmation_decay_ratio": null, + "confirmed_outcome_reinforcement": false, + "feedback_learning_rate": 0.2, + "maximum_edge_weight": 2.0, + "relation_feedback_evidence_quorum": 1, + "sibling_feedback_normalization": 1.0 + } + }, + "retrieval_config_fingerprint": "sha256:bfc95085fdc8870ecd1ef119edbad55869697f4265ed7a3f71431405709252b8", + "feedback_config_fingerprint": "sha256:455f39a483f342f3d2c4ec4651b464ee99e04fb3a5df079be8321e6becb96643", + "full_config_fingerprint": "sha256:03de470952a6b705500ffd169727eb22eb21463419347ad6696e405e2be255bf" + }, + "initial_edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "cases": [ + { + "case_id": "dev-confirmed-requirements-to-mcp", + "case_role": "confirmed", + "checkpoints": [ + { + "name": "baseline", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.02016371927147785, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_1", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.02016371927147785, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_1", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.02016371927147785, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_2", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.02016371927147785, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_2", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.02016371927147785, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_3", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.02016371927147785, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_3", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.02016371927147785, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + } + ], + "receipts": [ + { + "iteration": 1, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 2, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 3, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + } + ] + }, + { + "case_id": "dev-corrected-sibling-evaluation", + "case_role": "corrected", + "checkpoints": [ + { + "name": "baseline", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.2832103318995752, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/sibling-relation-feedback-normalization.md" + ], + "direct_rank": 1, + "reverse_rank": 5 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_1", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.2832103318995752, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/sibling-relation-feedback-normalization.md" + ], + "direct_rank": 1, + "reverse_rank": 5 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_1", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.2832103318995752, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/sibling-relation-feedback-normalization.md" + ], + "direct_rank": 1, + "reverse_rank": 5 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_2", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.2832103318995752, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/sibling-relation-feedback-normalization.md" + ], + "direct_rank": 1, + "reverse_rank": 5 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_2", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.2832103318995752, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/sibling-relation-feedback-normalization.md" + ], + "direct_rank": 1, + "reverse_rank": 5 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_3", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.2832103318995752, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/sibling-relation-feedback-normalization.md" + ], + "direct_rank": 1, + "reverse_rank": 5 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_3", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.2832103318995752, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/sibling-relation-feedback-normalization.md" + ], + "direct_rank": 1, + "reverse_rank": 5 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + } + ], + "receipts": [ + { + "iteration": 1, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/sibling-normalization-controlled-evaluation.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "corrected", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 2, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/sibling-normalization-controlled-evaluation.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "corrected", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 3, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/sibling-normalization-controlled-evaluation.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "corrected", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + } + ] + }, + { + "case_id": "dev-lexical-mcp-control", + "case_role": "lexical", + "checkpoints": [ + { + "name": "baseline", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.0001115754350962117, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_1", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.0001115754350962117, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_1", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.0001115754350962117, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_2", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.0001115754350962117, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_2", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.0001115754350962117, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_3", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.0001115754350962117, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_3", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.0001115754350962117, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + } + ], + "receipts": [ + { + "iteration": 1, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 2, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 3, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + } + ] + }, + { + "case_id": "dev-zero-hop-requirements-control", + "case_role": "zero_hop", + "checkpoints": [ + { + "name": "baseline", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_1", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_1", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_2", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_2", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_3", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_3", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + } + ], + "receipts": [ + { + "iteration": 1, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/requirements.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 2, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/requirements.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 3, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/requirements.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + } + ] + } + ], + "final_edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "semantic_sha256": "812e1c435561e529329e75b153a2f4d6153af552e571d12f2701929c222411b4", + "fresh_clone_replay": true + }, + { + "arm_id": "used_q3_s1", + "policy": "used-evidence-quorum-3-sibling-1.0", + "effective_config_provenance": { + "effective_config": { + "retrieval": { + "activation_budget": 1.0, + "activation_half_life_seconds": 3600.0, + "activation_strategy": "current_positive_additive", + "convergence_tolerance": 1e-09, + "dense_weight": 0.45, + "entry_weight": 0.55, + "final_fusion_strategy": "linear", + "graph_normalization": "max", + "graph_weight": 0.45, + "hop_decay": 0.7, + "inhibition_ratio": 0.0, + "inhibition_top_k": 0, + "max_active_paths_per_node": 4, + "max_hops": 2, + "max_paths_per_node": 4, + "max_propagation_expansions": 10000, + "maximum_activation": 10.0, + "query_transmission_floor": 0.4, + "query_transmission_power": 1.0, + "recurrent_decay": 0.5, + "recurrent_steps": 3, + "rrf_k": 60, + "seed_count": 3, + "sparse_weight": 0.55, + "use_dense_retrieval": true, + "use_graph_propagation": true + }, + "feedback": { + "confirmation_decay_ratio": null, + "confirmed_outcome_reinforcement": false, + "feedback_learning_rate": 0.2, + "maximum_edge_weight": 2.0, + "relation_feedback_evidence_quorum": 3, + "sibling_feedback_normalization": 1.0 + } + }, + "retrieval_config_fingerprint": "sha256:bfc95085fdc8870ecd1ef119edbad55869697f4265ed7a3f71431405709252b8", + "feedback_config_fingerprint": "sha256:a8704079446125f3e3e6b7cef83a80df7bae8a6e7cf46fe6702dde624b504d06", + "full_config_fingerprint": "sha256:8a0722d60159449ca0e09378469fd4be8be24eaf416211ce0e712e6029d98f1d" + }, + "initial_edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "cases": [ + { + "case_id": "dev-confirmed-requirements-to-mcp", + "case_role": "confirmed", + "checkpoints": [ + { + "name": "baseline", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.02016371927147785, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_1", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.02016371927147785, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [ + "docs/requirements.md|docs/optional-mcp-interface.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_1", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.02016371927147785, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [ + "docs/requirements.md|docs/optional-mcp-interface.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_2", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.018583132160375347, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5523130070034725, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5838763091453019, + "reinforced_count": 2, + "evidence_count": 3, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5612156339253269, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [ + "docs/requirements.md|docs/anchored-bm25-graph-hybrid-experiment.md|links_to", + "docs/requirements.md|docs/anchored-fusion-calibration-experiment.md|links_to", + "docs/requirements.md|docs/blind-llm-channel-selection-experiment.md|links_to", + "docs/requirements.md|docs/d1-corpus-fixture.md|links_to", + "docs/requirements.md|docs/engine-backed-feedback-trajectory-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-reproduction-experiment.md|links_to", + "docs/requirements.md|docs/independent-retrieval-channels-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-local-competition-experiment.md|links_to", + "docs/requirements.md|docs/node-first-blind-selection-experiment.md|links_to", + "docs/requirements.md|docs/optional-mcp-interface.md|links_to", + "docs/requirements.md|docs/real-corpus-benchmark.md|links_to", + "docs/requirements.md|docs/sibling-normalization-controlled-evaluation.md|links_to", + "docs/requirements.md|docs/sibling-relation-feedback-normalization.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_2", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.018583132160375347, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5523130070034725, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5838763091453019, + "reinforced_count": 2, + "evidence_count": 3, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5612156339253269, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [ + "docs/requirements.md|docs/anchored-bm25-graph-hybrid-experiment.md|links_to", + "docs/requirements.md|docs/anchored-fusion-calibration-experiment.md|links_to", + "docs/requirements.md|docs/blind-llm-channel-selection-experiment.md|links_to", + "docs/requirements.md|docs/d1-corpus-fixture.md|links_to", + "docs/requirements.md|docs/engine-backed-feedback-trajectory-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-reproduction-experiment.md|links_to", + "docs/requirements.md|docs/independent-retrieval-channels-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-local-competition-experiment.md|links_to", + "docs/requirements.md|docs/node-first-blind-selection-experiment.md|links_to", + "docs/requirements.md|docs/optional-mcp-interface.md|links_to", + "docs/requirements.md|docs/real-corpus-benchmark.md|links_to", + "docs/requirements.md|docs/sibling-normalization-controlled-evaluation.md|links_to", + "docs/requirements.md|docs/sibling-relation-feedback-normalization.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_3", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.01700254504927287, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [ + "docs/requirements.md|docs/anchored-bm25-graph-hybrid-experiment.md|links_to", + "docs/requirements.md|docs/anchored-fusion-calibration-experiment.md|links_to", + "docs/requirements.md|docs/blind-llm-channel-selection-experiment.md|links_to", + "docs/requirements.md|docs/d1-corpus-fixture.md|links_to", + "docs/requirements.md|docs/engine-backed-feedback-trajectory-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-reproduction-experiment.md|links_to", + "docs/requirements.md|docs/independent-retrieval-channels-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-local-competition-experiment.md|links_to", + "docs/requirements.md|docs/node-first-blind-selection-experiment.md|links_to", + "docs/requirements.md|docs/optional-mcp-interface.md|links_to", + "docs/requirements.md|docs/real-corpus-benchmark.md|links_to", + "docs/requirements.md|docs/sibling-normalization-controlled-evaluation.md|links_to", + "docs/requirements.md|docs/sibling-relation-feedback-normalization.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_3", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.01700254504927287, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [ + "docs/requirements.md|docs/anchored-bm25-graph-hybrid-experiment.md|links_to", + "docs/requirements.md|docs/anchored-fusion-calibration-experiment.md|links_to", + "docs/requirements.md|docs/blind-llm-channel-selection-experiment.md|links_to", + "docs/requirements.md|docs/d1-corpus-fixture.md|links_to", + "docs/requirements.md|docs/engine-backed-feedback-trajectory-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-reproduction-experiment.md|links_to", + "docs/requirements.md|docs/independent-retrieval-channels-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-local-competition-experiment.md|links_to", + "docs/requirements.md|docs/node-first-blind-selection-experiment.md|links_to", + "docs/requirements.md|docs/optional-mcp-interface.md|links_to", + "docs/requirements.md|docs/real-corpus-benchmark.md|links_to", + "docs/requirements.md|docs/sibling-normalization-controlled-evaluation.md|links_to", + "docs/requirements.md|docs/sibling-relation-feedback-normalization.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + } + ], + "receipts": [ + { + "iteration": 1, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": { + "channel": "relation", + "reinforced": [], + "normalized": [], + "evidence": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "count": 2, + "quorum": 3, + "activated": false + } + ] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 2, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": { + "channel": "relation", + "reinforced": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "old_weight": 0.5638763091453018, + "new_weight": 0.5838763091453019 + } + ], + "normalized": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "old_weight": 0.553741578432044, + "new_weight": 0.5523130070034725 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "old_weight": 0.5626442053538984, + "new_weight": 0.5612156339253269 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + } + ], + "evidence": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "count": 3, + "quorum": 3, + "activated": true + } + ] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 3, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": { + "channel": "relation", + "reinforced": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "old_weight": 0.5838763091453019, + "new_weight": 0.6038763091453019 + } + ], + "normalized": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.4971428571428571 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5523130070034725, + "new_weight": 0.5508844355749011 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.4971428571428571 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.4971428571428571 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.4971428571428571 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.4971428571428571 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.4971428571428571 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.4971428571428571 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.4971428571428571 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.4971428571428571 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.4971428571428571 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "old_weight": 0.5612156339253269, + "new_weight": 0.5597870624967555 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.4971428571428571 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.4971428571428571 + } + ], + "evidence": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "count": 4, + "quorum": 3, + "activated": true + } + ] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + } + ] + }, + { + "case_id": "dev-corrected-sibling-evaluation", + "case_role": "corrected", + "checkpoints": [ + { + "name": "baseline", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.2793399764804587, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/sibling-relation-feedback-normalization.md" + ], + "direct_rank": 1, + "reverse_rank": 5 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_1", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.3191248325764963, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/sibling-relation-feedback-normalization.md" + ], + "direct_rank": 1, + "reverse_rank": 5 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5689394832903669, + "reinforced_count": 1, + "evidence_count": 3, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [ + "docs/sibling-relation-feedback-normalization.md|docs/sibling-normalization-controlled-evaluation.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_1", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.3191248325764963, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/sibling-relation-feedback-normalization.md" + ], + "direct_rank": 1, + "reverse_rank": 5 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5689394832903669, + "reinforced_count": 1, + "evidence_count": 3, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [ + "docs/sibling-relation-feedback-normalization.md|docs/sibling-normalization-controlled-evaluation.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_2", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.36439518351661887, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/sibling-relation-feedback-normalization.md" + ], + "direct_rank": 1, + "reverse_rank": 5 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.6473842712934195, + "reinforced_count": 2, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [ + "docs/sibling-relation-feedback-normalization.md|docs/sibling-normalization-controlled-evaluation.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_2", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.36439518351661887, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/sibling-relation-feedback-normalization.md" + ], + "direct_rank": 1, + "reverse_rank": 5 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.6473842712934195, + "reinforced_count": 2, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [ + "docs/sibling-relation-feedback-normalization.md|docs/sibling-normalization-controlled-evaluation.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_3", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.41590736366111264, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/sibling-relation-feedback-normalization.md" + ], + "direct_rank": 1, + "reverse_rank": 5 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.7366449455999776, + "reinforced_count": 3, + "evidence_count": 5, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [ + "docs/sibling-relation-feedback-normalization.md|docs/sibling-normalization-controlled-evaluation.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_3", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.41590736366111264, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/sibling-relation-feedback-normalization.md" + ], + "direct_rank": 1, + "reverse_rank": 5 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.7366449455999776, + "reinforced_count": 3, + "evidence_count": 5, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [ + "docs/sibling-relation-feedback-normalization.md|docs/sibling-normalization-controlled-evaluation.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + } + ], + "receipts": [ + { + "iteration": 1, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/sibling-normalization-controlled-evaluation.md" + ], + "feedback": { + "channel": "relation", + "reinforced": [ + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.5689394832903669 + } + ], + "normalized": [], + "evidence": [ + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "count": 3, + "quorum": 3, + "activated": true + } + ] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "corrected", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 2, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/sibling-normalization-controlled-evaluation.md" + ], + "feedback": { + "channel": "relation", + "reinforced": [ + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "old_weight": 0.5689394832903669, + "new_weight": 0.6473842712934195 + } + ], + "normalized": [], + "evidence": [ + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "count": 4, + "quorum": 3, + "activated": true + } + ] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "corrected", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 3, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/sibling-normalization-controlled-evaluation.md" + ], + "feedback": { + "channel": "relation", + "reinforced": [ + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "old_weight": 0.6473842712934195, + "new_weight": 0.7366449455999776 + } + ], + "normalized": [], + "evidence": [ + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "count": 5, + "quorum": 3, + "activated": true + } + ] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "corrected", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + } + ] + }, + { + "case_id": "dev-lexical-mcp-control", + "case_role": "lexical", + "checkpoints": [ + { + "name": "baseline", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.0039925831834931175, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.7366449455999776, + "reinforced_count": 3, + "evidence_count": 5, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_1", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.0039925831834931175, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.7366449455999776, + "reinforced_count": 3, + "evidence_count": 5, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_1", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.0039925831834931175, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.7366449455999776, + "reinforced_count": 3, + "evidence_count": 5, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_2", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.0039925831834931175, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.7366449455999776, + "reinforced_count": 3, + "evidence_count": 5, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_2", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.0039925831834931175, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.7366449455999776, + "reinforced_count": 3, + "evidence_count": 5, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_3", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.0039925831834931175, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.7366449455999776, + "reinforced_count": 3, + "evidence_count": 5, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_3", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.0039925831834931175, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.7366449455999776, + "reinforced_count": 3, + "evidence_count": 5, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + } + ], + "receipts": [ + { + "iteration": 1, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": { + "channel": "lexical", + "reinforced": [], + "normalized": [], + "evidence": [] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 2, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": { + "channel": "lexical", + "reinforced": [], + "normalized": [], + "evidence": [] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 3, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": { + "channel": "lexical", + "reinforced": [], + "normalized": [], + "evidence": [] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + } + ] + }, + { + "case_id": "dev-zero-hop-requirements-control", + "case_role": "zero_hop", + "checkpoints": [ + { + "name": "baseline", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.7366449455999776, + "reinforced_count": 3, + "evidence_count": 5, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_1", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.7366449455999776, + "reinforced_count": 3, + "evidence_count": 5, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_1", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.7366449455999776, + "reinforced_count": 3, + "evidence_count": 5, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_2", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.7366449455999776, + "reinforced_count": 3, + "evidence_count": 5, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_2", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.7366449455999776, + "reinforced_count": 3, + "evidence_count": 5, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_3", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.7366449455999776, + "reinforced_count": 3, + "evidence_count": 5, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_3", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.7366449455999776, + "reinforced_count": 3, + "evidence_count": 5, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + } + ], + "receipts": [ + { + "iteration": 1, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/requirements.md" + ], + "feedback": { + "channel": "lexical", + "reinforced": [], + "normalized": [], + "evidence": [] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 2, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/requirements.md" + ], + "feedback": { + "channel": "lexical", + "reinforced": [], + "normalized": [], + "evidence": [] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 3, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/requirements.md" + ], + "feedback": { + "channel": "lexical", + "reinforced": [], + "normalized": [], + "evidence": [] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + } + ] + } + ], + "final_edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5508844355749011, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.6038763091453019, + "reinforced_count": 3, + "evidence_count": 4, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5597870624967555, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4971428571428571, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.7366449455999776, + "reinforced_count": 3, + "evidence_count": 5, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "semantic_sha256": "2c5ffde04027ceaf9a5c5a41b4d94b5f5a1f9a32c2f27aeed4719d7f9754929e", + "fresh_clone_replay": true + }, + { + "arm_id": "confirmed_r05_s1", + "policy": "confirmed-only-decay-0.5-sibling-1.0", + "effective_config_provenance": { + "effective_config": { + "retrieval": { + "activation_budget": 1.0, + "activation_half_life_seconds": 3600.0, + "activation_strategy": "current_positive_additive", + "convergence_tolerance": 1e-09, + "dense_weight": 0.45, + "entry_weight": 0.55, + "final_fusion_strategy": "linear", + "graph_normalization": "max", + "graph_weight": 0.45, + "hop_decay": 0.7, + "inhibition_ratio": 0.0, + "inhibition_top_k": 0, + "max_active_paths_per_node": 4, + "max_hops": 2, + "max_paths_per_node": 4, + "max_propagation_expansions": 10000, + "maximum_activation": 10.0, + "query_transmission_floor": 0.4, + "query_transmission_power": 1.0, + "recurrent_decay": 0.5, + "recurrent_steps": 3, + "rrf_k": 60, + "seed_count": 3, + "sparse_weight": 0.55, + "use_dense_retrieval": true, + "use_graph_propagation": true + }, + "feedback": { + "confirmation_decay_ratio": 0.5, + "confirmed_outcome_reinforcement": true, + "feedback_learning_rate": 0.2, + "maximum_edge_weight": 2.0, + "relation_feedback_evidence_quorum": 1, + "sibling_feedback_normalization": 1.0 + } + }, + "retrieval_config_fingerprint": "sha256:bfc95085fdc8870ecd1ef119edbad55869697f4265ed7a3f71431405709252b8", + "feedback_config_fingerprint": "sha256:4c21548f02728b0cbbc9d4c59f312f268c12170c5020139744a9d4882045a1e4", + "full_config_fingerprint": "sha256:25f5ece8bc4eab6f2a829a62279f4279a01947aefc4fc423c633644522e63a5f" + }, + "initial_edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "cases": [ + { + "case_id": "dev-confirmed-requirements-to-mcp", + "case_role": "confirmed", + "checkpoints": [ + { + "name": "baseline", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.02016371927147785, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_1", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.02016371927147785, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_1", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.018583132160375347, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5523130070034725, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5838763091453019, + "reinforced_count": 2, + "evidence_count": 1, + "confirmation_count": 1, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5612156339253269, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [ + "docs/requirements.md|docs/anchored-bm25-graph-hybrid-experiment.md|links_to", + "docs/requirements.md|docs/anchored-fusion-calibration-experiment.md|links_to", + "docs/requirements.md|docs/blind-llm-channel-selection-experiment.md|links_to", + "docs/requirements.md|docs/d1-corpus-fixture.md|links_to", + "docs/requirements.md|docs/engine-backed-feedback-trajectory-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-reproduction-experiment.md|links_to", + "docs/requirements.md|docs/independent-retrieval-channels-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-local-competition-experiment.md|links_to", + "docs/requirements.md|docs/node-first-blind-selection-experiment.md|links_to", + "docs/requirements.md|docs/optional-mcp-interface.md|links_to", + "docs/requirements.md|docs/real-corpus-benchmark.md|links_to", + "docs/requirements.md|docs/sibling-normalization-controlled-evaluation.md|links_to", + "docs/requirements.md|docs/sibling-relation-feedback-normalization.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_2", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.018583132160375347, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5523130070034725, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5838763091453019, + "reinforced_count": 2, + "evidence_count": 1, + "confirmation_count": 1, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5612156339253269, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.49857142857142855, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [ + "docs/requirements.md|docs/anchored-bm25-graph-hybrid-experiment.md|links_to", + "docs/requirements.md|docs/anchored-fusion-calibration-experiment.md|links_to", + "docs/requirements.md|docs/blind-llm-channel-selection-experiment.md|links_to", + "docs/requirements.md|docs/d1-corpus-fixture.md|links_to", + "docs/requirements.md|docs/engine-backed-feedback-trajectory-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-reproduction-experiment.md|links_to", + "docs/requirements.md|docs/independent-retrieval-channels-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-local-competition-experiment.md|links_to", + "docs/requirements.md|docs/node-first-blind-selection-experiment.md|links_to", + "docs/requirements.md|docs/optional-mcp-interface.md|links_to", + "docs/requirements.md|docs/real-corpus-benchmark.md|links_to", + "docs/requirements.md|docs/sibling-normalization-controlled-evaluation.md|links_to", + "docs/requirements.md|docs/sibling-relation-feedback-normalization.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_2", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.017792838604824113, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5938763091453019, + "reinforced_count": 3, + "evidence_count": 1, + "confirmation_count": 2, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [ + "docs/requirements.md|docs/anchored-bm25-graph-hybrid-experiment.md|links_to", + "docs/requirements.md|docs/anchored-fusion-calibration-experiment.md|links_to", + "docs/requirements.md|docs/blind-llm-channel-selection-experiment.md|links_to", + "docs/requirements.md|docs/d1-corpus-fixture.md|links_to", + "docs/requirements.md|docs/engine-backed-feedback-trajectory-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-reproduction-experiment.md|links_to", + "docs/requirements.md|docs/independent-retrieval-channels-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-local-competition-experiment.md|links_to", + "docs/requirements.md|docs/node-first-blind-selection-experiment.md|links_to", + "docs/requirements.md|docs/optional-mcp-interface.md|links_to", + "docs/requirements.md|docs/real-corpus-benchmark.md|links_to", + "docs/requirements.md|docs/sibling-normalization-controlled-evaluation.md|links_to", + "docs/requirements.md|docs/sibling-relation-feedback-normalization.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_3", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.017792838604824113, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5938763091453019, + "reinforced_count": 3, + "evidence_count": 1, + "confirmation_count": 2, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.49785714285714283, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [ + "docs/requirements.md|docs/anchored-bm25-graph-hybrid-experiment.md|links_to", + "docs/requirements.md|docs/anchored-fusion-calibration-experiment.md|links_to", + "docs/requirements.md|docs/blind-llm-channel-selection-experiment.md|links_to", + "docs/requirements.md|docs/d1-corpus-fixture.md|links_to", + "docs/requirements.md|docs/engine-backed-feedback-trajectory-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-reproduction-experiment.md|links_to", + "docs/requirements.md|docs/independent-retrieval-channels-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-local-competition-experiment.md|links_to", + "docs/requirements.md|docs/node-first-blind-selection-experiment.md|links_to", + "docs/requirements.md|docs/optional-mcp-interface.md|links_to", + "docs/requirements.md|docs/real-corpus-benchmark.md|links_to", + "docs/requirements.md|docs/sibling-normalization-controlled-evaluation.md|links_to", + "docs/requirements.md|docs/sibling-relation-feedback-normalization.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_3", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.017397691827048513, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.551241578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5601442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [ + "docs/requirements.md|docs/anchored-bm25-graph-hybrid-experiment.md|links_to", + "docs/requirements.md|docs/anchored-fusion-calibration-experiment.md|links_to", + "docs/requirements.md|docs/blind-llm-channel-selection-experiment.md|links_to", + "docs/requirements.md|docs/d1-corpus-fixture.md|links_to", + "docs/requirements.md|docs/engine-backed-feedback-trajectory-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-reproduction-experiment.md|links_to", + "docs/requirements.md|docs/independent-retrieval-channels-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-local-competition-experiment.md|links_to", + "docs/requirements.md|docs/node-first-blind-selection-experiment.md|links_to", + "docs/requirements.md|docs/optional-mcp-interface.md|links_to", + "docs/requirements.md|docs/real-corpus-benchmark.md|links_to", + "docs/requirements.md|docs/sibling-normalization-controlled-evaluation.md|links_to", + "docs/requirements.md|docs/sibling-relation-feedback-normalization.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + } + ], + "receipts": [ + { + "iteration": 1, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": true, + "confirmations": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "confirmation_count": 1, + "multiplier": 1.0, + "actual_delta": 0.020000000000000018, + "old_weight": 0.5638763091453018, + "new_weight": 0.5838763091453019 + } + ], + "credited_paths": [ + { + "node_id": "docs/optional-mcp-interface.md", + "steps": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "edge_weight": 0.5638763091453018, + "factuality": 1.0 + } + ] + } + ], + "normalized": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "old_weight": 0.553741578432044, + "new_weight": 0.5523130070034725 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "old_weight": 0.5626442053538984, + "new_weight": 0.5612156339253269 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49857142857142855 + } + ], + "idempotency_replay_equal": true + } + }, + { + "iteration": 2, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": true, + "confirmations": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "confirmation_count": 2, + "multiplier": 0.5, + "actual_delta": 0.010000000000000009, + "old_weight": 0.5838763091453019, + "new_weight": 0.5938763091453019 + } + ], + "credited_paths": [ + { + "node_id": "docs/optional-mcp-interface.md", + "steps": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "edge_weight": 0.5838763091453019, + "factuality": 1.0 + } + ] + } + ], + "normalized": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.49785714285714283 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5523130070034725, + "new_weight": 0.5515987212891869 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.49785714285714283 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.49785714285714283 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.49785714285714283 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.49785714285714283 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.49785714285714283 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.49785714285714283 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.49785714285714283 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.49785714285714283 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.49785714285714283 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "old_weight": 0.5612156339253269, + "new_weight": 0.5605013482110413 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.49785714285714283 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "old_weight": 0.49857142857142855, + "new_weight": 0.49785714285714283 + } + ], + "idempotency_replay_equal": true + } + }, + { + "iteration": 3, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": true, + "confirmations": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "confirmation_count": 3, + "multiplier": 0.25, + "actual_delta": 0.0050000000000000044, + "old_weight": 0.5938763091453019, + "new_weight": 0.5988763091453019 + } + ], + "credited_paths": [ + { + "node_id": "docs/optional-mcp-interface.md", + "steps": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "edge_weight": 0.5938763091453019, + "factuality": 1.0 + } + ] + } + ], + "normalized": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49785714285714283, + "new_weight": 0.4975 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5515987212891869, + "new_weight": 0.551241578432044 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49785714285714283, + "new_weight": 0.4975 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "old_weight": 0.49785714285714283, + "new_weight": 0.4975 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49785714285714283, + "new_weight": 0.4975 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49785714285714283, + "new_weight": 0.4975 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49785714285714283, + "new_weight": 0.4975 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49785714285714283, + "new_weight": 0.4975 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49785714285714283, + "new_weight": 0.4975 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49785714285714283, + "new_weight": 0.4975 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49785714285714283, + "new_weight": 0.4975 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "old_weight": 0.5605013482110413, + "new_weight": 0.5601442053538984 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "old_weight": 0.49785714285714283, + "new_weight": 0.4975 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "old_weight": 0.49785714285714283, + "new_weight": 0.4975 + } + ], + "idempotency_replay_equal": true + } + } + ] + }, + { + "case_id": "dev-corrected-sibling-evaluation", + "case_role": "corrected", + "checkpoints": [ + { + "name": "baseline", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.27982377090784827, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 1, + "reverse_rank": 15 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.551241578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5601442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_1", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.27982377090784827, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 1, + "reverse_rank": 15 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.551241578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5601442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_1", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.27982377090784827, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 1, + "reverse_rank": 15 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.551241578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5601442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_2", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.27982377090784827, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 1, + "reverse_rank": 15 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.551241578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5601442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_2", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.27982377090784827, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 1, + "reverse_rank": 15 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.551241578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5601442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_3", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.27982377090784827, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 1, + "reverse_rank": 15 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.551241578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5601442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_3", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.27982377090784827, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 1, + "reverse_rank": 15 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.551241578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5601442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + } + ], + "receipts": [ + { + "iteration": 1, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/sibling-normalization-controlled-evaluation.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "corrected", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 2, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/sibling-normalization-controlled-evaluation.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "corrected", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 3, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/sibling-normalization-controlled-evaluation.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "corrected", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + } + ] + }, + { + "case_id": "dev-lexical-mcp-control", + "case_role": "lexical", + "checkpoints": [ + { + "name": "baseline", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.003507457214943513, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.551241578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5601442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_1", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.003507457214943513, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.551241578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5601442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_1", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.003507457214943513, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.551241578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5601442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_2", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.003507457214943513, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.551241578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5601442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_2", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.003507457214943513, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.551241578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5601442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_3", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.003507457214943513, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.551241578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5601442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_3", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.003507457214943513, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.551241578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5601442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + } + ], + "receipts": [ + { + "iteration": 1, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 2, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 3, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + } + ] + }, + { + "case_id": "dev-zero-hop-requirements-control", + "case_role": "zero_hop", + "checkpoints": [ + { + "name": "baseline", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.551241578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5601442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_1", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.551241578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5601442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_1", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.551241578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5601442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_2", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.551241578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5601442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_2", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.551241578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5601442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_3", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.551241578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5601442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_3", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.551241578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5601442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + } + ], + "receipts": [ + { + "iteration": 1, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/requirements.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 2, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/requirements.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 3, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/requirements.md" + ], + "feedback": null, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + } + ] + } + ], + "final_edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.551241578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5601442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4975, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "semantic_sha256": "a8a9201b5880eacc73024bef4814bcaf12f2de13175fdbc4d767ee5b3ab3ac7a", + "fresh_clone_replay": true + }, + { + "arm_id": "soft_start_r025_r05_s1", + "policy": "soft-start-0.25-decay-0.5-sibling-1.0", + "effective_config_provenance": { + "effective_config": { + "retrieval": { + "activation_budget": 1.0, + "activation_half_life_seconds": 3600.0, + "activation_strategy": "current_positive_additive", + "convergence_tolerance": 1e-09, + "dense_weight": 0.45, + "entry_weight": 0.55, + "final_fusion_strategy": "linear", + "graph_normalization": "max", + "graph_weight": 0.45, + "hop_decay": 0.7, + "inhibition_ratio": 0.0, + "inhibition_top_k": 0, + "max_active_paths_per_node": 4, + "max_hops": 2, + "max_paths_per_node": 4, + "max_propagation_expansions": 10000, + "maximum_activation": 10.0, + "query_transmission_floor": 0.4, + "query_transmission_power": 1.0, + "recurrent_decay": 0.5, + "recurrent_steps": 3, + "rrf_k": 60, + "seed_count": 3, + "sparse_weight": 0.55, + "use_dense_retrieval": true, + "use_graph_propagation": true + }, + "feedback": { + "confirmation_decay_ratio": 0.5, + "confirmed_outcome_reinforcement": false, + "feedback_learning_rate": 0.2, + "maximum_edge_weight": 2.0, + "relation_feedback_evidence_quorum": 1, + "sibling_feedback_normalization": 1.0, + "soft_start_feedback_ratio": 0.25, + "soft_start_feedback_reinforcement": true + } + }, + "retrieval_config_fingerprint": "sha256:bfc95085fdc8870ecd1ef119edbad55869697f4265ed7a3f71431405709252b8", + "feedback_config_fingerprint": "sha256:d4d4a757f109c173a57ca921467b1ddcf57a6a672267579050df973566eae502", + "full_config_fingerprint": "sha256:20fcda84d32b6f70720785529a8fbfcceb4998abe1913bdb0074e46bee5d849c" + }, + "initial_edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "cases": [ + { + "case_id": "dev-confirmed-requirements-to-mcp", + "case_role": "confirmed", + "checkpoints": [ + { + "name": "baseline", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.02016371927147785, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5638763091453018, + "reinforced_count": 1, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_1", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.019798469898499184, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.553741578432044, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5688763091453019, + "reinforced_count": 2, + "evidence_count": 1, + "confirmation_count": 0, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5626442053538984, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [ + "docs/requirements.md|docs/optional-mcp-interface.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_1", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.018613800807791667, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5526701498606154, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5838763091453019, + "reinforced_count": 3, + "evidence_count": 1, + "confirmation_count": 1, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5615727767824698, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [ + "docs/requirements.md|docs/anchored-bm25-graph-hybrid-experiment.md|links_to", + "docs/requirements.md|docs/anchored-fusion-calibration-experiment.md|links_to", + "docs/requirements.md|docs/blind-llm-channel-selection-experiment.md|links_to", + "docs/requirements.md|docs/d1-corpus-fixture.md|links_to", + "docs/requirements.md|docs/engine-backed-feedback-trajectory-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-reproduction-experiment.md|links_to", + "docs/requirements.md|docs/independent-retrieval-channels-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-local-competition-experiment.md|links_to", + "docs/requirements.md|docs/node-first-blind-selection-experiment.md|links_to", + "docs/requirements.md|docs/optional-mcp-interface.md|links_to", + "docs/requirements.md|docs/real-corpus-benchmark.md|links_to", + "docs/requirements.md|docs/sibling-normalization-controlled-evaluation.md|links_to", + "docs/requirements.md|docs/sibling-relation-feedback-normalization.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_2", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.018613800807791667, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5526701498606154, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5838763091453019, + "reinforced_count": 3, + "evidence_count": 1, + "confirmation_count": 1, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5615727767824698, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.49892857142857144, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [ + "docs/requirements.md|docs/anchored-bm25-graph-hybrid-experiment.md|links_to", + "docs/requirements.md|docs/anchored-fusion-calibration-experiment.md|links_to", + "docs/requirements.md|docs/blind-llm-channel-selection-experiment.md|links_to", + "docs/requirements.md|docs/d1-corpus-fixture.md|links_to", + "docs/requirements.md|docs/engine-backed-feedback-trajectory-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-reproduction-experiment.md|links_to", + "docs/requirements.md|docs/independent-retrieval-channels-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-local-competition-experiment.md|links_to", + "docs/requirements.md|docs/node-first-blind-selection-experiment.md|links_to", + "docs/requirements.md|docs/optional-mcp-interface.md|links_to", + "docs/requirements.md|docs/real-corpus-benchmark.md|links_to", + "docs/requirements.md|docs/sibling-normalization-controlled-evaluation.md|links_to", + "docs/requirements.md|docs/sibling-relation-feedback-normalization.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_2", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.017824021413986618, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5519558641463297, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5938763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 2, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5608584910681841, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [ + "docs/requirements.md|docs/anchored-bm25-graph-hybrid-experiment.md|links_to", + "docs/requirements.md|docs/anchored-fusion-calibration-experiment.md|links_to", + "docs/requirements.md|docs/blind-llm-channel-selection-experiment.md|links_to", + "docs/requirements.md|docs/d1-corpus-fixture.md|links_to", + "docs/requirements.md|docs/engine-backed-feedback-trajectory-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-reproduction-experiment.md|links_to", + "docs/requirements.md|docs/independent-retrieval-channels-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-local-competition-experiment.md|links_to", + "docs/requirements.md|docs/node-first-blind-selection-experiment.md|links_to", + "docs/requirements.md|docs/optional-mcp-interface.md|links_to", + "docs/requirements.md|docs/real-corpus-benchmark.md|links_to", + "docs/requirements.md|docs/sibling-normalization-controlled-evaluation.md|links_to", + "docs/requirements.md|docs/sibling-relation-feedback-normalization.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_3", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.017824021413986618, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5519558641463297, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5938763091453019, + "reinforced_count": 4, + "evidence_count": 1, + "confirmation_count": 2, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5608584910681841, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4982142857142857, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [ + "docs/requirements.md|docs/anchored-bm25-graph-hybrid-experiment.md|links_to", + "docs/requirements.md|docs/anchored-fusion-calibration-experiment.md|links_to", + "docs/requirements.md|docs/blind-llm-channel-selection-experiment.md|links_to", + "docs/requirements.md|docs/d1-corpus-fixture.md|links_to", + "docs/requirements.md|docs/engine-backed-feedback-trajectory-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-reproduction-experiment.md|links_to", + "docs/requirements.md|docs/independent-retrieval-channels-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-local-competition-experiment.md|links_to", + "docs/requirements.md|docs/node-first-blind-selection-experiment.md|links_to", + "docs/requirements.md|docs/optional-mcp-interface.md|links_to", + "docs/requirements.md|docs/real-corpus-benchmark.md|links_to", + "docs/requirements.md|docs/sibling-normalization-controlled-evaluation.md|links_to", + "docs/requirements.md|docs/sibling-relation-feedback-normalization.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_3", + "metrics": { + "target_rank": 2, + "target_mrr": 0.5, + "target_hit_at_k": true, + "score_margin": -0.017429131717084087, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 5, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [ + "docs/requirements.md|docs/anchored-bm25-graph-hybrid-experiment.md|links_to", + "docs/requirements.md|docs/anchored-fusion-calibration-experiment.md|links_to", + "docs/requirements.md|docs/blind-llm-channel-selection-experiment.md|links_to", + "docs/requirements.md|docs/d1-corpus-fixture.md|links_to", + "docs/requirements.md|docs/engine-backed-feedback-trajectory-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-reproduction-experiment.md|links_to", + "docs/requirements.md|docs/independent-retrieval-channels-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-local-competition-experiment.md|links_to", + "docs/requirements.md|docs/node-first-blind-selection-experiment.md|links_to", + "docs/requirements.md|docs/optional-mcp-interface.md|links_to", + "docs/requirements.md|docs/real-corpus-benchmark.md|links_to", + "docs/requirements.md|docs/sibling-normalization-controlled-evaluation.md|links_to", + "docs/requirements.md|docs/sibling-relation-feedback-normalization.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + } + ], + "receipts": [ + { + "iteration": 1, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": { + "channel": "relation", + "reinforced": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "old_weight": 0.5638763091453018, + "new_weight": 0.5688763091453019 + } + ], + "normalized": [], + "evidence": [] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": true, + "confirmations": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "confirmation_count": 1, + "multiplier": 0.75, + "actual_delta": 0.015000000000000013, + "old_weight": 0.5688763091453019, + "new_weight": 0.5838763091453019 + } + ], + "credited_paths": [ + { + "node_id": "docs/optional-mcp-interface.md", + "steps": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "edge_weight": 0.5638763091453018, + "factuality": 1.0 + } + ] + } + ], + "normalized": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49892857142857144 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "old_weight": 0.553741578432044, + "new_weight": 0.5526701498606154 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49892857142857144 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49892857142857144 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49892857142857144 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49892857142857144 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49892857142857144 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49892857142857144 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49892857142857144 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49892857142857144 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49892857142857144 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "old_weight": 0.5626442053538984, + "new_weight": 0.5615727767824698 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49892857142857144 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.49892857142857144 + } + ], + "idempotency_replay_equal": true + } + }, + { + "iteration": 2, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": { + "channel": "relation", + "reinforced": [], + "normalized": [], + "evidence": [] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": true, + "confirmations": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "confirmation_count": 2, + "multiplier": 0.5, + "actual_delta": 0.010000000000000009, + "old_weight": 0.5838763091453019, + "new_weight": 0.5938763091453019 + } + ], + "credited_paths": [ + { + "node_id": "docs/optional-mcp-interface.md", + "steps": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "edge_weight": 0.5838763091453019, + "factuality": 1.0 + } + ] + } + ], + "normalized": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49892857142857144, + "new_weight": 0.4982142857142857 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5526701498606154, + "new_weight": 0.5519558641463297 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49892857142857144, + "new_weight": 0.4982142857142857 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "old_weight": 0.49892857142857144, + "new_weight": 0.4982142857142857 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49892857142857144, + "new_weight": 0.4982142857142857 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49892857142857144, + "new_weight": 0.4982142857142857 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49892857142857144, + "new_weight": 0.4982142857142857 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49892857142857144, + "new_weight": 0.4982142857142857 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49892857142857144, + "new_weight": 0.4982142857142857 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49892857142857144, + "new_weight": 0.4982142857142857 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "old_weight": 0.49892857142857144, + "new_weight": 0.4982142857142857 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "old_weight": 0.5615727767824698, + "new_weight": 0.5608584910681841 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "old_weight": 0.49892857142857144, + "new_weight": 0.4982142857142857 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "old_weight": 0.49892857142857144, + "new_weight": 0.4982142857142857 + } + ], + "idempotency_replay_equal": true + } + }, + { + "iteration": 3, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": { + "channel": "relation", + "reinforced": [], + "normalized": [], + "evidence": [] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": true, + "confirmations": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "confirmation_count": 3, + "multiplier": 0.25, + "actual_delta": 0.0050000000000000044, + "old_weight": 0.5938763091453019, + "new_weight": 0.5988763091453019 + } + ], + "credited_paths": [ + { + "node_id": "docs/optional-mcp-interface.md", + "steps": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "edge_weight": 0.5938763091453019, + "factuality": 1.0 + } + ] + } + ], + "normalized": [ + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "old_weight": 0.4982142857142857, + "new_weight": 0.4978571428571429 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "old_weight": 0.5519558641463297, + "new_weight": 0.5515987212891869 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "old_weight": 0.4982142857142857, + "new_weight": 0.4978571428571429 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "old_weight": 0.4982142857142857, + "new_weight": 0.4978571428571429 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "old_weight": 0.4982142857142857, + "new_weight": 0.4978571428571429 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "old_weight": 0.4982142857142857, + "new_weight": 0.4978571428571429 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "old_weight": 0.4982142857142857, + "new_weight": 0.4978571428571429 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "old_weight": 0.4982142857142857, + "new_weight": 0.4978571428571429 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "old_weight": 0.4982142857142857, + "new_weight": 0.4978571428571429 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "old_weight": 0.4982142857142857, + "new_weight": 0.4978571428571429 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "old_weight": 0.4982142857142857, + "new_weight": 0.4978571428571429 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "old_weight": 0.5608584910681841, + "new_weight": 0.5605013482110413 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "old_weight": 0.4982142857142857, + "new_weight": 0.4978571428571429 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "old_weight": 0.4982142857142857, + "new_weight": 0.4978571428571429 + } + ], + "idempotency_replay_equal": true + } + } + ] + }, + { + "case_id": "dev-corrected-sibling-evaluation", + "case_role": "corrected", + "checkpoints": [ + { + "name": "baseline", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.2798622640563502, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 1, + "reverse_rank": 15 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 5, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_1", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.2898092908079083, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 1, + "reverse_rank": 15 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 5, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5172348708225918, + "reinforced_count": 1, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": 0.06893948329036695, + "soft_start_ratio": 0.25 + } + ], + "changed_edges": [ + "docs/sibling-relation-feedback-normalization.md|docs/sibling-normalization-controlled-evaluation.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_1", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.2898092908079083, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 1, + "reverse_rank": 15 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 5, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5172348708225918, + "reinforced_count": 1, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": 0.06893948329036695, + "soft_start_ratio": 0.25 + } + ], + "changed_edges": [ + "docs/sibling-relation-feedback-normalization.md|docs/sibling-normalization-controlled-evaluation.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_2", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.2898092908079083, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 1, + "reverse_rank": 15 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 5, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5172348708225918, + "reinforced_count": 1, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": 0.06893948329036695, + "soft_start_ratio": 0.25 + } + ], + "changed_edges": [ + "docs/sibling-relation-feedback-normalization.md|docs/sibling-normalization-controlled-evaluation.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_2", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.2898092908079083, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 1, + "reverse_rank": 15 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 5, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5172348708225918, + "reinforced_count": 1, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": 0.06893948329036695, + "soft_start_ratio": 0.25 + } + ], + "changed_edges": [ + "docs/sibling-relation-feedback-normalization.md|docs/sibling-normalization-controlled-evaluation.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_3", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.2898092908079083, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 1, + "reverse_rank": 15 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 5, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5172348708225918, + "reinforced_count": 1, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": 0.06893948329036695, + "soft_start_ratio": 0.25 + } + ], + "changed_edges": [ + "docs/sibling-relation-feedback-normalization.md|docs/sibling-normalization-controlled-evaluation.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_3", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.2898092908079083, + "top_k": [ + "docs/sibling-normalization-controlled-evaluation.md", + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md" + ], + "direct_rank": 1, + "reverse_rank": 15 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 5, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5172348708225918, + "reinforced_count": 1, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": 0.06893948329036695, + "soft_start_ratio": 0.25 + } + ], + "changed_edges": [ + "docs/sibling-relation-feedback-normalization.md|docs/sibling-normalization-controlled-evaluation.md|links_to" + ], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + } + ], + "receipts": [ + { + "iteration": 1, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/sibling-normalization-controlled-evaluation.md" + ], + "feedback": { + "channel": "relation", + "reinforced": [ + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "old_weight": 0.5, + "new_weight": 0.5172348708225918 + } + ], + "normalized": [], + "evidence": [] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "corrected", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 2, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/sibling-normalization-controlled-evaluation.md" + ], + "feedback": { + "channel": "relation", + "reinforced": [], + "normalized": [], + "evidence": [] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "corrected", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 3, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/sibling-normalization-controlled-evaluation.md" + ], + "feedback": { + "channel": "relation", + "reinforced": [], + "normalized": [], + "evidence": [] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "corrected", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + } + ] + }, + { + "case_id": "dev-lexical-mcp-control", + "case_role": "lexical", + "checkpoints": [ + { + "name": "baseline", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.0034728545878247863, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 5, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5172348708225918, + "reinforced_count": 1, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": 0.06893948329036695, + "soft_start_ratio": 0.25 + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_1", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.0034728545878247863, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 5, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5172348708225918, + "reinforced_count": 1, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": 0.06893948329036695, + "soft_start_ratio": 0.25 + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_1", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.0034728545878247863, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 5, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5172348708225918, + "reinforced_count": 1, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": 0.06893948329036695, + "soft_start_ratio": 0.25 + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_2", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.0034728545878247863, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 5, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5172348708225918, + "reinforced_count": 1, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": 0.06893948329036695, + "soft_start_ratio": 0.25 + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_2", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.0034728545878247863, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 5, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5172348708225918, + "reinforced_count": 1, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": 0.06893948329036695, + "soft_start_ratio": 0.25 + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_3", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.0034728545878247863, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 5, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5172348708225918, + "reinforced_count": 1, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": 0.06893948329036695, + "soft_start_ratio": 0.25 + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_3", + "metrics": { + "target_rank": 1, + "target_mrr": 1.0, + "target_hit_at_k": true, + "score_margin": 0.0034728545878247863, + "top_k": [ + "docs/optional-mcp-interface.md", + "docs/real-corpus-benchmark.md", + "docs/anchored-fusion-calibration-experiment.md", + "docs/anchored-bm25-graph-hybrid-experiment.md", + "docs/blind-llm-channel-selection-experiment.md" + ], + "direct_rank": 4, + "reverse_rank": 1 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 5, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5172348708225918, + "reinforced_count": 1, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": 0.06893948329036695, + "soft_start_ratio": 0.25 + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + } + ], + "receipts": [ + { + "iteration": 1, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": { + "channel": "lexical", + "reinforced": [], + "normalized": [], + "evidence": [] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 2, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": { + "channel": "lexical", + "reinforced": [], + "normalized": [], + "evidence": [] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 3, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/optional-mcp-interface.md" + ], + "feedback": { + "channel": "lexical", + "reinforced": [], + "normalized": [], + "evidence": [] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + } + ] + }, + { + "case_id": "dev-zero-hop-requirements-control", + "case_role": "zero_hop", + "checkpoints": [ + { + "name": "baseline", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 5, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5172348708225918, + "reinforced_count": 1, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": 0.06893948329036695, + "soft_start_ratio": 0.25 + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_1", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 5, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5172348708225918, + "reinforced_count": 1, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": 0.06893948329036695, + "soft_start_ratio": 0.25 + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_1", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 5, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5172348708225918, + "reinforced_count": 1, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": 0.06893948329036695, + "soft_start_ratio": 0.25 + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_2", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 5, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5172348708225918, + "reinforced_count": 1, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": 0.06893948329036695, + "soft_start_ratio": 0.25 + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_2", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 5, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5172348708225918, + "reinforced_count": 1, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": 0.06893948329036695, + "soft_start_ratio": 0.25 + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "used_3", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 5, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5172348708225918, + "reinforced_count": 1, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": 0.06893948329036695, + "soft_start_ratio": 0.25 + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + }, + { + "name": "outcome_3", + "metrics": { + "target_rank": 22, + "target_mrr": 0.045454545454545456, + "target_hit_at_k": false, + "score_margin": 0.0, + "top_k": [], + "direct_rank": 5, + "reverse_rank": 22 + }, + "edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 5, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5172348708225918, + "reinforced_count": 1, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": 0.06893948329036695, + "soft_start_ratio": 0.25 + } + ], + "changed_edges": [], + "top_k_entry": [], + "top_k_exit": [], + "non_target_churn": 0 + } + ], + "receipts": [ + { + "iteration": 1, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/requirements.md" + ], + "feedback": { + "channel": "lexical", + "reinforced": [], + "normalized": [], + "evidence": [] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 2, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/requirements.md" + ], + "feedback": { + "channel": "lexical", + "reinforced": [], + "normalized": [], + "evidence": [] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + }, + { + "iteration": 3, + "source_use": { + "stages": [ + "selected", + "validated", + "used" + ], + "changed": [ + true, + true, + true + ], + "newly_used_node_ids": [ + "docs/requirements.md" + ], + "feedback": { + "channel": "lexical", + "reinforced": [], + "normalized": [], + "evidence": [] + }, + "idempotency_replay_equal": true + }, + "outcome": { + "outcome": "confirmed", + "reinforcement_applied": false, + "confirmations": [], + "credited_paths": [], + "normalized": [], + "idempotency_replay_equal": true + } + } + ] + } + ], + "final_edges": [ + { + "source_id": "README.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/github-rag-mcp-replacement-compatibility.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "README.md", + "target_id": "docs/requirements.md", + "edge_type": "links_to", + "weight": 0.5, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-bm25-graph-hybrid-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/anchored-fusion-calibration-experiment.md", + "edge_type": "links_to", + "weight": 0.5515987212891869, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/blind-llm-channel-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/d1-corpus-fixture.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/engine-backed-feedback-trajectory-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/independent-retrieval-channels-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/neural-dynamics-local-competition-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/node-first-blind-selection-experiment.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to", + "weight": 0.5988763091453019, + "reinforced_count": 5, + "evidence_count": 1, + "confirmation_count": 3, + "base_increment": 0.020000000000000004, + "soft_start_ratio": 0.25 + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/real-corpus-benchmark.md", + "edge_type": "links_to", + "weight": 0.5605013482110413, + "reinforced_count": 1, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/requirements.md", + "target_id": "docs/sibling-relation-feedback-normalization.md", + "edge_type": "links_to", + "weight": 0.4978571428571429, + "reinforced_count": 0, + "evidence_count": 0, + "confirmation_count": 0, + "base_increment": null, + "soft_start_ratio": null + }, + { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to", + "weight": 0.5172348708225918, + "reinforced_count": 1, + "evidence_count": 2, + "confirmation_count": 0, + "base_increment": 0.06893948329036695, + "soft_start_ratio": 0.25 + } + ], + "semantic_sha256": "803c10c5034a39ea4284b2e5069861579deebaddeecbe4255da5df0c27903263", + "fresh_clone_replay": true + } + ], + "gates": [ + { + "gate_id": "protocol-integrity", + "passed": true + }, + { + "gate_id": "soft-start-schedule", + "passed": true + }, + { + "gate_id": "policy-boundaries", + "passed": false + }, + { + "gate_id": "learning-latency-and-quality", + "passed": true + }, + { + "gate_id": "negative-provisional-bound", + "passed": true + }, + { + "gate_id": "control-rank-and-mutation-safety", + "passed": true + }, + { + "gate_id": "mutation-locality-and-source-isolation", + "passed": true + } + ], + "all_hard_gates_pass": false, + "interpretation_ja": { + "decision": "不支持", + "summary": "固定したlocal snapshotとhard gateの範囲でsoft-startの比較優位は成立しなかった。", + "scope": "local snapshot限定。external corpus、production quality、library defaultへ一般化せず、source databaseとlive configを変更しない。" + } +} diff --git a/tests/fixtures/soft_start_snapshot_v1.fixture.json b/tests/fixtures/soft_start_snapshot_v1.fixture.json new file mode 100644 index 0000000..52951b3 --- /dev/null +++ b/tests/fixtures/soft_start_snapshot_v1.fixture.json @@ -0,0 +1,210 @@ +{ + "protocol_id": "soft-start-snapshot-v1", + "selection_rule": "Public node and edge identifiers already present in the one-time local snapshot; fixed before any registered result; development and holdout are not changed after observation.", + "stages": { + "development": [ + { + "case_id": "dev-confirmed-requirements-to-mcp", + "case_role": "confirmed", + "query": "requirements specification feedback interface", + "search_surface": "relation", + "used_node_id": "docs/optional-mcp-interface.md", + "source_node_id": "docs/requirements.md", + "credited_edge": { + "source_id": "docs/requirements.md", + "target_id": "docs/optional-mcp-interface.md", + "edge_type": "links_to" + }, + "outcome": "confirmed", + "direct_query": "optional MCP interface", + "direct_node_id": "docs/optional-mcp-interface.md", + "reverse_query": "requirements specification", + "reverse_node_id": "docs/requirements.md", + "retrieval_limit": 21, + "hit_k": 5, + "allowed_mutation_edges": [ + "docs/requirements.md|docs/anchored-bm25-graph-hybrid-experiment.md|links_to", + "docs/requirements.md|docs/anchored-fusion-calibration-experiment.md|links_to", + "docs/requirements.md|docs/blind-llm-channel-selection-experiment.md|links_to", + "docs/requirements.md|docs/d1-corpus-fixture.md|links_to", + "docs/requirements.md|docs/engine-backed-feedback-trajectory-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-experiment.md|links_to", + "docs/requirements.md|docs/feedback-adaptation-reproduction-experiment.md|links_to", + "docs/requirements.md|docs/independent-retrieval-channels-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-experiment.md|links_to", + "docs/requirements.md|docs/neural-dynamics-local-competition-experiment.md|links_to", + "docs/requirements.md|docs/node-first-blind-selection-experiment.md|links_to", + "docs/requirements.md|docs/optional-mcp-interface.md|links_to", + "docs/requirements.md|docs/real-corpus-benchmark.md|links_to", + "docs/requirements.md|docs/sibling-normalization-controlled-evaluation.md|links_to", + "docs/requirements.md|docs/sibling-relation-feedback-normalization.md|links_to" + ] + }, + { + "case_id": "dev-corrected-sibling-evaluation", + "case_role": "corrected", + "query": "sibling relation feedback normalization", + "search_surface": "relation", + "used_node_id": "docs/sibling-normalization-controlled-evaluation.md", + "source_node_id": "docs/sibling-relation-feedback-normalization.md", + "credited_edge": { + "source_id": "docs/sibling-relation-feedback-normalization.md", + "target_id": "docs/sibling-normalization-controlled-evaluation.md", + "edge_type": "links_to" + }, + "outcome": "corrected", + "direct_query": "sibling normalization controlled evaluation", + "direct_node_id": "docs/sibling-normalization-controlled-evaluation.md", + "reverse_query": "sibling relation feedback normalization", + "reverse_node_id": "docs/sibling-relation-feedback-normalization.md", + "retrieval_limit": 21, + "hit_k": 5, + "allowed_mutation_edges": [ + "docs/sibling-relation-feedback-normalization.md|docs/sibling-normalization-controlled-evaluation.md|links_to" + ] + }, + { + "case_id": "dev-lexical-mcp-control", + "case_role": "lexical", + "query": "optional MCP feedback interface", + "search_surface": "lexical", + "used_node_id": "docs/optional-mcp-interface.md", + "source_node_id": "docs/optional-mcp-interface.md", + "credited_edge": {}, + "outcome": "confirmed", + "direct_query": "optional MCP interface", + "direct_node_id": "docs/optional-mcp-interface.md", + "reverse_query": "optional MCP interface", + "reverse_node_id": "docs/optional-mcp-interface.md", + "retrieval_limit": 21, + "hit_k": 5, + "allowed_mutation_edges": [] + }, + { + "case_id": "dev-zero-hop-requirements-control", + "case_role": "zero_hop", + "query": "requirements specification", + "search_surface": "lexical", + "used_node_id": "docs/requirements.md", + "source_node_id": "docs/requirements.md", + "credited_edge": {}, + "outcome": "confirmed", + "direct_query": "requirements specification", + "direct_node_id": "docs/requirements.md", + "reverse_query": "requirements specification", + "reverse_node_id": "docs/requirements.md", + "retrieval_limit": 21, + "hit_k": 5, + "allowed_mutation_edges": [] + } + ], + "holdout": [ + { + "case_id": "holdout-confirmed-readme-feedback", + "case_role": "confirmed", + "query": "Neuron Graph RAG prototype", + "search_surface": "relation", + "used_node_id": "docs/feedback-adaptation-experiment.md", + "source_node_id": "README.md", + "credited_edge": { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-experiment.md", + "edge_type": "links_to" + }, + "outcome": "confirmed", + "direct_query": "feedback adaptation experiment", + "direct_node_id": "docs/feedback-adaptation-experiment.md", + "reverse_query": "Neuron Graph RAG prototype", + "reverse_node_id": "README.md", + "retrieval_limit": 21, + "hit_k": 5, + "allowed_mutation_edges": [ + "README.md|docs/anchored-bm25-graph-hybrid-experiment.md|links_to", + "README.md|docs/anchored-fusion-calibration-experiment.md|links_to", + "README.md|docs/blind-llm-channel-selection-experiment.md|links_to", + "README.md|docs/d1-corpus-fixture.md|links_to", + "README.md|docs/feedback-adaptation-experiment.md|links_to", + "README.md|docs/feedback-adaptation-reproduction-experiment.md|links_to", + "README.md|docs/github-rag-mcp-replacement-compatibility.md|links_to", + "README.md|docs/independent-retrieval-channels-experiment.md|links_to", + "README.md|docs/neural-dynamics-experiment.md|links_to", + "README.md|docs/neural-dynamics-local-competition-experiment.md|links_to", + "README.md|docs/node-first-blind-selection-experiment.md|links_to", + "README.md|docs/optional-mcp-interface.md|links_to", + "README.md|docs/real-corpus-benchmark.md|links_to", + "README.md|docs/requirements.md|links_to" + ] + }, + { + "case_id": "holdout-corrected-readme-reproduction", + "case_role": "corrected", + "query": "Neuron Graph RAG prototype", + "search_surface": "relation", + "used_node_id": "docs/feedback-adaptation-reproduction-experiment.md", + "source_node_id": "README.md", + "credited_edge": { + "source_id": "README.md", + "target_id": "docs/feedback-adaptation-reproduction-experiment.md", + "edge_type": "links_to" + }, + "outcome": "corrected", + "direct_query": "feedback adaptation reproduction experiment", + "direct_node_id": "docs/feedback-adaptation-reproduction-experiment.md", + "reverse_query": "Neuron Graph RAG prototype", + "reverse_node_id": "README.md", + "retrieval_limit": 21, + "hit_k": 5, + "allowed_mutation_edges": [ + "README.md|docs/anchored-bm25-graph-hybrid-experiment.md|links_to", + "README.md|docs/anchored-fusion-calibration-experiment.md|links_to", + "README.md|docs/blind-llm-channel-selection-experiment.md|links_to", + "README.md|docs/d1-corpus-fixture.md|links_to", + "README.md|docs/feedback-adaptation-experiment.md|links_to", + "README.md|docs/feedback-adaptation-reproduction-experiment.md|links_to", + "README.md|docs/github-rag-mcp-replacement-compatibility.md|links_to", + "README.md|docs/independent-retrieval-channels-experiment.md|links_to", + "README.md|docs/neural-dynamics-experiment.md|links_to", + "README.md|docs/neural-dynamics-local-competition-experiment.md|links_to", + "README.md|docs/node-first-blind-selection-experiment.md|links_to", + "README.md|docs/optional-mcp-interface.md|links_to", + "README.md|docs/real-corpus-benchmark.md|links_to", + "README.md|docs/requirements.md|links_to" + ] + }, + { + "case_id": "holdout-lexical-feedback-control", + "case_role": "lexical", + "query": "feedback adaptation experiment", + "search_surface": "lexical", + "used_node_id": "docs/feedback-adaptation-experiment.md", + "source_node_id": "docs/feedback-adaptation-experiment.md", + "credited_edge": {}, + "outcome": "confirmed", + "direct_query": "feedback adaptation experiment", + "direct_node_id": "docs/feedback-adaptation-experiment.md", + "reverse_query": "feedback adaptation experiment", + "reverse_node_id": "docs/feedback-adaptation-experiment.md", + "retrieval_limit": 21, + "hit_k": 5, + "allowed_mutation_edges": [] + }, + { + "case_id": "holdout-zero-hop-readme-control", + "case_role": "zero_hop", + "query": "Neuron Graph RAG prototype", + "search_surface": "lexical", + "used_node_id": "README.md", + "source_node_id": "README.md", + "credited_edge": {}, + "outcome": "confirmed", + "direct_query": "Neuron Graph RAG prototype", + "direct_node_id": "README.md", + "reverse_query": "Neuron Graph RAG prototype", + "reverse_node_id": "README.md", + "retrieval_limit": 21, + "hit_k": 5, + "allowed_mutation_edges": [] + } + ] + } +} diff --git a/tests/fixtures/soft_start_snapshot_v1.gate.json b/tests/fixtures/soft_start_snapshot_v1.gate.json new file mode 100644 index 0000000..fa8c9f8 --- /dev/null +++ b/tests/fixtures/soft_start_snapshot_v1.gate.json @@ -0,0 +1,38 @@ +{ + "protocol_id": "soft-start-snapshot-v1", + "thresholds": { + "negative_provisional_ratio_max": 0.25, + "confirmation_decay_ratio": 0.5, + "numeric_tolerance": 1e-12 + }, + "gates": [ + { + "gate_id": "protocol-integrity", + "hard": true + }, + { + "gate_id": "soft-start-schedule", + "hard": true + }, + { + "gate_id": "policy-boundaries", + "hard": true + }, + { + "gate_id": "learning-latency-and-quality", + "hard": true + }, + { + "gate_id": "negative-provisional-bound", + "hard": true + }, + { + "gate_id": "control-rank-and-mutation-safety", + "hard": true + }, + { + "gate_id": "mutation-locality-and-source-isolation", + "hard": true + } + ] +} diff --git a/tests/fixtures/soft_start_snapshot_v1.manifest.json b/tests/fixtures/soft_start_snapshot_v1.manifest.json new file mode 100644 index 0000000..41de91e --- /dev/null +++ b/tests/fixtures/soft_start_snapshot_v1.manifest.json @@ -0,0 +1,67 @@ +{ + "protocol_id": "soft-start-snapshot-v1", + "issue": 104, + "source_boundary": "one-time-transaction-consistent-local-snapshot", + "historical_verification": "manifest-first-addition-commit-exact-blobs", + "snapshot": { + "source_locator": "local_codex_ngr_database", + "source_access": "sqlite-uri-mode-ro-query-only", + "capture_method": "sqlite-backup-api", + "captured_at": "2026-08-21T00:48:04+00:00", + "source_container_sha256_before": "90c664d345aab9a9ccf36943b5b503cf98e9588577db0e7ccd4f07b27cb33fe0", + "source_container_sha256_after": "90c664d345aab9a9ccf36943b5b503cf98e9588577db0e7ccd4f07b27cb33fe0", + "snapshot_sha256": "003f24478f8d18dd34ab6aee5d939202d116f195ac8db33c29e38ab7e0f456d1", + "snapshot_size": 425984, + "schema_sha256": "a4e58aa7675a6d9e3d9dd7fa778d5bbb4d0ec45eecc262e62f87e019a3ccae9f", + "table_names": [ + "activation_state", + "confirmed_edge_state", + "confirmed_relation_feedback", + "confirmed_source_uses", + "delayed_outcome_nodes", + "delayed_outcomes", + "edges", + "feedback_requests", + "nodes", + "relation_feedback_evidence", + "retrieval_channels", + "retrieval_results", + "retrievals", + "source_use_state", + "success_feedback", + "success_nodes" + ], + "row_counts": { + "nodes": 21, + "edges": 30, + "retrievals": 24, + "success_feedback": 10, + "delayed_outcomes": 3 + } + }, + "protocol_artifacts": { + "fixture": "tests/fixtures/soft_start_snapshot_v1.fixture.json", + "schedule": "tests/fixtures/soft_start_snapshot_v1.schedule.json", + "gate": "tests/fixtures/soft_start_snapshot_v1.gate.json", + "result_schema": "tests/fixtures/soft_start_snapshot_v1.result-schema.json", + "audit": "tests/fixtures/soft_start_snapshot_v1.result-free-audit.json" + }, + "outputs": { + "development": "tests/fixtures/soft_start_snapshot_v1.development.observed.json", + "holdout": "tests/fixtures/soft_start_snapshot_v1.holdout.observed.json" + }, + "artifact_sha256": { + "src/neuron_graph_rag/soft_start_snapshot_evaluation.py": "d7f7b421315118c96ccb9e796524dd02c0edec2c0f6fb2f7398b7ad88be58f13", + "tools/run_soft_start_snapshot_evaluation.py": "c15a14b4b0d2c8498f70b01a7e75aa45a1c8a670690638bdc7c4b2aa3654c2da", + "tests/test_soft_start_snapshot_evaluation.py": "a43c5dcfa2afe4506bcf2966cfbe6fab4ce7e09f37c9eb82b6608a5310b21210", + "tests/fixtures/soft_start_snapshot_v1.fixture.json": "9d785ffa49c6cca590a088c50bb33cc1b55d3120063c7e0f9ef33603ea07ace9", + "tests/fixtures/soft_start_snapshot_v1.schedule.json": "932ea6636f81fe3e0a68a1e78e48ce423d08511a7235185d9d02b38d6421f331", + "tests/fixtures/soft_start_snapshot_v1.gate.json": "f38e1d052fede8380a86344b80332506405343f2e73d6efe40bf74addd5f907e", + "tests/fixtures/soft_start_snapshot_v1.result-schema.json": "65c380803004eafa6e2faae259108ea972ce26dafe1284590d8580703055b5b4", + "tests/fixtures/soft_start_snapshot_v1.result-free-audit.json": "3169c3fcef89bbe10d29c103e4e294887da13d81983d27dc7ccd9b3a697a69c2", + "docs/soft-start-snapshot-evaluation.md": "f19d578a3babb07a6a3c86dfe678bf0566e29871b80722a437bcb143a31ab980", + "docs/requirements.md": "8d39e4eb3da6e3fa27b4b57cc63e8e3951be28d539fcac71f258533a69d7249b", + "docs/Decision-Structure.md": "a35f485db4adc6b403fe8f3ff5db270df3d0da5aae94313f3d79e54762b0bb67", + "README.md": "1222d1146560719b19f5d1962f12740a4929cb02bf97ad93830723ac1845d08a" + } +} diff --git a/tests/fixtures/soft_start_snapshot_v1.result-free-audit.json b/tests/fixtures/soft_start_snapshot_v1.result-free-audit.json new file mode 100644 index 0000000..7d2d387 --- /dev/null +++ b/tests/fixtures/soft_start_snapshot_v1.result-free-audit.json @@ -0,0 +1,12 @@ +{ + "protocol_id": "soft-start-snapshot-v1", + "result_free": true, + "registered_outputs_absent": true, + "source_database_write_count": 0, + "snapshot_clone_only": true, + "snapshot_body_private": true, + "private_node_text_registered": false, + "absolute_private_path_registered": false, + "placeholder_round_trip_passed": true, + "prior_frozen_artifacts_reused": false +} diff --git a/tests/fixtures/soft_start_snapshot_v1.result-schema.json b/tests/fixtures/soft_start_snapshot_v1.result-schema.json new file mode 100644 index 0000000..e030999 --- /dev/null +++ b/tests/fixtures/soft_start_snapshot_v1.result-schema.json @@ -0,0 +1,21 @@ +{ + "protocol_id": "soft-start-snapshot-v1", + "top_level_fields": [ + "protocol_id", + "stage", + "status", + "failure_code", + "snapshot", + "protocol_hashes", + "preflight", + "arms", + "gates", + "all_hard_gates_pass", + "interpretation_ja" + ], + "failure_codes": [ + "preflight-failed", + "execution-failed" + ], + "output_policy": "exclusive-create-no-overwrite-no-rerun" +} diff --git a/tests/fixtures/soft_start_snapshot_v1.schedule.json b/tests/fixtures/soft_start_snapshot_v1.schedule.json new file mode 100644 index 0000000..e462d1e --- /dev/null +++ b/tests/fixtures/soft_start_snapshot_v1.schedule.json @@ -0,0 +1,82 @@ +{ + "protocol_id": "soft-start-snapshot-v1", + "base_engine_config": { + "sparse_weight": 0.55, + "dense_weight": 0.45, + "entry_weight": 0.55, + "graph_weight": 0.45, + "seed_count": 3, + "max_hops": 2, + "hop_decay": 0.7, + "activation_half_life_seconds": 3600.0, + "feedback_learning_rate": 0.2, + "sibling_feedback_normalization": 1.0, + "maximum_edge_weight": 2.0, + "maximum_activation": 10.0, + "max_paths_per_node": 4, + "max_propagation_expansions": 10000, + "activation_strategy": "current_positive_additive", + "activation_budget": 1.0, + "inhibition_ratio": 0.0, + "inhibition_top_k": 0, + "query_transmission_floor": 0.4, + "query_transmission_power": 1.0, + "recurrent_steps": 3, + "recurrent_decay": 0.5, + "convergence_tolerance": 1e-09, + "max_active_paths_per_node": 4, + "use_dense_retrieval": true, + "use_graph_propagation": true, + "graph_normalization": "max", + "final_fusion_strategy": "linear", + "rrf_k": 60, + "relation_feedback_evidence_quorum": 1, + "confirmed_outcome_reinforcement": false, + "confirmation_decay_ratio": null, + "soft_start_feedback_reinforcement": false, + "soft_start_feedback_ratio": null + }, + "arms": [ + { + "arm_id": "control", + "policy": "audit-only", + "engine_config": {} + }, + { + "arm_id": "used_q3_s1", + "policy": "used-evidence-quorum-3-sibling-1.0", + "engine_config": { + "relation_feedback_evidence_quorum": 3 + } + }, + { + "arm_id": "confirmed_r05_s1", + "policy": "confirmed-only-decay-0.5-sibling-1.0", + "engine_config": { + "confirmed_outcome_reinforcement": true, + "confirmation_decay_ratio": 0.5 + } + }, + { + "arm_id": "soft_start_r025_r05_s1", + "policy": "soft-start-0.25-decay-0.5-sibling-1.0", + "engine_config": { + "soft_start_feedback_reinforcement": true, + "soft_start_feedback_ratio": 0.25, + "confirmation_decay_ratio": 0.5 + } + } + ], + "event_order": [ + "used_1", + "outcome_1", + "used_2", + "outcome_2", + "used_3", + "outcome_3" + ], + "iterations_per_case": 3, + "checkpoint_policy": "baseline and after every registered event", + "fresh_trace_policy": "one new search trace per iteration", + "fresh_clone_replay": true +} diff --git a/tests/test_soft_start_snapshot_evaluation.py b/tests/test_soft_start_snapshot_evaluation.py new file mode 100644 index 0000000..a0a4956 --- /dev/null +++ b/tests/test_soft_start_snapshot_evaluation.py @@ -0,0 +1,164 @@ +from __future__ import annotations + +import hashlib +import json +import sqlite3 +import subprocess +import tempfile +import unittest +from pathlib import Path + +from neuron_graph_rag.corpus_integrity import verify_manifest_source_hashes +from neuron_graph_rag.soft_start_snapshot_evaluation import ( + MANIFEST_PATH, + POLICIES, + STEM, + acquire_transactional_snapshot, + assert_public_payload, + prove_writer_verifier_round_trip, + read_json, + verify_registered_result, + write_json_exclusive, +) + + +ROOT = Path(__file__).resolve().parents[1] +FIXTURES = ROOT / "tests" / "fixtures" + + +def _fixture(name: str) -> dict[str, object]: + return read_json(FIXTURES / f"{STEM}.{name}.json") + + +class SoftStartSnapshotFreezeTest(unittest.TestCase): + def test_result_free_artifacts_are_canonical_private_free_and_complete(self) -> None: + names = ( + "fixture", + "schedule", + "gate", + "result-schema", + "result-free-audit", + ) + for name in names: + path = FIXTURES / f"{STEM}.{name}.json" + raw = path.read_bytes() + payload = json.loads(raw.decode("utf-8", errors="strict")) + self.assertNotIn(b"\r", raw) + self.assertEqual( + raw.decode("utf-8"), + json.dumps(payload, ensure_ascii=False, indent=2) + "\n", + ) + self.assertEqual(payload["protocol_id"], "soft-start-snapshot-v1") + assert_public_payload(payload) + + schedule = _fixture("schedule") + self.assertEqual( + [arm["arm_id"] for arm in schedule["arms"]], list(POLICIES) + ) + self.assertEqual(schedule["iterations_per_case"], 3) + self.assertEqual( + schedule["event_order"], + ["used_1", "outcome_1", "used_2", "outcome_2", "used_3", "outcome_3"], + ) + self.assertEqual( + schedule["arms"][3]["engine_config"], + { + "soft_start_feedback_reinforcement": True, + "soft_start_feedback_ratio": 0.25, + "confirmation_decay_ratio": 0.5, + }, + ) + fixture = _fixture("fixture") + for stage in ("development", "holdout"): + self.assertEqual( + [case["case_role"] for case in fixture["stages"][stage]], + ["confirmed", "corrected", "lexical", "zero_hop"], + ) + + audit = _fixture("result-free-audit") + self.assertTrue(audit["result_free"]) + self.assertTrue(audit["registered_outputs_absent"]) + self.assertEqual(audit["source_database_write_count"], 0) + self.assertTrue(audit["placeholder_round_trip_passed"]) + + def test_manifest_reads_registered_commit_bytes_and_registered_outputs_were_absent(self) -> None: + manifest = read_json(MANIFEST_PATH) + assert_public_payload(manifest) + registered = verify_manifest_source_hashes( + ROOT, MANIFEST_PATH, manifest["artifact_sha256"] + ) + self.assertEqual(registered.artifact_sha256, manifest["artifact_sha256"]) + for relative in manifest["outputs"].values(): + completed = subprocess.run( + [ + "git", + "cat-file", + "-e", + f"{registered.source_commit}:{relative}", + ], + cwd=ROOT, + check=False, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + ) + self.assertNotEqual(completed.returncode, 0) + + def test_snapshot_acquisition_is_transactional_read_only_and_exclusive(self) -> None: + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + source = root / "source.sqlite" + snapshot = root / "snapshot.sqlite" + connection = sqlite3.connect(source) + try: + connection.execute("CREATE TABLE nodes(node_id TEXT PRIMARY KEY, text TEXT)") + connection.execute( + "CREATE TABLE edges(source_id TEXT, target_id TEXT, edge_type TEXT)" + ) + connection.execute("CREATE TABLE retrievals(trace_id TEXT)") + connection.execute("CREATE TABLE success_feedback(feedback_id TEXT)") + connection.execute("CREATE TABLE delayed_outcomes(outcome_id TEXT)") + connection.execute("INSERT INTO nodes VALUES ('public-id', 'private body')") + connection.commit() + finally: + connection.close() + before = hashlib.sha256(source.read_bytes()).hexdigest() + provenance = acquire_transactional_snapshot(source, snapshot) + after = hashlib.sha256(source.read_bytes()).hexdigest() + self.assertEqual(before, after) + self.assertEqual( + provenance["source_container_sha256_before"], + provenance["source_container_sha256_after"], + ) + self.assertEqual(provenance["row_counts"]["nodes"], 1) + self.assertNotIn("private body", json.dumps(provenance)) + assert_public_payload(provenance) + with self.assertRaises(FileExistsError): + acquire_transactional_snapshot(source, snapshot) + + def test_writer_round_trip_is_exclusive_and_privacy_scan_fails_closed(self) -> None: + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + prove_writer_verifier_round_trip(root / "probe.json") + self.assertFalse((root / "probe.json").exists()) + target = root / "exclusive.json" + write_json_exclusive(target, {"safe": True}) + with self.assertRaises(FileExistsError): + write_json_exclusive(target, {"safe": False}) + with self.assertRaisesRegex(ValueError, "private field"): + assert_public_payload({"node_text": "secret"}) + with self.assertRaisesRegex(ValueError, "absolute private path"): + assert_public_payload({"value": "C:\\private\\snapshot.sqlite"}) + with self.assertRaisesRegex(ValueError, "absolute private path"): + assert_public_payload({"value": "/private/snapshot.sqlite"}) + with self.assertRaisesRegex(ValueError, "credential-shaped"): + assert_public_payload({"value": "password=hunter2"}) + + def test_registered_observations_verify_when_present(self) -> None: + manifest = read_json(MANIFEST_PATH) + for stage, relative in manifest["outputs"].items(): + if (ROOT / relative).exists(): + verify_registered_result(stage) + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/run_soft_start_snapshot_evaluation.py b/tools/run_soft_start_snapshot_evaluation.py new file mode 100644 index 0000000..93f597d --- /dev/null +++ b/tools/run_soft_start_snapshot_evaluation.py @@ -0,0 +1,47 @@ +from __future__ import annotations + +import argparse +import json +from pathlib import Path +from tempfile import TemporaryDirectory + +from neuron_graph_rag.soft_start_snapshot_evaluation import ( + acquire_transactional_snapshot, + preflight_snapshot, + prove_writer_verifier_round_trip, + run_registered_stage, + verify_registered_result, +) + + +def main() -> None: + parser = argparse.ArgumentParser() + actions = parser.add_mutually_exclusive_group(required=True) + actions.add_argument("--acquire", action="store_true") + actions.add_argument("--probe", action="store_true") + actions.add_argument("--stage", choices=("development", "holdout")) + actions.add_argument("--verify", choices=("development", "holdout")) + parser.add_argument("--source", type=Path) + parser.add_argument("--snapshot", type=Path) + args = parser.parse_args() + if args.acquire: + if args.source is None or args.snapshot is None: + parser.error("--acquire requires --source and --snapshot") + print(json.dumps(acquire_transactional_snapshot(args.source, args.snapshot), indent=2)) + elif args.probe: + if args.snapshot is None: + parser.error("--probe requires --snapshot") + with TemporaryDirectory() as directory: + prove_writer_verifier_round_trip(Path(directory) / "placeholder.json") + print(json.dumps(preflight_snapshot(args.snapshot), indent=2)) + elif args.stage: + if args.snapshot is None: + parser.error("--stage requires --snapshot") + print(run_registered_stage(args.stage, args.snapshot)) + else: + verify_registered_result(args.verify) + print(f"{args.verify} verification passed") + + +if __name__ == "__main__": + main()