From b35ec06e2640803b1215a3afed8c4548cc97ee40 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:24:24 -0700 Subject: [PATCH 01/40] data(stack): pin EDCM metric-origin producer --- .../EDCM_METRIC_ORIGINS_SOURCE.json | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json diff --git a/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json b/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json new file mode 100644 index 00000000..eefb15f0 --- /dev/null +++ b/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json @@ -0,0 +1,19 @@ +{ + "schema": "edcm.metric-origin-spec-fixture", + "version": "0.1.0", + "producer_repository": "The-Interdependency/edcm", + "producer_commit": "c5a8ff3b9189d1b8f04810380b5b57d429d8efaa", + "specs": { + "C": {"surface_terms":["Constraint Strain"],"defining_statement":"constraint strain is pressure produced by contradiction within the measured window","formula_or_rule":"weighted contradiction density","standing":"resolved","unresolved":[]}, + "R": {"surface_terms":["Refusal Density"],"defining_statement":"refusal density is the concentration of refusal relative to active constraint statements","formula_or_rule":"count refusal markers relative to constraint statements","standing":"resolved","unresolved":[]}, + "F": {"surface_terms":["Fixation"],"defining_statement":"fixation is persistence of substantially the same constraint bearing pattern across successive states","formula_or_rule":"semantic or structural persistence across consecutive constraint expressions","standing":"resolved","unresolved":[]}, + "E": {"surface_terms":["Escalation"],"defining_statement":"escalation is positive change in commitment or constraint intensity across sequence","formula_or_rule":"positive derivative of commitment intensity","standing":"resolved","unresolved":[]}, + "D": {"surface_terms":["Deflection"],"defining_statement":"deflection is movement away from the active constraint bearing subject or relation","formula_or_rule":"one minus constraint relevant share or a declared comparison proxy","standing":"resolved","unresolved":[]}, + "N": {"surface_terms":["Noise"],"defining_statement":"noise is activity that consumes representational space without proportionate constraint resolution","formula_or_rule":"one minus resolution relative to constraint load with declared structural proxies","standing":"resolved","unresolved":[]}, + "I": {"surface_terms":["Integration Failure"],"defining_statement":"integration failure is failure of a correction or newly supplied constraint to alter subsequent behavior accordingly","formula_or_rule":"one minus correction integration similarity or a declared proxy","standing":"resolved","unresolved":[]}, + "O": {"surface_terms":["Overextension","Overconfidence"],"defining_statement":"O has conflicting maintained semantic names and therefore has no closed semantic origin yet","formula_or_rule":"hmmm","standing":"hmmm","unresolved":["marker canon says Overextension; compute.py says Overconfidence"]}, + "L": {"surface_terms":["Load","Coherence Loss"],"defining_statement":"L has conflicting maintained semantic names and therefore has no closed semantic origin yet","formula_or_rule":"hmmm","standing":"hmmm","unresolved":["marker canon says Load; compute.py says Coherence Loss"]}, + "P": {"surface_terms":["Progress"],"defining_statement":"progress is newly integrated information or state change that advances resolution relative to the prior state","formula_or_rule":"novelty plus entropy gain proxy in the maintained implementation","standing":"resolved","unresolved":[]}, + "kappa": {"surface_terms":["Stored Tension"],"defining_statement":"stored tension is unresolved dissonance carried forward as circuit state","formula_or_rule":"persistent circuit state updated by energy step","standing":"resolved","unresolved":[]} + } +} From 49024fcfa55fc6050d988265e39a9c2ec22280e0 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:24:26 -0700 Subject: [PATCH 02/40] feat(stack): construct EDCM metric hyperspace origins --- .../english_gonol/edcm_metric_origins.py | 161 ++++++++++++++++++ 1 file changed, 161 insertions(+) create mode 100644 research/english-gonol/english_gonol/edcm_metric_origins.py diff --git a/research/english-gonol/english_gonol/edcm_metric_origins.py b/research/english-gonol/english_gonol/edcm_metric_origins.py new file mode 100644 index 00000000..0e1cd803 --- /dev/null +++ b/research/english-gonol/english_gonol/edcm_metric_origins.py @@ -0,0 +1,161 @@ +"""Construct EDCM metric words as English hyperspace origin sets. + +Usage: load_metric_origin_specs(), then build_metric_origin_set(state_dir, id, +construct_receipt=...). The words define the instrument origin. They are not +measurement evidence and no metric value is computed here. +""" + +# === MODULE_BUILD === +# id: english_edcm_metric_origin_sets_v0 +# module_name: english_gonol.edcm_metric_origins +# module_kind: constructor +# summary: constructs ordered English hyperspace origin sets from EDCM-owned metric descriptions +# owner: Stack English Gonol Construction +# public_surface: MetricOriginSet, OriginComponent, load_metric_origin_specs, build_metric_origin_set +# internal_surface: exact-run admission and deterministic receipt +# auth_boundary: none +# storage_boundary: read +# network_boundary: none +# user_data_boundary: none +# admin_only: false +# tests: research/english-gonol/tests/test_edcm_metric_origins.py +# rollout: stack-local research candidate +# rollback: remove module fixture and tests; EDCM source specs remain unchanged +# requires: english_gonol_language_hyperspace, edcm metric-origin spec fixture +# since: 2026-10-03 +# unresolved: O and L source semantics conflict; full-corpus closure requires the generated construct.db +# === END MODULE_BUILD === + +# === CONTRACTS === +# id: metric_origin_words_define_instrument_not_evidence +# given: an EDCM metric origin set is constructed +# then: it contains only source-owned semantic construction and no observation or metric value +# class: boundary_contract +# +# id: metric_origin_preserves_order_identity_provenance +# given: a resolved metric description is admitted by the English construct +# then: exact ordered word and whitespace-glyph axes plus producer and construct identities survive in the receipt +# class: correctness +# +# id: metric_origin_unresolved_fails_open_as_hmmm_not_closed +# given: the EDCM source spec is hmmm +# then: no semantic components are constructed and closed is false +# class: safety +# === END CONTRACTS === + +from __future__ import annotations +from dataclasses import asdict, dataclass +from hashlib import sha256 +import json +from pathlib import Path +import sqlite3 + +from .full_construct_run import _definition_runs +from .hyperspace_construct import glyph_inventory, promote_glyph, promote_word + +SCHEMA = "english-gonol.edcm-metric-origin-set" +VERSION = "0.1.0" +FIXTURE = Path(__file__).resolve().parents[1] / "EDCM_METRIC_ORIGINS_SOURCE.json" + +def _canonical(value: object) -> bytes: + return json.dumps(value, sort_keys=True, ensure_ascii=False, + separators=(",", ":"), allow_nan=False).encode("utf-8") + +@dataclass(frozen=True, slots=True) +class OriginComponent: + ordinal: int + kind: str + surface: str + axis_origin: str + axis_index: int | None + identity: str + +@dataclass(frozen=True, slots=True) +class MetricOriginSet: + metric_id: str + producer_repository: str + producer_commit: str + construct_receipt: str + source_text: str + components: tuple[OriginComponent, ...] + closed: bool + unresolved: tuple[str, ...] + receipt_sha256: str + + def to_dict(self) -> dict[str, object]: + return { + "schema": SCHEMA, "version": VERSION, + "metric_id": self.metric_id, + "producer_repository": self.producer_repository, + "producer_commit": self.producer_commit, + "construct_receipt": self.construct_receipt, + "source_text": self.source_text, + "components": [asdict(x) for x in self.components], + "closed": self.closed, + "unresolved": list(self.unresolved), + "receipt_sha256": self.receipt_sha256, + } + +def load_metric_origin_specs(path: Path = FIXTURE) -> dict[str, object]: + data = json.loads(Path(path).read_text(encoding="utf-8")) + if data.get("schema") != "edcm.metric-origin-spec-fixture" or data.get("version") != "0.1.0": + raise ValueError("unsupported EDCM metric-origin fixture") + return data + +def _receipt(payload: dict[str, object]) -> str: + return sha256(_canonical(payload)).hexdigest() + +def build_metric_origin_set( + state_dir: Path, + metric_id: str, + *, + construct_receipt: str, + fixture_path: Path = FIXTURE, +) -> MetricOriginSet: + source = load_metric_origin_specs(fixture_path) + specs = source["specs"] + if metric_id not in specs: + raise KeyError(f"unknown metric origin {metric_id!r}") + spec = specs[metric_id] + text = " ".join((*spec["surface_terms"], spec["defining_statement"], spec["formula_or_rule"])) + unresolved = tuple(spec.get("unresolved", ())) + common = { + "metric_id": metric_id, + "producer_repository": source["producer_repository"], + "producer_commit": source["producer_commit"], + "construct_receipt": construct_receipt, + "source_text": text, + } + if spec["standing"] != "resolved": + payload = {**common, "components": [], "closed": False, "unresolved": list(unresolved)} + return MetricOriginSet(**common, components=(), closed=False, unresolved=unresolved, + receipt_sha256=_receipt(payload)) + + db_path = Path(state_dir) / "construct.db" + if not db_path.exists(): + raise ValueError(f"construct.db not found under {state_dir}") + db = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True) + try: + inventory = glyph_inventory(db) + components = [] + for ordinal, (kind, surface, _start, _end) in enumerate(_definition_runs(text)): + if kind == "word": + row = db.execute("SELECT id FROM words WHERE surface = ?", (surface,)).fetchone() + if row is None: + raise ValueError(f"metric {metric_id}: unadmitted word surface {surface!r}") + word, axis = promote_word(db, row[0]) + components.append(OriginComponent(ordinal, "word", surface, "O_W", axis, + f"word:{word.word_id}")) + else: + glyph, axis = promote_glyph(db, inventory, surface) + components.append(OriginComponent(ordinal, "glyph", surface, "O_G", axis, + f"glyph:{glyph.identity}")) + finally: + db.close() + payload = {**common, "components": [asdict(x) for x in components], + "closed": True, "unresolved": []} + return MetricOriginSet(**common, components=tuple(components), closed=True, unresolved=(), + receipt_sha256=_receipt(payload)) + +__all__ = ["SCHEMA","VERSION","OriginComponent","MetricOriginSet", + "load_metric_origin_specs","build_metric_origin_set"] From 3534bcfd0b172de9213e8255f302e32f23e11278 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:24:28 -0700 Subject: [PATCH 03/40] test(stack): falsify metric-origin construction boundaries --- .../tests/test_edcm_metric_origins.py | 91 +++++++++++++++++++ 1 file changed, 91 insertions(+) create mode 100644 research/english-gonol/tests/test_edcm_metric_origins.py diff --git a/research/english-gonol/tests/test_edcm_metric_origins.py b/research/english-gonol/tests/test_edcm_metric_origins.py new file mode 100644 index 00000000..56b5342d --- /dev/null +++ b/research/english-gonol/tests/test_edcm_metric_origins.py @@ -0,0 +1,91 @@ +# === CHECKS === +# id: check_metric_origin_instrument_boundary +# proves: metric_origin_words_define_instrument_not_evidence +# call: self::test_origin_record_contains_no_measurement_value +# requires: python3 +# timeout: 10 +# mutates: none +# cleanup: none +# +# id: check_metric_origin_order_provenance +# proves: metric_origin_preserves_order_identity_provenance +# call: self::test_resolved_origin_uses_word_and_glyph_axes_in_order +# requires: python3 +# timeout: 10 +# mutates: temporary sqlite fixture +# cleanup: pytest tmp_path +# +# id: check_metric_origin_hmmm +# proves: metric_origin_unresolved_fails_open_as_hmmm_not_closed +# call: self::test_unresolved_origin_does_not_construct_components +# requires: python3 +# timeout: 10 +# mutates: none +# cleanup: none +# === END CHECKS === + +import json +import sqlite3 +from pathlib import Path + +from english_gonol.edcm_metric_origins import build_metric_origin_set + +def _fixture(tmp_path: Path, metric="F", standing="resolved"): + source = { + "schema":"edcm.metric-origin-spec-fixture","version":"0.1.0", + "producer_repository":"The-Interdependency/edcm","producer_commit":"a"*40, + "specs":{metric:{ + "surface_terms":["Fixation"],"defining_statement":"is persistence", + "formula_or_rule":"across states","standing":standing, + "unresolved":[] if standing=="resolved" else ["collision"]}} + } + path=tmp_path/"source.json" + path.write_text(json.dumps(source),encoding="utf-8") + return path + +def _db(tmp_path: Path): + db=sqlite3.connect(tmp_path/"construct.db") + db.executescript(""" + CREATE TABLE characters (id INTEGER PRIMARY KEY, scalar TEXT, public_position INTEGER); + CREATE TABLE words (id INTEGER PRIMARY KEY, surface TEXT); + CREATE TABLE word_characters (word_id INTEGER, ordinal INTEGER, character_id INTEGER); + """) + chars={} + next_id=1 + words=["Fixation","is","persistence","across","states"] + for surface in words: + for ch in surface+" ": + if ch not in chars: + chars[ch]=next_id + db.execute("INSERT INTO characters VALUES (?,?,NULL)",(next_id,ch)) + next_id+=1 + for wid,surface in enumerate(words,1): + db.execute("INSERT INTO words VALUES (?,?)",(wid,surface)) + for ordinal,ch in enumerate(surface): + db.execute("INSERT INTO word_characters VALUES (?,?,?)",(wid,ordinal,chars[ch])) + db.commit(); db.close() + +def test_resolved_origin_uses_word_and_glyph_axes_in_order(tmp_path): + _db(tmp_path) + record=build_metric_origin_set(tmp_path,"F",construct_receipt="r"*64, + fixture_path=_fixture(tmp_path)) + assert record.closed + assert record.components[0].axis_origin=="O_W" + assert any(x.axis_origin=="O_G" and x.surface==" " for x in record.components) + assert record.producer_repository=="The-Interdependency/edcm" + +def test_origin_record_contains_no_measurement_value(tmp_path): + _db(tmp_path) + record=build_metric_origin_set(tmp_path,"F",construct_receipt="r"*64, + fixture_path=_fixture(tmp_path)) + keys=record.to_dict() + assert "value" not in keys + assert "measurement" not in keys + assert "score" not in keys + +def test_unresolved_origin_does_not_construct_components(tmp_path): + record=build_metric_origin_set(tmp_path,"F",construct_receipt="r"*64, + fixture_path=_fixture(tmp_path,standing="hmmm")) + assert record.closed is False + assert record.components==() + assert record.unresolved==("collision",) From c23e05512c58392b20bc48cd8a8c2f97a577b46f Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:25:44 -0700 Subject: [PATCH 04/40] docs: bind metric-origin semantic work graph --- .../work-graphs/metric-origin-space-v0.json | 44 +++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 research/english-gonol/docs/work-graphs/metric-origin-space-v0.json diff --git a/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json b/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json new file mode 100644 index 00000000..a3218cee --- /dev/null +++ b/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json @@ -0,0 +1,44 @@ +{ + "schema": "the-interdependency.stack-manifest", + "version": "1.0.0", + "work_graph_sha256": "cfc0003637eb9f7948cc3b626a4739c58d171c97d49e155278bb4d73d7f479ad", + "repositories": [ + { + "repository": "The-Interdependency/edcm", + "commit": "881b086afd755ab469b25e4b2b4c5ebdbae7dc3c", + "authority": "metric definitions, scalar measurement, and evidence/readout contracts", + "relation": "defines metric-origin source words and binds scalar readouts to Stack origin receipts" + }, + { + "repository": "The-Interdependency/stack", + "commit": "3534bcfd0b172de9213e8255f302e32f23e11278", + "authority": "current English Gonol semantic construction", + "relation": "constructs EDCM source words as ordered O_W/O_G metric origin sets" + }, + { + "repository": "The-Interdependency/metapat", + "commit": "1cdfb09dd00a451cee30eec2e78624df8c682662", + "authority": "cross-domain semantic constraints", + "relation": "constrains semantic transfer; no metric validity transfer" + }, + { + "repository": "The-Interdependency/ucns", + "commit": "1975fe70cf4e0826a8020c2da3047569e277af64", + "authority": "gonol geometry consumed by Stack English construction", + "relation": "underlying geometry only; no metric semantics or measurement validity" + } + ], + "boundaries": { + "authority_transfer": false, + "proof_status_transfer": false, + "measurement_status_transfer": false, + "semantic_mapping": "declared mapping", + "agent_scope": "cross-repository-work-graph", + "hmmm": [ + "O semantic origin conflicts: Overextension versus Overconfidence", + "L semantic origin conflicts: Load versus Coherence Loss", + "lawful observed-construct to metric-origin projection/distance is unresolved", + "full-corpus closure requires the generated English construct database" + ] + } +} From be0160d86dfc2bdf43139e703b5469ddcefcb3a7 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:27:42 -0700 Subject: [PATCH 05/40] data(stack): repin semantic-only EDCM metric origins --- .../EDCM_METRIC_ORIGINS_SOURCE.json | 26 +++++++++---------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json b/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json index eefb15f0..87df657a 100644 --- a/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json +++ b/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json @@ -1,19 +1,19 @@ { "schema": "edcm.metric-origin-spec-fixture", - "version": "0.1.0", + "version": "0.2.0", "producer_repository": "The-Interdependency/edcm", - "producer_commit": "c5a8ff3b9189d1b8f04810380b5b57d429d8efaa", + "producer_commit": "0d6ea9ad1531b607d6df35175ed86686dcbdb58f", "specs": { - "C": {"surface_terms":["Constraint Strain"],"defining_statement":"constraint strain is pressure produced by contradiction within the measured window","formula_or_rule":"weighted contradiction density","standing":"resolved","unresolved":[]}, - "R": {"surface_terms":["Refusal Density"],"defining_statement":"refusal density is the concentration of refusal relative to active constraint statements","formula_or_rule":"count refusal markers relative to constraint statements","standing":"resolved","unresolved":[]}, - "F": {"surface_terms":["Fixation"],"defining_statement":"fixation is persistence of substantially the same constraint bearing pattern across successive states","formula_or_rule":"semantic or structural persistence across consecutive constraint expressions","standing":"resolved","unresolved":[]}, - "E": {"surface_terms":["Escalation"],"defining_statement":"escalation is positive change in commitment or constraint intensity across sequence","formula_or_rule":"positive derivative of commitment intensity","standing":"resolved","unresolved":[]}, - "D": {"surface_terms":["Deflection"],"defining_statement":"deflection is movement away from the active constraint bearing subject or relation","formula_or_rule":"one minus constraint relevant share or a declared comparison proxy","standing":"resolved","unresolved":[]}, - "N": {"surface_terms":["Noise"],"defining_statement":"noise is activity that consumes representational space without proportionate constraint resolution","formula_or_rule":"one minus resolution relative to constraint load with declared structural proxies","standing":"resolved","unresolved":[]}, - "I": {"surface_terms":["Integration Failure"],"defining_statement":"integration failure is failure of a correction or newly supplied constraint to alter subsequent behavior accordingly","formula_or_rule":"one minus correction integration similarity or a declared proxy","standing":"resolved","unresolved":[]}, - "O": {"surface_terms":["Overextension","Overconfidence"],"defining_statement":"O has conflicting maintained semantic names and therefore has no closed semantic origin yet","formula_or_rule":"hmmm","standing":"hmmm","unresolved":["marker canon says Overextension; compute.py says Overconfidence"]}, - "L": {"surface_terms":["Load","Coherence Loss"],"defining_statement":"L has conflicting maintained semantic names and therefore has no closed semantic origin yet","formula_or_rule":"hmmm","standing":"hmmm","unresolved":["marker canon says Load; compute.py says Coherence Loss"]}, - "P": {"surface_terms":["Progress"],"defining_statement":"progress is newly integrated information or state change that advances resolution relative to the prior state","formula_or_rule":"novelty plus entropy gain proxy in the maintained implementation","standing":"resolved","unresolved":[]}, - "kappa": {"surface_terms":["Stored Tension"],"defining_statement":"stored tension is unresolved dissonance carried forward as circuit state","formula_or_rule":"persistent circuit state updated by energy step","standing":"resolved","unresolved":[]} + "C": {"surface_terms":["Constraint Strain"],"semantic_definition":"constraint strain is pressure produced by contradiction within the measured window","standing":"resolved","measurement_alignment":"proxy","unresolved":["implicit contradiction semantics are not measured by the maintained proxy"]}, + "R": {"surface_terms":["Refusal Density"],"semantic_definition":"refusal density is the concentration of refusal relative to active constraint statements","standing":"resolved","measurement_alignment":"proxy","unresolved":["implemented denominator is token-count scale, not counted constraint statements"]}, + "F": {"surface_terms":["Fixation"],"semantic_definition":"fixation is persistence of substantially the same constraint bearing pattern across successive states","standing":"resolved","measurement_alignment":"proxy","unresolved":["maintained implementation is a lexical structural proxy, not embedding similarity"]}, + "E": {"surface_terms":["Escalation"],"semantic_definition":"escalation is positive change in commitment or constraint intensity across sequence","standing":"resolved","measurement_alignment":"proxy","unresolved":["maintained implementation does not directly compute commitment-intensity derivative"]}, + "D": {"surface_terms":["Deflection"],"semantic_definition":"deflection is movement away from the active constraint bearing subject or relation","standing":"resolved","measurement_alignment":"proxy","unresolved":["prior-round lexical overlap substitutes for active-constraint topic tracking"]}, + "N": {"surface_terms":["Noise"],"semantic_definition":"noise is activity that consumes representational space without proportionate constraint resolution","standing":"resolved","measurement_alignment":"proxy","unresolved":["maintained implementation measures repetition and entropy rather than resolution ratio"]}, + "I": {"surface_terms":["Integration Failure"],"semantic_definition":"integration failure is failure of a correction or newly supplied constraint to alter subsequent behavior accordingly","standing":"resolved","measurement_alignment":"proxy","unresolved":["maintained implementation does not observe subsequent integration behavior"]}, + "O": {"surface_terms":["Overextension","Overconfidence"],"semantic_definition":"O has conflicting maintained semantic names and therefore has no closed semantic origin yet","standing":"hmmm","measurement_alignment":"conflict","unresolved":["marker canon says Overextension; compute.py says Overconfidence"]}, + "L": {"surface_terms":["Load","Coherence Loss"],"semantic_definition":"L has conflicting maintained semantic names and therefore has no closed semantic origin yet","standing":"hmmm","measurement_alignment":"conflict","unresolved":["marker canon says Load; compute.py says Coherence Loss"]}, + "P": {"surface_terms":["Progress"],"semantic_definition":"progress is newly integrated information or state change that advances resolution relative to the prior state","standing":"resolved","measurement_alignment":"proxy","unresolved":["progress is explicitly implemented as a proxy"]}, + "kappa": {"surface_terms":["Stored Tension"],"semantic_definition":"stored tension is unresolved dissonance carried forward as circuit state","standing":"resolved","measurement_alignment":"proxy","unresolved":["resolution function is currently approximated from dissonance"]} } } From a9790a4a672ca5ba00a932b4876888cd0a4edad4 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:28:12 -0700 Subject: [PATCH 06/40] refactor(stack): replace metric-origin constructor --- .../english_gonol/edcm_metric_origins.py | 161 ------------------ 1 file changed, 161 deletions(-) delete mode 100644 research/english-gonol/english_gonol/edcm_metric_origins.py diff --git a/research/english-gonol/english_gonol/edcm_metric_origins.py b/research/english-gonol/english_gonol/edcm_metric_origins.py deleted file mode 100644 index 0e1cd803..00000000 --- a/research/english-gonol/english_gonol/edcm_metric_origins.py +++ /dev/null @@ -1,161 +0,0 @@ -"""Construct EDCM metric words as English hyperspace origin sets. - -Usage: load_metric_origin_specs(), then build_metric_origin_set(state_dir, id, -construct_receipt=...). The words define the instrument origin. They are not -measurement evidence and no metric value is computed here. -""" - -# === MODULE_BUILD === -# id: english_edcm_metric_origin_sets_v0 -# module_name: english_gonol.edcm_metric_origins -# module_kind: constructor -# summary: constructs ordered English hyperspace origin sets from EDCM-owned metric descriptions -# owner: Stack English Gonol Construction -# public_surface: MetricOriginSet, OriginComponent, load_metric_origin_specs, build_metric_origin_set -# internal_surface: exact-run admission and deterministic receipt -# auth_boundary: none -# storage_boundary: read -# network_boundary: none -# user_data_boundary: none -# admin_only: false -# tests: research/english-gonol/tests/test_edcm_metric_origins.py -# rollout: stack-local research candidate -# rollback: remove module fixture and tests; EDCM source specs remain unchanged -# requires: english_gonol_language_hyperspace, edcm metric-origin spec fixture -# since: 2026-10-03 -# unresolved: O and L source semantics conflict; full-corpus closure requires the generated construct.db -# === END MODULE_BUILD === - -# === CONTRACTS === -# id: metric_origin_words_define_instrument_not_evidence -# given: an EDCM metric origin set is constructed -# then: it contains only source-owned semantic construction and no observation or metric value -# class: boundary_contract -# -# id: metric_origin_preserves_order_identity_provenance -# given: a resolved metric description is admitted by the English construct -# then: exact ordered word and whitespace-glyph axes plus producer and construct identities survive in the receipt -# class: correctness -# -# id: metric_origin_unresolved_fails_open_as_hmmm_not_closed -# given: the EDCM source spec is hmmm -# then: no semantic components are constructed and closed is false -# class: safety -# === END CONTRACTS === - -from __future__ import annotations -from dataclasses import asdict, dataclass -from hashlib import sha256 -import json -from pathlib import Path -import sqlite3 - -from .full_construct_run import _definition_runs -from .hyperspace_construct import glyph_inventory, promote_glyph, promote_word - -SCHEMA = "english-gonol.edcm-metric-origin-set" -VERSION = "0.1.0" -FIXTURE = Path(__file__).resolve().parents[1] / "EDCM_METRIC_ORIGINS_SOURCE.json" - -def _canonical(value: object) -> bytes: - return json.dumps(value, sort_keys=True, ensure_ascii=False, - separators=(",", ":"), allow_nan=False).encode("utf-8") - -@dataclass(frozen=True, slots=True) -class OriginComponent: - ordinal: int - kind: str - surface: str - axis_origin: str - axis_index: int | None - identity: str - -@dataclass(frozen=True, slots=True) -class MetricOriginSet: - metric_id: str - producer_repository: str - producer_commit: str - construct_receipt: str - source_text: str - components: tuple[OriginComponent, ...] - closed: bool - unresolved: tuple[str, ...] - receipt_sha256: str - - def to_dict(self) -> dict[str, object]: - return { - "schema": SCHEMA, "version": VERSION, - "metric_id": self.metric_id, - "producer_repository": self.producer_repository, - "producer_commit": self.producer_commit, - "construct_receipt": self.construct_receipt, - "source_text": self.source_text, - "components": [asdict(x) for x in self.components], - "closed": self.closed, - "unresolved": list(self.unresolved), - "receipt_sha256": self.receipt_sha256, - } - -def load_metric_origin_specs(path: Path = FIXTURE) -> dict[str, object]: - data = json.loads(Path(path).read_text(encoding="utf-8")) - if data.get("schema") != "edcm.metric-origin-spec-fixture" or data.get("version") != "0.1.0": - raise ValueError("unsupported EDCM metric-origin fixture") - return data - -def _receipt(payload: dict[str, object]) -> str: - return sha256(_canonical(payload)).hexdigest() - -def build_metric_origin_set( - state_dir: Path, - metric_id: str, - *, - construct_receipt: str, - fixture_path: Path = FIXTURE, -) -> MetricOriginSet: - source = load_metric_origin_specs(fixture_path) - specs = source["specs"] - if metric_id not in specs: - raise KeyError(f"unknown metric origin {metric_id!r}") - spec = specs[metric_id] - text = " ".join((*spec["surface_terms"], spec["defining_statement"], spec["formula_or_rule"])) - unresolved = tuple(spec.get("unresolved", ())) - common = { - "metric_id": metric_id, - "producer_repository": source["producer_repository"], - "producer_commit": source["producer_commit"], - "construct_receipt": construct_receipt, - "source_text": text, - } - if spec["standing"] != "resolved": - payload = {**common, "components": [], "closed": False, "unresolved": list(unresolved)} - return MetricOriginSet(**common, components=(), closed=False, unresolved=unresolved, - receipt_sha256=_receipt(payload)) - - db_path = Path(state_dir) / "construct.db" - if not db_path.exists(): - raise ValueError(f"construct.db not found under {state_dir}") - db = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True) - try: - inventory = glyph_inventory(db) - components = [] - for ordinal, (kind, surface, _start, _end) in enumerate(_definition_runs(text)): - if kind == "word": - row = db.execute("SELECT id FROM words WHERE surface = ?", (surface,)).fetchone() - if row is None: - raise ValueError(f"metric {metric_id}: unadmitted word surface {surface!r}") - word, axis = promote_word(db, row[0]) - components.append(OriginComponent(ordinal, "word", surface, "O_W", axis, - f"word:{word.word_id}")) - else: - glyph, axis = promote_glyph(db, inventory, surface) - components.append(OriginComponent(ordinal, "glyph", surface, "O_G", axis, - f"glyph:{glyph.identity}")) - finally: - db.close() - payload = {**common, "components": [asdict(x) for x in components], - "closed": True, "unresolved": []} - return MetricOriginSet(**common, components=tuple(components), closed=True, unresolved=(), - receipt_sha256=_receipt(payload)) - -__all__ = ["SCHEMA","VERSION","OriginComponent","MetricOriginSet", - "load_metric_origin_specs","build_metric_origin_set"] From 03154d6b75c61c014f27edcf10a1c84c1c9ac79f Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:28:31 -0700 Subject: [PATCH 07/40] refactor(stack): construct semantic-only metric origins --- .../english_gonol/edcm_metric_origins.py | 169 ++++++++++++++++++ 1 file changed, 169 insertions(+) create mode 100644 research/english-gonol/english_gonol/edcm_metric_origins.py diff --git a/research/english-gonol/english_gonol/edcm_metric_origins.py b/research/english-gonol/english_gonol/edcm_metric_origins.py new file mode 100644 index 00000000..152e8973 --- /dev/null +++ b/research/english-gonol/english_gonol/edcm_metric_origins.py @@ -0,0 +1,169 @@ +"""Construct EDCM metric words as English hyperspace origin sets. + +Usage: load_metric_origin_specs(), then build_metric_origin_set(state_dir, id, +construct_receipt=...). Only EDCM semantic-definition words enter the origin. +Declared/implemented measurement rules stay outside the semantic construction. +""" + +# === MODULE_BUILD === +# id: english_edcm_metric_origin_sets_v0 +# module_name: english_gonol.edcm_metric_origins +# module_kind: constructor +# summary: constructs ordered English hyperspace origin sets from EDCM-owned semantic metric descriptions +# owner: Stack English Gonol Construction +# public_surface: MetricOriginSet, OriginComponent, load_metric_origin_specs, build_metric_origin_set +# internal_surface: exact-run admission and deterministic receipt +# auth_boundary: none +# storage_boundary: read +# network_boundary: none +# user_data_boundary: none +# admin_only: false +# tests: research/english-gonol/tests/test_edcm_metric_origins.py +# rollout: stack-local research candidate +# rollback: remove module fixture and tests; EDCM source specs remain unchanged +# requires: english_gonol_language_hyperspace, edcm metric-origin spec fixture +# since: 2026-10-03 +# unresolved: O and L source semantics conflict; full-corpus closure requires the generated construct.db +# === END MODULE_BUILD === + +# === CONTRACTS === +# id: metric_origin_words_define_instrument_not_evidence +# given: an EDCM metric origin set is constructed +# then: it contains only source-owned semantic construction and no observation or metric value +# class: boundary_contract +# +# id: metric_origin_preserves_order_identity_provenance +# given: a resolved metric description is admitted by the English construct +# then: exact ordered word and whitespace-glyph axes plus producer and construct identities survive in the receipt +# class: correctness +# +# id: metric_origin_unresolved_fails_open_as_hmmm_not_closed +# given: the EDCM source spec is hmmm +# then: no semantic components are constructed and closed is false +# class: safety +# === END CONTRACTS === + +from __future__ import annotations +from dataclasses import asdict, dataclass +from hashlib import sha256 +import json +from pathlib import Path +import sqlite3 + +from .full_construct_run import _definition_runs +from .hyperspace_construct import glyph_inventory, promote_glyph, promote_word + +SCHEMA = "english-gonol.edcm-metric-origin-set" +VERSION = "0.1.0" +FIXTURE = Path(__file__).resolve().parents[1] / "EDCM_METRIC_ORIGINS_SOURCE.json" + +def _canonical(value: object) -> bytes: + return json.dumps(value, sort_keys=True, ensure_ascii=False, + separators=(",", ":"), allow_nan=False).encode("utf-8") + +@dataclass(frozen=True, slots=True) +class OriginComponent: + ordinal: int + kind: str + surface: str + axis_origin: str + axis_index: int | None + identity: str + +@dataclass(frozen=True, slots=True) +class MetricOriginSet: + metric_id: str + producer_repository: str + producer_commit: str + construct_receipt: str + source_text: str + components: tuple[OriginComponent, ...] + closed: bool + unresolved: tuple[str, ...] + receipt_sha256: str + + def to_dict(self) -> dict[str, object]: + return { + "schema": SCHEMA, "version": VERSION, + "metric_id": self.metric_id, + "producer_repository": self.producer_repository, + "producer_commit": self.producer_commit, + "construct_receipt": self.construct_receipt, + "source_text": self.source_text, + "components": [asdict(x) for x in self.components], + "closed": self.closed, + "unresolved": list(self.unresolved), + "receipt_sha256": self.receipt_sha256, + } + +def load_metric_origin_specs(path: Path = FIXTURE) -> dict[str, object]: + data = json.loads(Path(path).read_text(encoding="utf-8")) + if data.get("schema") != "edcm.metric-origin-spec-fixture" or data.get("version") != "0.2.0": + raise ValueError("unsupported EDCM metric-origin fixture") + return data + +def _receipt(payload: dict[str, object]) -> str: + return sha256(_canonical(payload)).hexdigest() + +def build_metric_origin_set( + state_dir: Path, + metric_id: str, + *, + construct_receipt: str, + fixture_path: Path = FIXTURE, +) -> MetricOriginSet: + source = load_metric_origin_specs(fixture_path) + specs = source["specs"] + if metric_id not in specs: + raise KeyError(f"unknown metric origin {metric_id!r}") + spec = specs[metric_id] + text = " ".join((*spec["surface_terms"], spec["semantic_definition"])) + unresolved = tuple(spec.get("unresolved", ())) + common = { + "metric_id": metric_id, + "producer_repository": source["producer_repository"], + "producer_commit": source["producer_commit"], + "construct_receipt": construct_receipt, + "source_text": text, + } + if spec["standing"] != "resolved": + payload = {**common, "components": [], "closed": False, "unresolved": list(unresolved)} + return MetricOriginSet(**common, components=(), closed=False, unresolved=unresolved, + receipt_sha256=_receipt(payload)) + + db_path = Path(state_dir) / "construct.db" + if not db_path.exists(): + raise ValueError(f"construct.db not found under {state_dir}") + db = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True) + try: + inventory = glyph_inventory(db) + components = [] + for ordinal, (kind, surface, _start, _end) in enumerate(_definition_runs(text)): + if kind == "word": + row = db.execute("SELECT id FROM words WHERE surface = ?", (surface,)).fetchone() + if row is None: + raise ValueError(f"metric {metric_id}: unadmitted word surface {surface!r}") + word, axis = promote_word(db, row[0]) + components.append(OriginComponent( + ordinal, "word", surface, "O_W", axis, f"word:{word.word_id}" + )) + else: + glyph, axis = promote_glyph(db, inventory, surface) + components.append(OriginComponent( + ordinal, "glyph", surface, "O_G", axis, f"glyph:{glyph.identity}" + )) + finally: + db.close() + + payload = {**common, "components": [asdict(x) for x in components], + "closed": True, "unresolved": list(unresolved)} + return MetricOriginSet( + **common, + components=tuple(components), + closed=True, + unresolved=unresolved, + receipt_sha256=_receipt(payload), + ) + +__all__ = ["SCHEMA","VERSION","OriginComponent","MetricOriginSet", + "load_metric_origin_specs","build_metric_origin_set"] From e653d7f02f8b52eae96bf290e57d615f322ff069 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:28:48 -0700 Subject: [PATCH 08/40] test(stack): separate semantic origin from measurement proxy --- .../english-gonol/tests/test_edcm_metric_origins.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/research/english-gonol/tests/test_edcm_metric_origins.py b/research/english-gonol/tests/test_edcm_metric_origins.py index 56b5342d..5993506d 100644 --- a/research/english-gonol/tests/test_edcm_metric_origins.py +++ b/research/english-gonol/tests/test_edcm_metric_origins.py @@ -32,12 +32,12 @@ def _fixture(tmp_path: Path, metric="F", standing="resolved"): source = { - "schema":"edcm.metric-origin-spec-fixture","version":"0.1.0", + "schema":"edcm.metric-origin-spec-fixture","version":"0.2.0", "producer_repository":"The-Interdependency/edcm","producer_commit":"a"*40, "specs":{metric:{ - "surface_terms":["Fixation"],"defining_statement":"is persistence", - "formula_or_rule":"across states","standing":standing, - "unresolved":[] if standing=="resolved" else ["collision"]}} + "surface_terms":["Fixation"],"semantic_definition":"is persistence across states", + "standing":standing,"measurement_alignment":"proxy", + "unresolved":["proxy gap"] if standing=="resolved" else ["collision"]}} } path=tmp_path/"source.json" path.write_text(json.dumps(source),encoding="utf-8") @@ -73,6 +73,7 @@ def test_resolved_origin_uses_word_and_glyph_axes_in_order(tmp_path): assert record.components[0].axis_origin=="O_W" assert any(x.axis_origin=="O_G" and x.surface==" " for x in record.components) assert record.producer_repository=="The-Interdependency/edcm" + assert "proxy gap" in record.unresolved def test_origin_record_contains_no_measurement_value(tmp_path): _db(tmp_path) @@ -82,6 +83,7 @@ def test_origin_record_contains_no_measurement_value(tmp_path): assert "value" not in keys assert "measurement" not in keys assert "score" not in keys + assert "implemented_rule" not in record.source_text def test_unresolved_origin_does_not_construct_components(tmp_path): record=build_metric_origin_set(tmp_path,"F",construct_receipt="r"*64, From fe207c3b664bce205915e12d9214314756f0d38f Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:29:21 -0700 Subject: [PATCH 09/40] docs: refresh semantic metric-origin work graph --- .../work-graphs/metric-origin-space-v0.json | 53 ++++++------------- 1 file changed, 17 insertions(+), 36 deletions(-) diff --git a/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json b/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json index a3218cee..615f3173 100644 --- a/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json +++ b/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json @@ -1,44 +1,25 @@ { - "schema": "the-interdependency.stack-manifest", - "version": "1.0.0", - "work_graph_sha256": "cfc0003637eb9f7948cc3b626a4739c58d171c97d49e155278bb4d73d7f479ad", - "repositories": [ - { - "repository": "The-Interdependency/edcm", - "commit": "881b086afd755ab469b25e4b2b4c5ebdbae7dc3c", - "authority": "metric definitions, scalar measurement, and evidence/readout contracts", - "relation": "defines metric-origin source words and binds scalar readouts to Stack origin receipts" - }, - { - "repository": "The-Interdependency/stack", - "commit": "3534bcfd0b172de9213e8255f302e32f23e11278", - "authority": "current English Gonol semantic construction", - "relation": "constructs EDCM source words as ordered O_W/O_G metric origin sets" - }, - { - "repository": "The-Interdependency/metapat", - "commit": "1cdfb09dd00a451cee30eec2e78624df8c682662", - "authority": "cross-domain semantic constraints", - "relation": "constrains semantic transfer; no metric validity transfer" - }, - { - "repository": "The-Interdependency/ucns", - "commit": "1975fe70cf4e0826a8020c2da3047569e277af64", - "authority": "gonol geometry consumed by Stack English construction", - "relation": "underlying geometry only; no metric semantics or measurement validity" - } + "schema":"the-interdependency.stack-manifest", + "version":"1.0.0", + "work_graph_sha256":"32b3736512da9fe023f0ee42b75d34d12a18f182bb16785598116adb76ee1242", + "repositories":[ + {"repository":"The-Interdependency/edcm","commit":"0d6ea9ad1531b607d6df35175ed86686dcbdb58f","authority":"metric definitions, scalar measurement, and evidence/readout contracts","relation":"defines metric-origin source words and binds scalar readouts to Stack origin receipts"}, + {"repository":"The-Interdependency/stack","commit":"e653d7f02f8b52eae96bf290e57d615f322ff069","authority":"current English Gonol semantic construction","relation":"constructs EDCM semantic-definition words as ordered O_W/O_G metric origin sets"}, + {"repository":"The-Interdependency/metapat","commit":"1cdfb09dd00a451cee30eec2e78624df8c682662","authority":"cross-domain semantic constraints","relation":"constrains semantic transfer; no metric validity transfer"}, + {"repository":"The-Interdependency/ucns","commit":"1975fe70cf4e0826a8020c2da3047569e277af64","authority":"gonol geometry consumed by Stack English construction","relation":"underlying geometry only; no metric semantics or measurement validity"} ], - "boundaries": { - "authority_transfer": false, - "proof_status_transfer": false, - "measurement_status_transfer": false, - "semantic_mapping": "declared mapping", - "agent_scope": "cross-repository-work-graph", - "hmmm": [ + "boundaries":{ + "authority_transfer":false, + "proof_status_transfer":false, + "measurement_status_transfer":false, + "semantic_mapping":"declared mapping", + "agent_scope":"cross-repository-work-graph", + "hmmm":[ "O semantic origin conflicts: Overextension versus Overconfidence", "L semantic origin conflicts: Load versus Coherence Loss", "lawful observed-construct to metric-origin projection/distance is unresolved", - "full-corpus closure requires the generated English construct database" + "full-corpus closure requires the generated English construct database", + "originating operator decision lacks immutable public provenance; repository adoption is prospective" ] } } From b688bcfb369ba1bcb0200887bc50a533bc9db1ec Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:35:07 -0700 Subject: [PATCH 10/40] data(stack): consume exact EDCM construction terms --- .../EDCM_METRIC_ORIGINS_SOURCE.json | 193 ++++++++++++++++-- 1 file changed, 180 insertions(+), 13 deletions(-) diff --git a/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json b/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json index 87df657a..1dd7f6f9 100644 --- a/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json +++ b/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json @@ -1,19 +1,186 @@ { "schema": "edcm.metric-origin-spec-fixture", - "version": "0.2.0", + "version": "0.3.0", "producer_repository": "The-Interdependency/edcm", - "producer_commit": "0d6ea9ad1531b607d6df35175ed86686dcbdb58f", + "producer_commit": "7dd93e3fc19f82300e3ffbb83ffc64e641ea6cd4", "specs": { - "C": {"surface_terms":["Constraint Strain"],"semantic_definition":"constraint strain is pressure produced by contradiction within the measured window","standing":"resolved","measurement_alignment":"proxy","unresolved":["implicit contradiction semantics are not measured by the maintained proxy"]}, - "R": {"surface_terms":["Refusal Density"],"semantic_definition":"refusal density is the concentration of refusal relative to active constraint statements","standing":"resolved","measurement_alignment":"proxy","unresolved":["implemented denominator is token-count scale, not counted constraint statements"]}, - "F": {"surface_terms":["Fixation"],"semantic_definition":"fixation is persistence of substantially the same constraint bearing pattern across successive states","standing":"resolved","measurement_alignment":"proxy","unresolved":["maintained implementation is a lexical structural proxy, not embedding similarity"]}, - "E": {"surface_terms":["Escalation"],"semantic_definition":"escalation is positive change in commitment or constraint intensity across sequence","standing":"resolved","measurement_alignment":"proxy","unresolved":["maintained implementation does not directly compute commitment-intensity derivative"]}, - "D": {"surface_terms":["Deflection"],"semantic_definition":"deflection is movement away from the active constraint bearing subject or relation","standing":"resolved","measurement_alignment":"proxy","unresolved":["prior-round lexical overlap substitutes for active-constraint topic tracking"]}, - "N": {"surface_terms":["Noise"],"semantic_definition":"noise is activity that consumes representational space without proportionate constraint resolution","standing":"resolved","measurement_alignment":"proxy","unresolved":["maintained implementation measures repetition and entropy rather than resolution ratio"]}, - "I": {"surface_terms":["Integration Failure"],"semantic_definition":"integration failure is failure of a correction or newly supplied constraint to alter subsequent behavior accordingly","standing":"resolved","measurement_alignment":"proxy","unresolved":["maintained implementation does not observe subsequent integration behavior"]}, - "O": {"surface_terms":["Overextension","Overconfidence"],"semantic_definition":"O has conflicting maintained semantic names and therefore has no closed semantic origin yet","standing":"hmmm","measurement_alignment":"conflict","unresolved":["marker canon says Overextension; compute.py says Overconfidence"]}, - "L": {"surface_terms":["Load","Coherence Loss"],"semantic_definition":"L has conflicting maintained semantic names and therefore has no closed semantic origin yet","standing":"hmmm","measurement_alignment":"conflict","unresolved":["marker canon says Load; compute.py says Coherence Loss"]}, - "P": {"surface_terms":["Progress"],"semantic_definition":"progress is newly integrated information or state change that advances resolution relative to the prior state","standing":"resolved","measurement_alignment":"proxy","unresolved":["progress is explicitly implemented as a proxy"]}, - "kappa": {"surface_terms":["Stored Tension"],"semantic_definition":"stored tension is unresolved dissonance carried forward as circuit state","standing":"resolved","measurement_alignment":"proxy","unresolved":["resolution function is currently approximated from dissonance"]} + "C": { + "surface_terms": [ + "Constraint Strain" + ], + "semantic_definition": "constraint strain is pressure produced by contradiction within the measured window", + "standing": "resolved", + "measurement_alignment": "proxy", + "unresolved": [ + "implicit contradiction semantics are not measured by the maintained proxy" + ], + "construction_terms": [ + "constraint", + "strain", + "contradiction", + "pressure" + ] + }, + "R": { + "surface_terms": [ + "Refusal Density" + ], + "semantic_definition": "refusal density is the concentration of refusal relative to active constraint statements", + "standing": "resolved", + "measurement_alignment": "proxy", + "unresolved": [ + "implemented denominator is token-count scale, not counted constraint statements" + ], + "construction_terms": [ + "refusal", + "density", + "refusal", + "constraint" + ] + }, + "F": { + "surface_terms": [ + "Fixation" + ], + "semantic_definition": "fixation is persistence of substantially the same constraint bearing pattern across successive states", + "standing": "resolved", + "measurement_alignment": "proxy", + "unresolved": [ + "maintained implementation is a lexical structural proxy, not embedding similarity" + ], + "construction_terms": [ + "fixation", + "persistence", + "repetition" + ] + }, + "E": { + "surface_terms": [ + "Escalation" + ], + "semantic_definition": "escalation is positive change in commitment or constraint intensity across sequence", + "standing": "resolved", + "measurement_alignment": "proxy", + "unresolved": [ + "maintained implementation does not directly compute commitment-intensity derivative" + ], + "construction_terms": [ + "escalation", + "increase", + "commitment", + "intensity" + ] + }, + "D": { + "surface_terms": [ + "Deflection" + ], + "semantic_definition": "deflection is movement away from the active constraint bearing subject or relation", + "standing": "resolved", + "measurement_alignment": "proxy", + "unresolved": [ + "prior-round lexical overlap substitutes for active-constraint topic tracking" + ], + "construction_terms": [ + "deflection", + "movement", + "away", + "constraint" + ] + }, + "N": { + "surface_terms": [ + "Noise" + ], + "semantic_definition": "noise is activity that consumes representational space without proportionate constraint resolution", + "standing": "resolved", + "measurement_alignment": "proxy", + "unresolved": [ + "maintained implementation measures repetition and entropy rather than resolution ratio" + ], + "construction_terms": [ + "noise", + "repetition", + "without", + "resolution" + ] + }, + "I": { + "surface_terms": [ + "Integration Failure" + ], + "semantic_definition": "integration failure is failure of a correction or newly supplied constraint to alter subsequent behavior accordingly", + "standing": "resolved", + "measurement_alignment": "proxy", + "unresolved": [ + "maintained implementation does not observe subsequent integration behavior" + ], + "construction_terms": [ + "integration", + "failure", + "correction", + "change" + ] + }, + "O": { + "surface_terms": [ + "Overextension", + "Overconfidence" + ], + "semantic_definition": "O has conflicting maintained semantic names and therefore has no closed semantic origin yet", + "standing": "hmmm", + "measurement_alignment": "conflict", + "unresolved": [ + "marker canon says Overextension; compute.py says Overconfidence" + ], + "construction_terms": [] + }, + "L": { + "surface_terms": [ + "Load", + "Coherence Loss" + ], + "semantic_definition": "L has conflicting maintained semantic names and therefore has no closed semantic origin yet", + "standing": "hmmm", + "measurement_alignment": "conflict", + "unresolved": [ + "marker canon says Load; compute.py says Coherence Loss" + ], + "construction_terms": [] + }, + "P": { + "surface_terms": [ + "Progress" + ], + "semantic_definition": "progress is newly integrated information or state change that advances resolution relative to the prior state", + "standing": "resolved", + "measurement_alignment": "proxy", + "unresolved": [ + "progress is explicitly implemented as a proxy" + ], + "construction_terms": [ + "progress", + "novelty", + "change", + "resolution" + ] + }, + "kappa": { + "surface_terms": [ + "Stored Tension" + ], + "semantic_definition": "stored tension is unresolved dissonance carried forward as circuit state", + "standing": "resolved", + "measurement_alignment": "proxy", + "unresolved": [ + "resolution function is currently approximated from dissonance" + ], + "construction_terms": [ + "stored", + "tension", + "unresolved", + "dissonance" + ] + } } } From 9c6bb8718fad180e373fd072d1a041cce2aeb8f9 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:35:39 -0700 Subject: [PATCH 11/40] fix(stack): verify construct identity and bind full origin receipts --- .../english_gonol/edcm_metric_origins.py | 173 +++++++++++++----- 1 file changed, 123 insertions(+), 50 deletions(-) diff --git a/research/english-gonol/english_gonol/edcm_metric_origins.py b/research/english-gonol/english_gonol/edcm_metric_origins.py index 152e8973..ea203494 100644 --- a/research/english-gonol/english_gonol/edcm_metric_origins.py +++ b/research/english-gonol/english_gonol/edcm_metric_origins.py @@ -1,18 +1,18 @@ -"""Construct EDCM metric words as English hyperspace origin sets. +"""Construct EDCM metric descriptions as English hyperspace origin sets. -Usage: load_metric_origin_specs(), then build_metric_origin_set(state_dir, id, -construct_receipt=...). Only EDCM semantic-definition words enter the origin. -Declared/implemented measurement rules stay outside the semantic construction. +Only EDCM-owned construction terms enter the semantic origin. Measurement rules +and observed evidence stay outside it. Resolved origins require the exact pinned +English v2 construct receipt; unresolved EDCM semantics remain unclosed hmmm. """ # === MODULE_BUILD === # id: english_edcm_metric_origin_sets_v0 # module_name: english_gonol.edcm_metric_origins # module_kind: constructor -# summary: constructs ordered English hyperspace origin sets from EDCM-owned semantic metric descriptions +# summary: constructs ordered English hyperspace origin sets from EDCM-owned exact construction terms # owner: Stack English Gonol Construction # public_surface: MetricOriginSet, OriginComponent, load_metric_origin_specs, build_metric_origin_set -# internal_surface: exact-run admission and deterministic receipt +# internal_surface: verified construct identity, exact-run admission, deterministic receipt # auth_boundary: none # storage_boundary: read # network_boundary: none @@ -21,9 +21,9 @@ # tests: research/english-gonol/tests/test_edcm_metric_origins.py # rollout: stack-local research candidate # rollback: remove module fixture and tests; EDCM source specs remain unchanged -# requires: english_gonol_language_hyperspace, edcm metric-origin spec fixture +# requires: english_gonol_language_hyperspace, english_gonol_full_construct, edcm metric-origin spec fixture # since: 2026-10-03 -# unresolved: O and L source semantics conflict; full-corpus closure requires the generated construct.db +# unresolved: O and L source semantics conflict; lawful observed-state projection to these origins remains hmmm # === END MODULE_BUILD === # === CONTRACTS === @@ -33,14 +33,19 @@ # class: boundary_contract # # id: metric_origin_preserves_order_identity_provenance -# given: a resolved metric description is admitted by the English construct -# then: exact ordered word and whitespace-glyph axes plus producer and construct identities survive in the receipt +# given: a resolved metric description is admitted by the verified English construct +# then: exact ordered word and whitespace-glyph axes plus producer and verified construct identities survive in the receipt # class: correctness # # id: metric_origin_unresolved_fails_open_as_hmmm_not_closed # given: the EDCM source spec is hmmm # then: no semantic components are constructed and closed is false # class: safety +# +# id: metric_origin_receipt_binds_schema +# given: any metric-origin record is emitted +# then: receipt identity covers schema version and every serialized field except the receipt itself +# class: identity_contract # === END CONTRACTS === from __future__ import annotations @@ -50,16 +55,25 @@ from pathlib import Path import sqlite3 -from .full_construct_run import _definition_runs -from .hyperspace_construct import glyph_inventory, promote_glyph, promote_word +from .full_construct_run import _assert_schema_boundary, _definition_runs, _logical_receipt +from .hyperspace_construct import ( + V2_MANIFEST_RECEIPT, + glyph_inventory, + promote_glyph, + promote_word, +) SCHEMA = "english-gonol.edcm-metric-origin-set" -VERSION = "0.1.0" +VERSION = "0.2.0" FIXTURE = Path(__file__).resolve().parents[1] / "EDCM_METRIC_ORIGINS_SOURCE.json" + def _canonical(value: object) -> bytes: - return json.dumps(value, sort_keys=True, ensure_ascii=False, - separators=(",", ":"), allow_nan=False).encode("utf-8") + return json.dumps( + value, sort_keys=True, ensure_ascii=False, + separators=(",", ":"), allow_nan=False, + ).encode("utf-8") + @dataclass(frozen=True, slots=True) class OriginComponent: @@ -70,6 +84,7 @@ class OriginComponent: axis_index: int | None identity: str + @dataclass(frozen=True, slots=True) class MetricOriginSet: metric_id: str @@ -82,9 +97,10 @@ class MetricOriginSet: unresolved: tuple[str, ...] receipt_sha256: str - def to_dict(self) -> dict[str, object]: + def _payload(self) -> dict[str, object]: return { - "schema": SCHEMA, "version": VERSION, + "schema": SCHEMA, + "version": VERSION, "metric_id": self.metric_id, "producer_repository": self.producer_repository, "producer_commit": self.producer_commit, @@ -93,23 +109,51 @@ def to_dict(self) -> dict[str, object]: "components": [asdict(x) for x in self.components], "closed": self.closed, "unresolved": list(self.unresolved), - "receipt_sha256": self.receipt_sha256, } + def to_dict(self) -> dict[str, object]: + return {**self._payload(), "receipt_sha256": self.receipt_sha256} + + def load_metric_origin_specs(path: Path = FIXTURE) -> dict[str, object]: data = json.loads(Path(path).read_text(encoding="utf-8")) - if data.get("schema") != "edcm.metric-origin-spec-fixture" or data.get("version") != "0.2.0": + if ( + data.get("schema") != "edcm.metric-origin-spec-fixture" + or data.get("version") != "0.3.0" + ): raise ValueError("unsupported EDCM metric-origin fixture") return data -def _receipt(payload: dict[str, object]) -> str: - return sha256(_canonical(payload)).hexdigest() + +def _emit( + common: dict[str, object], + *, + components: tuple[OriginComponent, ...], + closed: bool, + unresolved: tuple[str, ...], +) -> MetricOriginSet: + payload = { + "schema": SCHEMA, + "version": VERSION, + **common, + "components": [asdict(x) for x in components], + "closed": closed, + "unresolved": list(unresolved), + } + receipt = sha256(_canonical(payload)).hexdigest() + return MetricOriginSet( + **common, + components=components, + closed=closed, + unresolved=unresolved, + receipt_sha256=receipt, + ) + def build_metric_origin_set( state_dir: Path, metric_id: str, *, - construct_receipt: str, fixture_path: Path = FIXTURE, ) -> MetricOriginSet: source = load_metric_origin_specs(fixture_path) @@ -117,53 +161,82 @@ def build_metric_origin_set( if metric_id not in specs: raise KeyError(f"unknown metric origin {metric_id!r}") spec = specs[metric_id] - text = " ".join((*spec["surface_terms"], spec["semantic_definition"])) unresolved = tuple(spec.get("unresolved", ())) - common = { - "metric_id": metric_id, - "producer_repository": source["producer_repository"], - "producer_commit": source["producer_commit"], - "construct_receipt": construct_receipt, - "source_text": text, - } + terms = tuple(spec.get("construction_terms", ())) + source_text = " ".join(terms) + if spec["standing"] != "resolved": - payload = {**common, "components": [], "closed": False, "unresolved": list(unresolved)} - return MetricOriginSet(**common, components=(), closed=False, unresolved=unresolved, - receipt_sha256=_receipt(payload)) + common = { + "metric_id": metric_id, + "producer_repository": source["producer_repository"], + "producer_commit": source["producer_commit"], + "construct_receipt": "hmmm", + "source_text": source_text, + } + return _emit(common, components=(), closed=False, unresolved=unresolved) + + if not terms or any(not isinstance(term, str) or not term for term in terms): + raise ValueError(f"metric {metric_id}: resolved origin requires exact construction terms") db_path = Path(state_dir) / "construct.db" if not db_path.exists(): raise ValueError(f"construct.db not found under {state_dir}") db = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True) try: + _assert_schema_boundary(db) + observed_receipt = _logical_receipt(db) + if observed_receipt != V2_MANIFEST_RECEIPT: + raise ValueError( + f"metric {metric_id}: construct receipt mismatch; " + f"expected {V2_MANIFEST_RECEIPT}, got {observed_receipt}" + ) inventory = glyph_inventory(db) - components = [] - for ordinal, (kind, surface, _start, _end) in enumerate(_definition_runs(text)): + components: list[OriginComponent] = [] + for ordinal, (kind, surface, _start, _end) in enumerate(_definition_runs(source_text)): if kind == "word": - row = db.execute("SELECT id FROM words WHERE surface = ?", (surface,)).fetchone() + row = db.execute( + "SELECT id FROM words WHERE surface = ?", (surface,) + ).fetchone() if row is None: - raise ValueError(f"metric {metric_id}: unadmitted word surface {surface!r}") + raise ValueError( + f"metric {metric_id}: unadmitted exact word surface {surface!r}" + ) word, axis = promote_word(db, row[0]) - components.append(OriginComponent( - ordinal, "word", surface, "O_W", axis, f"word:{word.word_id}" - )) + components.append( + OriginComponent( + ordinal, "word", surface, "O_W", axis, f"word:{word.word_id}" + ) + ) else: glyph, axis = promote_glyph(db, inventory, surface) - components.append(OriginComponent( - ordinal, "glyph", surface, "O_G", axis, f"glyph:{glyph.identity}" - )) + components.append( + OriginComponent( + ordinal, "glyph", surface, "O_G", axis, f"glyph:{glyph.identity}" + ) + ) finally: db.close() - payload = {**common, "components": [asdict(x) for x in components], - "closed": True, "unresolved": list(unresolved)} - return MetricOriginSet( - **common, + common = { + "metric_id": metric_id, + "producer_repository": source["producer_repository"], + "producer_commit": source["producer_commit"], + "construct_receipt": observed_receipt, + "source_text": source_text, + } + return _emit( + common, components=tuple(components), closed=True, unresolved=unresolved, - receipt_sha256=_receipt(payload), ) -__all__ = ["SCHEMA","VERSION","OriginComponent","MetricOriginSet", - "load_metric_origin_specs","build_metric_origin_set"] + +__all__ = [ + "SCHEMA", + "VERSION", + "OriginComponent", + "MetricOriginSet", + "load_metric_origin_specs", + "build_metric_origin_set", +] From 75d196f0e80db5b57b8983c3c21afa8cd9606c7c Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:35:59 -0700 Subject: [PATCH 12/40] test(stack): verify metric-origin identity and receipts --- .../tests/test_edcm_metric_origins.py | 85 +++++++++++++++---- 1 file changed, 70 insertions(+), 15 deletions(-) diff --git a/research/english-gonol/tests/test_edcm_metric_origins.py b/research/english-gonol/tests/test_edcm_metric_origins.py index 5993506d..351de88c 100644 --- a/research/english-gonol/tests/test_edcm_metric_origins.py +++ b/research/english-gonol/tests/test_edcm_metric_origins.py @@ -15,6 +15,14 @@ # mutates: temporary sqlite fixture # cleanup: pytest tmp_path # +# id: check_metric_origin_construct_identity +# proves: metric_origin_preserves_order_identity_provenance +# call: self::test_wrong_construct_receipt_fails_closed +# requires: python3 +# timeout: 10 +# mutates: temporary sqlite fixture +# cleanup: pytest tmp_path +# # id: check_metric_origin_hmmm # proves: metric_origin_unresolved_fails_open_as_hmmm_not_closed # call: self::test_unresolved_origin_does_not_construct_components @@ -22,20 +30,35 @@ # timeout: 10 # mutates: none # cleanup: none +# +# id: check_metric_origin_receipt_schema +# proves: metric_origin_receipt_binds_schema +# call: self::test_receipt_hashes_complete_payload_except_receipt +# requires: python3 +# timeout: 10 +# mutates: temporary sqlite fixture +# cleanup: pytest tmp_path # === END CHECKS === +from hashlib import sha256 import json import sqlite3 from pathlib import Path -from english_gonol.edcm_metric_origins import build_metric_origin_set +import pytest + +import english_gonol.edcm_metric_origins as origins +from english_gonol.hyperspace_construct import V2_MANIFEST_RECEIPT + def _fixture(tmp_path: Path, metric="F", standing="resolved"): source = { - "schema":"edcm.metric-origin-spec-fixture","version":"0.2.0", + "schema":"edcm.metric-origin-spec-fixture","version":"0.3.0", "producer_repository":"The-Interdependency/edcm","producer_commit":"a"*40, "specs":{metric:{ - "surface_terms":["Fixation"],"semantic_definition":"is persistence across states", + "surface_terms":["Fixation"], + "construction_terms":["fixation","persistence","repetition"], + "semantic_definition":"fixation is persistence across states", "standing":standing,"measurement_alignment":"proxy", "unresolved":["proxy gap"] if standing=="resolved" else ["collision"]}} } @@ -43,6 +66,7 @@ def _fixture(tmp_path: Path, metric="F", standing="resolved"): path.write_text(json.dumps(source),encoding="utf-8") return path + def _db(tmp_path: Path): db=sqlite3.connect(tmp_path/"construct.db") db.executescript(""" @@ -52,7 +76,7 @@ def _db(tmp_path: Path): """) chars={} next_id=1 - words=["Fixation","is","persistence","across","states"] + words=["fixation","persistence","repetition"] for surface in words: for ch in surface+" ": if ch not in chars: @@ -65,29 +89,60 @@ def _db(tmp_path: Path): db.execute("INSERT INTO word_characters VALUES (?,?,?)",(wid,ordinal,chars[ch])) db.commit(); db.close() -def test_resolved_origin_uses_word_and_glyph_axes_in_order(tmp_path): - _db(tmp_path) - record=build_metric_origin_set(tmp_path,"F",construct_receipt="r"*64, - fixture_path=_fixture(tmp_path)) + +def _verified(monkeypatch): + monkeypatch.setattr(origins, "_assert_schema_boundary", lambda _db: None) + monkeypatch.setattr(origins, "_logical_receipt", lambda _db: V2_MANIFEST_RECEIPT) + + +def test_resolved_origin_uses_word_and_glyph_axes_in_order(tmp_path, monkeypatch): + _db(tmp_path); _verified(monkeypatch) + record=origins.build_metric_origin_set(tmp_path,"F",fixture_path=_fixture(tmp_path)) assert record.closed + assert record.construct_receipt==V2_MANIFEST_RECEIPT + assert record.source_text=="fixation persistence repetition" assert record.components[0].axis_origin=="O_W" assert any(x.axis_origin=="O_G" and x.surface==" " for x in record.components) assert record.producer_repository=="The-Interdependency/edcm" assert "proxy gap" in record.unresolved -def test_origin_record_contains_no_measurement_value(tmp_path): - _db(tmp_path) - record=build_metric_origin_set(tmp_path,"F",construct_receipt="r"*64, - fixture_path=_fixture(tmp_path)) + +def test_origin_record_contains_no_measurement_value(tmp_path, monkeypatch): + _db(tmp_path); _verified(monkeypatch) + record=origins.build_metric_origin_set(tmp_path,"F",fixture_path=_fixture(tmp_path)) keys=record.to_dict() assert "value" not in keys assert "measurement" not in keys assert "score" not in keys - assert "implemented_rule" not in record.source_text + assert record.source_text=="fixation persistence repetition" + + +def test_wrong_construct_receipt_fails_closed(tmp_path, monkeypatch): + _db(tmp_path) + monkeypatch.setattr(origins, "_assert_schema_boundary", lambda _db: None) + monkeypatch.setattr(origins, "_logical_receipt", lambda _db: "0"*64) + with pytest.raises(ValueError,match="construct receipt mismatch"): + origins.build_metric_origin_set(tmp_path,"F",fixture_path=_fixture(tmp_path)) + def test_unresolved_origin_does_not_construct_components(tmp_path): - record=build_metric_origin_set(tmp_path,"F",construct_receipt="r"*64, - fixture_path=_fixture(tmp_path,standing="hmmm")) + record=origins.build_metric_origin_set( + tmp_path,"F",fixture_path=_fixture(tmp_path,standing="hmmm") + ) assert record.closed is False assert record.components==() + assert record.construct_receipt=="hmmm" assert record.unresolved==("collision",) + + +def test_receipt_hashes_complete_payload_except_receipt(tmp_path, monkeypatch): + _db(tmp_path); _verified(monkeypatch) + record=origins.build_metric_origin_set(tmp_path,"F",fixture_path=_fixture(tmp_path)) + payload=record.to_dict() + receipt=payload.pop("receipt_sha256") + expected=sha256(json.dumps( + payload,sort_keys=True,ensure_ascii=False,separators=(",",":"),allow_nan=False + ).encode("utf-8")).hexdigest() + assert receipt==expected + assert payload["schema"]==origins.SCHEMA + assert payload["version"]==origins.VERSION From 7c35d6c99c77fc6c07c446574154e63606f4e90c Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:36:09 -0700 Subject: [PATCH 13/40] docs(stack): bind EDCM metric-origin producer in English base --- research/english-gonol/BASE.json | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/research/english-gonol/BASE.json b/research/english-gonol/BASE.json index 33475775..db898edd 100644 --- a/research/english-gonol/BASE.json +++ b/research/english-gonol/BASE.json @@ -18,5 +18,11 @@ "protocol": "FULL_VIEW_AUDIT.json", "work_graph": "../../stack-manifest.json#research_participants[workspace=research/english-gonol/]", "authority_transfer": false + }, + "metric_origin_source": { + "repository": "The-Interdependency/edcm", + "commit": "7dd93e3fc19f82300e3ffbb83ffc64e641ea6cd4", + "relation": "exact EDCM semantic metric-origin producer; does not refresh the historical extraction source or libs/edcm pin", + "authority_transfer": false } } From b0974230d662dbd2b8908f96ec4bc421604c8cbc Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:36:33 -0700 Subject: [PATCH 14/40] docs(stack): register EDCM metric-origin research source --- stack-manifest.json | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/stack-manifest.json b/stack-manifest.json index 3f6f7fb6..1fda29c4 100644 --- a/stack-manifest.json +++ b/stack-manifest.json @@ -1,7 +1,7 @@ { "schema": "the-interdependency.stack-manifest", "version": "1.1.0", - "work_graph_sha256": "7384687cde8e9d18a1019fecd62adbaa6278930bb556546db05062ef4a348f0b", + "work_graph_sha256": "a57c9bb44d76dddfd4d806f3db3e53b4eb6048b1eb7981215ebc4f219662a788", "repositories": [ { "repository": "The-Interdependency/skill-lib", @@ -330,6 +330,16 @@ "relation": "exact installed wheel consumer via research/zfae/UCHC_INPUT.json; no fixed-width semantic projection or neural readiness promotion", "canonical_release": false, "authority_transfer": false + }, + { + "workspace": "research/english-gonol/", + "participant_id": "edcm-metric-origin-source", + "repository": "The-Interdependency/edcm", + "commit": "7dd93e3fc19f82300e3ffbb83ffc64e641ea6cd4", + "authority": "EDCM semantic metric-origin definitions and measurement-rule alignment", + "relation": "exact semantic-origin producer consumed by Stack English; does not refresh libs/edcm or transfer measurement authority", + "canonical_release": false, + "authority_transfer": false } ] } From 20daed7f29d90fa14a01a8f4ba7bc32a78895152 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:36:44 -0700 Subject: [PATCH 15/40] docs(stack): project metric-origin source into manifest --- STACK_MANIFEST.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/STACK_MANIFEST.md b/STACK_MANIFEST.md index 40fbd92b..19bf972a 100644 --- a/STACK_MANIFEST.md +++ b/STACK_MANIFEST.md @@ -17,7 +17,7 @@ Provenance and authority-boundary record for `The-Interdependency/stack`. - English four-view complete-corpus audit UTC: `2026-09-22`, exact view source `1f9a35eb355296fc88d09784c7a3e2e95511ca31`; all 164,864 words, native and independent agreement. - Stack-manifest schema: `the-interdependency.stack-manifest` version `1.1.0` - Work-graph digest (SHA-256 over canonical `repositories` + `research_participants` + `boundaries` JSON): - `7384687cde8e9d18a1019fecd62adbaa6278930bb556546db05062ef4a348f0b` + `a57c9bb44d76dddfd4d806f3db3e53b4eb6048b1eb7981215ebc4f219662a788` - Weave workspace creation UTC: `2026-09-28`; new specification-first research starts from the intended multi-arity interleaving mechanism without URPCS inheritance - Machine-readable copy: [`stack-manifest.json`](stack-manifest.json) @@ -65,6 +65,7 @@ release identity. | `research/urpcs/` | `The-Interdependency/stack` | `a428a41a38a8b30bacb7025a4d54070b228a8089` | retired substituted-codec historical evidence only; no active URPCS authority or evidence transfer | no | | `research/weave/` | `The-Interdependency/stack` | `1ba201449731337dc20c564788f4303c8910bfdd` | full gonol/private-key/thread/corpus/interleave/asymmetric construction research; native derivation unresolved; no URPCS implementation inheritance or security standing | no | | `research/english-gonol/` | `The-Interdependency/stack` | `99b3598b02a6e683b3c84184d8ea443b12fc0e1a` | stack-local English lexical/gonol construction separated from EDCM; full pinned-corpus v2 build/replay survived; consumes UCNS geometry; EDCM may evaluate outputs but does not define construction | no | +| `research/english-gonol/` | `The-Interdependency/edcm` | `7dd93e3fc19f82300e3ffbb83ffc64e641ea6cd4` | exact EDCM semantic metric-origin producer; supplies metric definitions and proxy-alignment metadata without refreshing `libs/edcm` or transferring measurement authority | no | | `research/python-gonol/` | `The-Interdependency/stack` | `0e8384bbb60e4c2189016a212bdd0030d04aed7d` | stack-local bottom-up Python 3.12 source gonol construction; applies METAPAT affixiation semantics, consumes optional UCNS geometry, and transfers no language authority to UCNS or EDCM | no | | `research/ucns/` | `The-Interdependency/ucns` | `1975fe70cf4e0826a8020c2da3047569e277af64` | explicit source base for integrated stack-local UCNS research; does not refresh or replace the manifest-pinned `libs/ucns` canonical view | no | | `research/from-photons-to-macroverse/` | `The-Interdependency/stack` | `77ef8c7fb0ff75a524181655ee9f9641372768f7` | target composition forge baseline at audit start | no | From 9d4109e6003a5f54a2d95fd042d11c605b0bd292 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:37:30 -0700 Subject: [PATCH 16/40] docs: refresh verified metric-origin work graph --- .../work-graphs/metric-origin-space-v0.json | 50 +++++++++++++------ 1 file changed, 35 insertions(+), 15 deletions(-) diff --git a/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json b/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json index 615f3173..0ba6dd26 100644 --- a/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json +++ b/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json @@ -1,20 +1,40 @@ { - "schema":"the-interdependency.stack-manifest", - "version":"1.0.0", - "work_graph_sha256":"32b3736512da9fe023f0ee42b75d34d12a18f182bb16785598116adb76ee1242", - "repositories":[ - {"repository":"The-Interdependency/edcm","commit":"0d6ea9ad1531b607d6df35175ed86686dcbdb58f","authority":"metric definitions, scalar measurement, and evidence/readout contracts","relation":"defines metric-origin source words and binds scalar readouts to Stack origin receipts"}, - {"repository":"The-Interdependency/stack","commit":"e653d7f02f8b52eae96bf290e57d615f322ff069","authority":"current English Gonol semantic construction","relation":"constructs EDCM semantic-definition words as ordered O_W/O_G metric origin sets"}, - {"repository":"The-Interdependency/metapat","commit":"1cdfb09dd00a451cee30eec2e78624df8c682662","authority":"cross-domain semantic constraints","relation":"constrains semantic transfer; no metric validity transfer"}, - {"repository":"The-Interdependency/ucns","commit":"1975fe70cf4e0826a8020c2da3047569e277af64","authority":"gonol geometry consumed by Stack English construction","relation":"underlying geometry only; no metric semantics or measurement validity"} + "schema": "the-interdependency.stack-manifest", + "version": "1.0.0", + "work_graph_sha256": "c0397219cf465ff2a9fb29e667d2c80ce0e259d9fcd0eda731693ad390871b1d", + "repositories": [ + { + "repository": "The-Interdependency/edcm", + "commit": "8f40ad6cd7a436d6223a623544285aff1b73eccb", + "authority": "metric definitions, scalar measurement, and evidence/readout contracts", + "relation": "defines source-owned construction terms and binds scalar readouts to Stack origin receipts" + }, + { + "repository": "The-Interdependency/stack", + "commit": "20daed7f29d90fa14a01a8f4ba7bc32a78895152", + "authority": "current English Gonol semantic construction", + "relation": "constructs exact EDCM construction terms as verified O_W/O_G metric origin sets" + }, + { + "repository": "The-Interdependency/metapat", + "commit": "1cdfb09dd00a451cee30eec2e78624df8c682662", + "authority": "cross-domain semantic constraints", + "relation": "constrains semantic transfer; no metric validity transfer" + }, + { + "repository": "The-Interdependency/ucns", + "commit": "1975fe70cf4e0826a8020c2da3047569e277af64", + "authority": "gonol geometry consumed by Stack English construction", + "relation": "underlying geometry only; no metric semantics or measurement validity" + } ], - "boundaries":{ - "authority_transfer":false, - "proof_status_transfer":false, - "measurement_status_transfer":false, - "semantic_mapping":"declared mapping", - "agent_scope":"cross-repository-work-graph", - "hmmm":[ + "boundaries": { + "authority_transfer": false, + "proof_status_transfer": false, + "measurement_status_transfer": false, + "semantic_mapping": "declared mapping", + "agent_scope": "cross-repository-work-graph", + "hmmm": [ "O semantic origin conflicts: Overextension versus Overconfidence", "L semantic origin conflicts: Load versus Coherence Loss", "lawful observed-construct to metric-origin projection/distance is unresolved", From a17bd6fb0313798baf18fcd998bfb9bdcea67fbd Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:38:31 -0700 Subject: [PATCH 17/40] feat(stack): name each metric semantic origin explicitly From dadeed9963082832d5537b48aa854105d3f0a597 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:38:40 -0700 Subject: [PATCH 18/40] test(stack): bind explicit metric origin identity From ce1f77970af1a7101dd66ab2fae72397d3052db2 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:40:54 -0700 Subject: [PATCH 19/40] data(stack): repin admitted metric-origin source terms --- research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json b/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json index 1dd7f6f9..6c1c12b6 100644 --- a/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json +++ b/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json @@ -2,7 +2,7 @@ "schema": "edcm.metric-origin-spec-fixture", "version": "0.3.0", "producer_repository": "The-Interdependency/edcm", - "producer_commit": "7dd93e3fc19f82300e3ffbb83ffc64e641ea6cd4", + "producer_commit": "57e2c32196568b4bbde61a80001906eb735ac830", "specs": { "C": { "surface_terms": [ @@ -179,7 +179,7 @@ "stored", "tension", "unresolved", - "dissonance" + "conflict" ] } } From 1aab1ab5dd84a1ff0e3194330c58d85b066f0c03 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:41:01 -0700 Subject: [PATCH 20/40] docs(stack): repin metric-origin producer --- research/english-gonol/BASE.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/research/english-gonol/BASE.json b/research/english-gonol/BASE.json index db898edd..55984120 100644 --- a/research/english-gonol/BASE.json +++ b/research/english-gonol/BASE.json @@ -21,7 +21,7 @@ }, "metric_origin_source": { "repository": "The-Interdependency/edcm", - "commit": "7dd93e3fc19f82300e3ffbb83ffc64e641ea6cd4", + "commit": "57e2c32196568b4bbde61a80001906eb735ac830", "relation": "exact EDCM semantic metric-origin producer; does not refresh the historical extraction source or libs/edcm pin", "authority_transfer": false } From 6a3cf6c4e2703181277b464662ac7d47715e4898 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:41:13 -0700 Subject: [PATCH 21/40] docs(stack): repin metric-origin participant --- stack-manifest.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/stack-manifest.json b/stack-manifest.json index 1fda29c4..b6eed1d1 100644 --- a/stack-manifest.json +++ b/stack-manifest.json @@ -1,7 +1,7 @@ { "schema": "the-interdependency.stack-manifest", "version": "1.1.0", - "work_graph_sha256": "a57c9bb44d76dddfd4d806f3db3e53b4eb6048b1eb7981215ebc4f219662a788", + "work_graph_sha256": "306da7cba2d38df0387d7f6778c88138c223b4e66ed9818feb42a4e8a8832fcf", "repositories": [ { "repository": "The-Interdependency/skill-lib", @@ -335,7 +335,7 @@ "workspace": "research/english-gonol/", "participant_id": "edcm-metric-origin-source", "repository": "The-Interdependency/edcm", - "commit": "7dd93e3fc19f82300e3ffbb83ffc64e641ea6cd4", + "commit": "57e2c32196568b4bbde61a80001906eb735ac830", "authority": "EDCM semantic metric-origin definitions and measurement-rule alignment", "relation": "exact semantic-origin producer consumed by Stack English; does not refresh libs/edcm or transfer measurement authority", "canonical_release": false, From 388be0c47cf502341b507f14c1ab6ddf00222e36 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:41:23 -0700 Subject: [PATCH 22/40] docs(stack): refresh metric-origin manifest projection --- STACK_MANIFEST.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/STACK_MANIFEST.md b/STACK_MANIFEST.md index 19bf972a..66927f69 100644 --- a/STACK_MANIFEST.md +++ b/STACK_MANIFEST.md @@ -17,7 +17,7 @@ Provenance and authority-boundary record for `The-Interdependency/stack`. - English four-view complete-corpus audit UTC: `2026-09-22`, exact view source `1f9a35eb355296fc88d09784c7a3e2e95511ca31`; all 164,864 words, native and independent agreement. - Stack-manifest schema: `the-interdependency.stack-manifest` version `1.1.0` - Work-graph digest (SHA-256 over canonical `repositories` + `research_participants` + `boundaries` JSON): - `a57c9bb44d76dddfd4d806f3db3e53b4eb6048b1eb7981215ebc4f219662a788` + `306da7cba2d38df0387d7f6778c88138c223b4e66ed9818feb42a4e8a8832fcf` - Weave workspace creation UTC: `2026-09-28`; new specification-first research starts from the intended multi-arity interleaving mechanism without URPCS inheritance - Machine-readable copy: [`stack-manifest.json`](stack-manifest.json) @@ -65,7 +65,7 @@ release identity. | `research/urpcs/` | `The-Interdependency/stack` | `a428a41a38a8b30bacb7025a4d54070b228a8089` | retired substituted-codec historical evidence only; no active URPCS authority or evidence transfer | no | | `research/weave/` | `The-Interdependency/stack` | `1ba201449731337dc20c564788f4303c8910bfdd` | full gonol/private-key/thread/corpus/interleave/asymmetric construction research; native derivation unresolved; no URPCS implementation inheritance or security standing | no | | `research/english-gonol/` | `The-Interdependency/stack` | `99b3598b02a6e683b3c84184d8ea443b12fc0e1a` | stack-local English lexical/gonol construction separated from EDCM; full pinned-corpus v2 build/replay survived; consumes UCNS geometry; EDCM may evaluate outputs but does not define construction | no | -| `research/english-gonol/` | `The-Interdependency/edcm` | `7dd93e3fc19f82300e3ffbb83ffc64e641ea6cd4` | exact EDCM semantic metric-origin producer; supplies metric definitions and proxy-alignment metadata without refreshing `libs/edcm` or transferring measurement authority | no | +| `research/english-gonol/` | `The-Interdependency/edcm` | `57e2c32196568b4bbde61a80001906eb735ac830` | exact EDCM semantic metric-origin producer; supplies metric definitions and proxy-alignment metadata without refreshing `libs/edcm` or transferring measurement authority | no | | `research/python-gonol/` | `The-Interdependency/stack` | `0e8384bbb60e4c2189016a212bdd0030d04aed7d` | stack-local bottom-up Python 3.12 source gonol construction; applies METAPAT affixiation semantics, consumes optional UCNS geometry, and transfers no language authority to UCNS or EDCM | no | | `research/ucns/` | `The-Interdependency/ucns` | `1975fe70cf4e0826a8020c2da3047569e277af64` | explicit source base for integrated stack-local UCNS research; does not refresh or replace the manifest-pinned `libs/ucns` canonical view | no | | `research/from-photons-to-macroverse/` | `The-Interdependency/stack` | `77ef8c7fb0ff75a524181655ee9f9641372768f7` | target composition forge baseline at audit start | no | From 90fd7750d4fe763e3ff5730f8e3fd0968ae9afb2 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:42:03 -0700 Subject: [PATCH 23/40] ci(stack): verify metric terms against pinned OEWN --- .github/workflows/english-gonol.yml | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/.github/workflows/english-gonol.yml b/.github/workflows/english-gonol.yml index 2335b2ed..4b4e5398 100644 --- a/.github/workflows/english-gonol.yml +++ b/.github/workflows/english-gonol.yml @@ -45,6 +45,14 @@ jobs: path: _deps/ucns-relational persist-credentials: false + - name: Checkout pinned OEWN 2025 source + uses: actions/checkout@v7.0.1 + with: + repository: globalwordnet/english-wordnet + ref: dc343f2683279ecbb13fab4e2fd778d7b162d287 + path: _deps/oewn + persist-credentials: false + - name: Set up Python uses: actions/setup-python@v7.0.0 with: From f665879d82ba8c94f3bc01a8f067fc6a46132155 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:42:12 -0700 Subject: [PATCH 24/40] contract(stack): require pinned-corpus metric term admission --- research/english-gonol/english_gonol/edcm_metric_origins.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/research/english-gonol/english_gonol/edcm_metric_origins.py b/research/english-gonol/english_gonol/edcm_metric_origins.py index ea203494..7bb49c29 100644 --- a/research/english-gonol/english_gonol/edcm_metric_origins.py +++ b/research/english-gonol/english_gonol/edcm_metric_origins.py @@ -46,6 +46,11 @@ # given: any metric-origin record is emitted # then: receipt identity covers schema version and every serialized field except the receipt itself # class: identity_contract +# +# id: metric_origin_terms_admitted_by_pinned_corpus +# given: resolved EDCM construction terms are compared with the exact pinned OEWN 2025 source +# then: every term is an exact admitted word surface before an origin is licensed +# class: provenance_contract # === END CONTRACTS === from __future__ import annotations From a29af39db7ef282589d1ec60a19702c3e6cbcdcc Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:42:24 -0700 Subject: [PATCH 25/40] test(stack): prove metric terms admitted by pinned OEWN --- .../tests/test_edcm_metric_origins.py | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/research/english-gonol/tests/test_edcm_metric_origins.py b/research/english-gonol/tests/test_edcm_metric_origins.py index 351de88c..5c1dface 100644 --- a/research/english-gonol/tests/test_edcm_metric_origins.py +++ b/research/english-gonol/tests/test_edcm_metric_origins.py @@ -38,6 +38,13 @@ # timeout: 10 # mutates: temporary sqlite fixture # cleanup: pytest tmp_path +# id: check_metric_origin_pinned_corpus_admission +# proves: metric_origin_terms_admitted_by_pinned_corpus +# call: self::test_all_resolved_terms_are_admitted_by_pinned_oewn +# requires: python3, PyYAML, exact OEWN 2025 source +# timeout: 60 +# mutates: none +# cleanup: none # === END CHECKS === from hashlib import sha256 @@ -146,3 +153,21 @@ def test_receipt_hashes_complete_payload_except_receipt(tmp_path, monkeypatch): assert receipt==expected assert payload["schema"]==origins.SCHEMA assert payload["version"]==origins.VERSION + + +def test_all_resolved_terms_are_admitted_by_pinned_oewn(): + root=os.environ.get("OEWN_SOURCE_ROOT") + if not root: + pytest.skip("exact OEWN source not present; authoritative CI supplies it") + snapshot=load_oewn_2025(Path(root)) + words,_characters=_collect_surfaces(snapshot) + admitted=set(words) + fixture=origins.load_metric_origin_specs() + missing={} + for metric,spec in fixture["specs"].items(): + if spec["standing"]!="resolved": + continue + absent=[term for term in spec["construction_terms"] if term not in admitted] + if absent: + missing[metric]=absent + assert missing=={} From ba801ae4f5fe74c4ef2b756b9338e43189b4b9a8 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:42:36 -0700 Subject: [PATCH 26/40] chore(stack): let pinned corpus admission test finish naturally From b625d5d88612160ebdc431ca5878f2dc9afd8e68 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:45:36 -0700 Subject: [PATCH 27/40] fix(stack): import environment for OEWN admission gate --- research/english-gonol/tests/test_edcm_metric_origins.py | 1 + 1 file changed, 1 insertion(+) diff --git a/research/english-gonol/tests/test_edcm_metric_origins.py b/research/english-gonol/tests/test_edcm_metric_origins.py index 5c1dface..3dad6343 100644 --- a/research/english-gonol/tests/test_edcm_metric_origins.py +++ b/research/english-gonol/tests/test_edcm_metric_origins.py @@ -49,6 +49,7 @@ from hashlib import sha256 import json +import os import sqlite3 from pathlib import Path From 410d21eb4fcca1802889381bad160b5b28658e17 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:46:34 -0700 Subject: [PATCH 28/40] ci(stack): replay exact EDCM metric-origin producer --- .github/workflows/english-gonol.yml | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/.github/workflows/english-gonol.yml b/.github/workflows/english-gonol.yml index 4b4e5398..ffaf12ea 100644 --- a/.github/workflows/english-gonol.yml +++ b/.github/workflows/english-gonol.yml @@ -53,6 +53,14 @@ jobs: path: _deps/oewn persist-credentials: false + - name: Checkout pinned EDCM metric-origin producer + uses: actions/checkout@v7.0.1 + with: + repository: The-Interdependency/edcm + ref: 57e2c32196568b4bbde61a80001906eb735ac830 + path: _deps/edcm-metric-origin + persist-credentials: false + - name: Set up Python uses: actions/setup-python@v7.0.0 with: From 7cb40ff3b3a2f3d31ca157d7ca6f22eb53ad5ac3 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:46:42 -0700 Subject: [PATCH 29/40] contract(stack): replay metric-origin producer semantics --- research/english-gonol/english_gonol/edcm_metric_origins.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/research/english-gonol/english_gonol/edcm_metric_origins.py b/research/english-gonol/english_gonol/edcm_metric_origins.py index 7bb49c29..d1f967fc 100644 --- a/research/english-gonol/english_gonol/edcm_metric_origins.py +++ b/research/english-gonol/english_gonol/edcm_metric_origins.py @@ -51,6 +51,11 @@ # given: resolved EDCM construction terms are compared with the exact pinned OEWN 2025 source # then: every term is an exact admitted word surface before an origin is licensed # class: provenance_contract +# +# id: metric_origin_source_fixture_matches_pinned_edcm +# given: the Stack source fixture and exact pinned EDCM producer are inspected +# then: every semantic construction field is identical before Stack constructs an origin +# class: provenance_contract # === END CONTRACTS === from __future__ import annotations From 3fca0ae57ea82976875efe804bd15e3d4888c43f Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:46:52 -0700 Subject: [PATCH 30/40] test(stack): replay exact EDCM metric-origin semantics --- .../tests/test_edcm_metric_origins.py | 31 +++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/research/english-gonol/tests/test_edcm_metric_origins.py b/research/english-gonol/tests/test_edcm_metric_origins.py index 3dad6343..0e720e8f 100644 --- a/research/english-gonol/tests/test_edcm_metric_origins.py +++ b/research/english-gonol/tests/test_edcm_metric_origins.py @@ -45,12 +45,20 @@ # timeout: 60 # mutates: none # cleanup: none +# id: check_metric_origin_source_fixture +# proves: metric_origin_source_fixture_matches_pinned_edcm +# call: self::test_stack_fixture_matches_exact_edcm_producer +# requires: python3, exact EDCM metric-origin producer +# mutates: none +# cleanup: none # === END CHECKS === from hashlib import sha256 +import importlib.util import json import os import sqlite3 +import sys from pathlib import Path import pytest @@ -172,3 +180,26 @@ def test_all_resolved_terms_are_admitted_by_pinned_oewn(): if absent: missing[metric]=absent assert missing=={} + + +def test_stack_fixture_matches_exact_edcm_producer(): + root=os.environ.get("EDCM_METRIC_ORIGIN_ROOT") + if not root: + pytest.skip("exact EDCM metric-origin producer not present; authoritative CI supplies it") + module_path=Path(root)/"edcm"/"metric_origin_spec.py" + spec=importlib.util.spec_from_file_location("_pinned_edcm_metric_origin_spec",module_path) + assert spec is not None and spec.loader is not None + module=importlib.util.module_from_spec(spec) + sys.modules[spec.name]=module + spec.loader.exec_module(module) + fixture=origins.load_metric_origin_specs() + assert fixture["producer_commit"]=="57e2c32196568b4bbde61a80001906eb735ac830" + assert tuple(fixture["specs"])==tuple(module.METRIC_ORIGIN_SPECS) + for metric,source_spec in module.METRIC_ORIGIN_SPECS.items(): + record=fixture["specs"][metric] + assert record["surface_terms"]==list(source_spec.surface_terms) + assert record["construction_terms"]==list(source_spec.construction_terms) + assert record["semantic_definition"]==source_spec.semantic_definition + assert record["standing"]==source_spec.standing + assert record["measurement_alignment"]==source_spec.measurement_alignment + assert record["unresolved"]==list(source_spec.unresolved) From 684746e6eb2cc6893724b56e13373af4049fef9d Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:47:16 -0700 Subject: [PATCH 31/40] docs(stack): repin valid EDCM metric-origin producer --- research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json b/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json index 6c1c12b6..b186d2ad 100644 --- a/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json +++ b/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json @@ -2,7 +2,7 @@ "schema": "edcm.metric-origin-spec-fixture", "version": "0.3.0", "producer_repository": "The-Interdependency/edcm", - "producer_commit": "57e2c32196568b4bbde61a80001906eb735ac830", + "producer_commit": "ed1b6e42b72c47f9383bd20b65e49a6c39a1a747", "specs": { "C": { "surface_terms": [ From 9368e4a2a14e04ae4a026274531269aa8539117c Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:47:18 -0700 Subject: [PATCH 32/40] docs(stack): repin valid EDCM metric-origin producer --- research/english-gonol/BASE.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/research/english-gonol/BASE.json b/research/english-gonol/BASE.json index 55984120..1f3b806a 100644 --- a/research/english-gonol/BASE.json +++ b/research/english-gonol/BASE.json @@ -21,7 +21,7 @@ }, "metric_origin_source": { "repository": "The-Interdependency/edcm", - "commit": "57e2c32196568b4bbde61a80001906eb735ac830", + "commit": "ed1b6e42b72c47f9383bd20b65e49a6c39a1a747", "relation": "exact EDCM semantic metric-origin producer; does not refresh the historical extraction source or libs/edcm pin", "authority_transfer": false } From c78e0e79b93dbdef779907f45668d432c57ddd44 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:47:26 -0700 Subject: [PATCH 33/40] ci(stack): repin valid EDCM metric-origin producer --- .github/workflows/english-gonol.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/english-gonol.yml b/.github/workflows/english-gonol.yml index ffaf12ea..7c3828e1 100644 --- a/.github/workflows/english-gonol.yml +++ b/.github/workflows/english-gonol.yml @@ -57,7 +57,7 @@ jobs: uses: actions/checkout@v7.0.1 with: repository: The-Interdependency/edcm - ref: 57e2c32196568b4bbde61a80001906eb735ac830 + ref: ed1b6e42b72c47f9383bd20b65e49a6c39a1a747 path: _deps/edcm-metric-origin persist-credentials: false From 2c6f001405cfbcdb21aaed5fcf5b0106049bf030 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:47:28 -0700 Subject: [PATCH 34/40] ci(stack): repin valid EDCM metric-origin producer --- research/english-gonol/tests/test_edcm_metric_origins.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/research/english-gonol/tests/test_edcm_metric_origins.py b/research/english-gonol/tests/test_edcm_metric_origins.py index 0e720e8f..6cbb7640 100644 --- a/research/english-gonol/tests/test_edcm_metric_origins.py +++ b/research/english-gonol/tests/test_edcm_metric_origins.py @@ -193,7 +193,7 @@ def test_stack_fixture_matches_exact_edcm_producer(): sys.modules[spec.name]=module spec.loader.exec_module(module) fixture=origins.load_metric_origin_specs() - assert fixture["producer_commit"]=="57e2c32196568b4bbde61a80001906eb735ac830" + assert fixture["producer_commit"]=="ed1b6e42b72c47f9383bd20b65e49a6c39a1a747" assert tuple(fixture["specs"])==tuple(module.METRIC_ORIGIN_SPECS) for metric,source_spec in module.METRIC_ORIGIN_SPECS.items(): record=fixture["specs"][metric] From 7359f071d645fbb5bbbc2352d49360397c608d1a Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:47:40 -0700 Subject: [PATCH 35/40] docs(stack): repin valid metric-origin participant --- stack-manifest.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/stack-manifest.json b/stack-manifest.json index b6eed1d1..757ba6fc 100644 --- a/stack-manifest.json +++ b/stack-manifest.json @@ -1,7 +1,7 @@ { "schema": "the-interdependency.stack-manifest", "version": "1.1.0", - "work_graph_sha256": "306da7cba2d38df0387d7f6778c88138c223b4e66ed9818feb42a4e8a8832fcf", + "work_graph_sha256": "e3fd82189f5968b9aa7431a39e9230d79d7053de3aebfa46b621aa0590ceb793", "repositories": [ { "repository": "The-Interdependency/skill-lib", @@ -335,7 +335,7 @@ "workspace": "research/english-gonol/", "participant_id": "edcm-metric-origin-source", "repository": "The-Interdependency/edcm", - "commit": "57e2c32196568b4bbde61a80001906eb735ac830", + "commit": "ed1b6e42b72c47f9383bd20b65e49a6c39a1a747", "authority": "EDCM semantic metric-origin definitions and measurement-rule alignment", "relation": "exact semantic-origin producer consumed by Stack English; does not refresh libs/edcm or transfer measurement authority", "canonical_release": false, From 49df85271ec92d2f45e4ca1f3c43dd34aa5476ae Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 17:47:49 -0700 Subject: [PATCH 36/40] docs(stack): refresh valid metric-origin projection --- STACK_MANIFEST.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/STACK_MANIFEST.md b/STACK_MANIFEST.md index 66927f69..799c56f0 100644 --- a/STACK_MANIFEST.md +++ b/STACK_MANIFEST.md @@ -17,7 +17,7 @@ Provenance and authority-boundary record for `The-Interdependency/stack`. - English four-view complete-corpus audit UTC: `2026-09-22`, exact view source `1f9a35eb355296fc88d09784c7a3e2e95511ca31`; all 164,864 words, native and independent agreement. - Stack-manifest schema: `the-interdependency.stack-manifest` version `1.1.0` - Work-graph digest (SHA-256 over canonical `repositories` + `research_participants` + `boundaries` JSON): - `306da7cba2d38df0387d7f6778c88138c223b4e66ed9818feb42a4e8a8832fcf` + `e3fd82189f5968b9aa7431a39e9230d79d7053de3aebfa46b621aa0590ceb793` - Weave workspace creation UTC: `2026-09-28`; new specification-first research starts from the intended multi-arity interleaving mechanism without URPCS inheritance - Machine-readable copy: [`stack-manifest.json`](stack-manifest.json) @@ -65,7 +65,7 @@ release identity. | `research/urpcs/` | `The-Interdependency/stack` | `a428a41a38a8b30bacb7025a4d54070b228a8089` | retired substituted-codec historical evidence only; no active URPCS authority or evidence transfer | no | | `research/weave/` | `The-Interdependency/stack` | `1ba201449731337dc20c564788f4303c8910bfdd` | full gonol/private-key/thread/corpus/interleave/asymmetric construction research; native derivation unresolved; no URPCS implementation inheritance or security standing | no | | `research/english-gonol/` | `The-Interdependency/stack` | `99b3598b02a6e683b3c84184d8ea443b12fc0e1a` | stack-local English lexical/gonol construction separated from EDCM; full pinned-corpus v2 build/replay survived; consumes UCNS geometry; EDCM may evaluate outputs but does not define construction | no | -| `research/english-gonol/` | `The-Interdependency/edcm` | `57e2c32196568b4bbde61a80001906eb735ac830` | exact EDCM semantic metric-origin producer; supplies metric definitions and proxy-alignment metadata without refreshing `libs/edcm` or transferring measurement authority | no | +| `research/english-gonol/` | `The-Interdependency/edcm` | `ed1b6e42b72c47f9383bd20b65e49a6c39a1a747` | exact EDCM semantic metric-origin producer; supplies metric definitions and proxy-alignment metadata without refreshing `libs/edcm` or transferring measurement authority | no | | `research/python-gonol/` | `The-Interdependency/stack` | `0e8384bbb60e4c2189016a212bdd0030d04aed7d` | stack-local bottom-up Python 3.12 source gonol construction; applies METAPAT affixiation semantics, consumes optional UCNS geometry, and transfers no language authority to UCNS or EDCM | no | | `research/ucns/` | `The-Interdependency/ucns` | `1975fe70cf4e0826a8020c2da3047569e277af64` | explicit source base for integrated stack-local UCNS research; does not refresh or replace the manifest-pinned `libs/ucns` canonical view | no | | `research/from-photons-to-macroverse/` | `The-Interdependency/stack` | `77ef8c7fb0ff75a524181655ee9f9641372768f7` | target composition forge baseline at audit start | no | From f14351a8d167f73e34d2b4317c3ff69068f6ec91 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 21:09:36 -0700 Subject: [PATCH 37/40] fix: bind metric origins to merged EDCM and execute full provenance gates Pin EDCM 91b5600 across projections, preserve exact producer definitions, reject altered fixture provenance, and hash metric origin identities. CI supplies required source paths and executes the complete corpus/adapter replay. Local English suite: 131 passed, zero skipped. --- .github/workflows/english-gonol.yml | 48 +++++- STACK_MANIFEST.md | 4 +- research/english-gonol/BASE.json | 2 +- .../EDCM_METRIC_ORIGINS_SOURCE.json | 6 +- .../english-gonol/docs/metric-origin-space.md | 81 +++++++++++ .../work-graphs/metric-origin-space-v0.json | 4 +- .../english_gonol/edcm_metric_origins.py | 19 ++- .../tests/test_edcm_metric_origins.py | 137 +++++++++++++++--- stack-manifest.json | 4 +- 9 files changed, 266 insertions(+), 39 deletions(-) create mode 100644 research/english-gonol/docs/metric-origin-space.md diff --git a/.github/workflows/english-gonol.yml b/.github/workflows/english-gonol.yml index 7c3828e1..960cd616 100644 --- a/.github/workflows/english-gonol.yml +++ b/.github/workflows/english-gonol.yml @@ -21,6 +21,10 @@ jobs: env: UCNS_SOURCE_ROOT: ${{ github.workspace }}/_deps/ucns-motion ENGLISH_GONOL_UCNS_ROOT: ${{ github.workspace }}/_deps/ucns-relational + OEWN_SOURCE_ROOT: ${{ github.workspace }}/_deps/oewn/src/yaml + EDCM_METRIC_ORIGIN_ROOT: ${{ github.workspace }}/_deps/edcm-metric-origin + ENGLISH_GONOL_FULL_CONSTRUCT_ROOT: ${{ github.workspace }}/_state/english-full-construct + REQUIRE_METRIC_ORIGIN_SOURCES: "1" steps: - name: Checkout stack uses: actions/checkout@v7.0.1 @@ -57,23 +61,59 @@ jobs: uses: actions/checkout@v7.0.1 with: repository: The-Interdependency/edcm - ref: ed1b6e42b72c47f9383bd20b65e49a6c39a1a747 + ref: 91b56007f4c77bd7e939bcbe93d8095411ceff78 path: _deps/edcm-metric-origin persist-credentials: false + - name: Checkout pinned full-construct carrier + uses: actions/checkout@v7.0.1 + with: + repository: The-Interdependency/ucns + ref: 4f863ad37096b7baab8f62820ad5cb937b62a3a7 + path: _deps/ucns-carrier + persist-credentials: false + - name: Set up Python uses: actions/setup-python@v7.0.0 with: python-version: "3.12" - - name: Install pytest - run: python -m pip install --disable-pip-version-check pytest + - name: Install construction prerequisites + run: python -m pip install --disable-pip-version-check pytest PyYAML - - name: Verify pinned UCNS source identities + - name: Verify all pinned source identities run: | test "$(git -C _deps/ucns-motion rev-parse HEAD)" = "5a042416ef62abd9b674523284c2a31193918d66" test "$(git -C _deps/ucns-relational rev-parse HEAD)" = "d7c6f51304ed6c32d48badf63132bea6de8af497" + test "$(git -C _deps/oewn rev-parse HEAD)" = "dc343f2683279ecbb13fab4e2fd778d7b162d287" + test "$(git -C _deps/edcm-metric-origin rev-parse HEAD)" = "91b56007f4c77bd7e939bcbe93d8095411ceff78" + test "$(git -C _deps/ucns-carrier rev-parse HEAD)" = "4f863ad37096b7baab8f62820ad5cb937b62a3a7" + + - name: Preflight full-corpus resources + run: | + python - <<'PY' + import os, shutil + assert shutil.disk_usage(os.environ["RUNNER_TEMP"]).free >= 8 * 1024**3 + assert os.sysconf("SC_PHYS_PAGES") * os.sysconf("SC_PAGE_SIZE") >= 5 * 1024**3 + PY + + - name: Build complete pinned corpus for metric-origin replay + working-directory: research/english-gonol + run: | + python -m english_gonol.full_construct_run \ + --source-root "$OEWN_SOURCE_ROOT" \ + --ucns-source-root "$GITHUB_WORKSPACE/_deps/ucns-carrier" \ + --out-dir "$ENGLISH_GONOL_FULL_CONSTRUCT_ROOT" - name: English Gonol construction tests working-directory: research/english-gonol run: python -m pytest -q tests + + - name: Retain full-corpus metric-origin evidence + uses: actions/upload-artifact@v7.0.1 + with: + name: metric-origin-replay + path: | + ${{ env.ENGLISH_GONOL_FULL_CONSTRUCT_ROOT }}/manifest.json + ${{ env.ENGLISH_GONOL_FULL_CONSTRUCT_ROOT }}/metric-origin-replay.json + if-no-files-found: error diff --git a/STACK_MANIFEST.md b/STACK_MANIFEST.md index 799c56f0..bca22793 100644 --- a/STACK_MANIFEST.md +++ b/STACK_MANIFEST.md @@ -17,7 +17,7 @@ Provenance and authority-boundary record for `The-Interdependency/stack`. - English four-view complete-corpus audit UTC: `2026-09-22`, exact view source `1f9a35eb355296fc88d09784c7a3e2e95511ca31`; all 164,864 words, native and independent agreement. - Stack-manifest schema: `the-interdependency.stack-manifest` version `1.1.0` - Work-graph digest (SHA-256 over canonical `repositories` + `research_participants` + `boundaries` JSON): - `e3fd82189f5968b9aa7431a39e9230d79d7053de3aebfa46b621aa0590ceb793` + `d20c8965766caacc008c1e54de2edc0c47b5247159c7ec7da0f8d3d773b29b52` - Weave workspace creation UTC: `2026-09-28`; new specification-first research starts from the intended multi-arity interleaving mechanism without URPCS inheritance - Machine-readable copy: [`stack-manifest.json`](stack-manifest.json) @@ -65,7 +65,7 @@ release identity. | `research/urpcs/` | `The-Interdependency/stack` | `a428a41a38a8b30bacb7025a4d54070b228a8089` | retired substituted-codec historical evidence only; no active URPCS authority or evidence transfer | no | | `research/weave/` | `The-Interdependency/stack` | `1ba201449731337dc20c564788f4303c8910bfdd` | full gonol/private-key/thread/corpus/interleave/asymmetric construction research; native derivation unresolved; no URPCS implementation inheritance or security standing | no | | `research/english-gonol/` | `The-Interdependency/stack` | `99b3598b02a6e683b3c84184d8ea443b12fc0e1a` | stack-local English lexical/gonol construction separated from EDCM; full pinned-corpus v2 build/replay survived; consumes UCNS geometry; EDCM may evaluate outputs but does not define construction | no | -| `research/english-gonol/` | `The-Interdependency/edcm` | `ed1b6e42b72c47f9383bd20b65e49a6c39a1a747` | exact EDCM semantic metric-origin producer; supplies metric definitions and proxy-alignment metadata without refreshing `libs/edcm` or transferring measurement authority | no | +| `research/english-gonol/` | `The-Interdependency/edcm` | `91b56007f4c77bd7e939bcbe93d8095411ceff78` | exact EDCM semantic metric-origin producer; supplies metric definitions and proxy-alignment metadata without refreshing `libs/edcm` or transferring measurement authority | no | | `research/python-gonol/` | `The-Interdependency/stack` | `0e8384bbb60e4c2189016a212bdd0030d04aed7d` | stack-local bottom-up Python 3.12 source gonol construction; applies METAPAT affixiation semantics, consumes optional UCNS geometry, and transfers no language authority to UCNS or EDCM | no | | `research/ucns/` | `The-Interdependency/ucns` | `1975fe70cf4e0826a8020c2da3047569e277af64` | explicit source base for integrated stack-local UCNS research; does not refresh or replace the manifest-pinned `libs/ucns` canonical view | no | | `research/from-photons-to-macroverse/` | `The-Interdependency/stack` | `77ef8c7fb0ff75a524181655ee9f9641372768f7` | target composition forge baseline at audit start | no | diff --git a/research/english-gonol/BASE.json b/research/english-gonol/BASE.json index 1f3b806a..eecd92c8 100644 --- a/research/english-gonol/BASE.json +++ b/research/english-gonol/BASE.json @@ -21,7 +21,7 @@ }, "metric_origin_source": { "repository": "The-Interdependency/edcm", - "commit": "ed1b6e42b72c47f9383bd20b65e49a6c39a1a747", + "commit": "91b56007f4c77bd7e939bcbe93d8095411ceff78", "relation": "exact EDCM semantic metric-origin producer; does not refresh the historical extraction source or libs/edcm pin", "authority_transfer": false } diff --git a/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json b/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json index b186d2ad..60216681 100644 --- a/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json +++ b/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json @@ -2,7 +2,7 @@ "schema": "edcm.metric-origin-spec-fixture", "version": "0.3.0", "producer_repository": "The-Interdependency/edcm", - "producer_commit": "ed1b6e42b72c47f9383bd20b65e49a6c39a1a747", + "producer_commit": "91b56007f4c77bd7e939bcbe93d8095411ceff78", "specs": { "C": { "surface_terms": [ @@ -42,7 +42,7 @@ "surface_terms": [ "Fixation" ], - "semantic_definition": "fixation is persistence of substantially the same constraint bearing pattern across successive states", + "semantic_definition": "fixation is persistence of substantially the same constraint-bearing pattern across successive states", "standing": "resolved", "measurement_alignment": "proxy", "unresolved": [ @@ -75,7 +75,7 @@ "surface_terms": [ "Deflection" ], - "semantic_definition": "deflection is movement away from the active constraint bearing subject or relation", + "semantic_definition": "deflection is movement away from the active constraint-bearing subject or relation", "standing": "resolved", "measurement_alignment": "proxy", "unresolved": [ diff --git a/research/english-gonol/docs/metric-origin-space.md b/research/english-gonol/docs/metric-origin-space.md new file mode 100644 index 00000000..9512556f --- /dev/null +++ b/research/english-gonol/docs/metric-origin-space.md @@ -0,0 +1,81 @@ +# EDCM metric-origin construction — usage guidance + +Stack consumes the merged EDCM producer +`91b56007f4c77bd7e939bcbe93d8095411ceff78`. EDCM owns the metric meanings, +scalar computations, conflicts, and proxy limitations. Stack constructs their +declared ordered English terms. Construction closure does not establish +measurement validity. O and L remain unclosed `hmmm` records. + +`BASE.json`, the local metric work graph, the Stack manifests, the source fixture, +and CI register this same producer. The loader binds the fixture's complete bytes +to `FIXTURE_SHA256`; `fixture_path` accepts an exact copy, not alternate semantic +definitions or unregistered producer labels. Update the owning EDCM source first +and replay the cross-source check before changing this pin. + +## Reproduce the authoritative checks + +From `research/english-gonol`, install `pytest` and `PyYAML`. Use clean checkouts: + +| Input | Commit | Path passed to the checks | +|---|---|---| +| EDCM | `91b56007f4c77bd7e939bcbe93d8095411ceff78` | checkout root | +| OEWN 2025 | `dc343f2683279ecbb13fab4e2fd778d7b162d287` | checkout `src/yaml` | +| UCNS full-construct carrier | `4f863ad37096b7baab8f62820ad5cb937b62a3a7` | checkout root | + +Set the three absolute paths for your checkouts and a new output directory: + +```bash +export OEWN_SOURCE_ROOT=/path/to/oewn/src/yaml +export EDCM_METRIC_ORIGIN_ROOT=/path/to/edcm +export ENGLISH_GONOL_FULL_CONSTRUCT_ROOT=/path/to/generated/english-full-construct +export REQUIRE_METRIC_ORIGIN_SOURCES=1 +python -m english_gonol.full_construct_run \ + --source-root "$OEWN_SOURCE_ROOT" \ + --ucns-source-root /path/to/ucns-carrier \ + --out-dir "$ENGLISH_GONOL_FULL_CONSTRUCT_ROOT" +python -m pytest -q tests/test_edcm_metric_origins.py +``` + +Preflight enough disk and memory before starting the full construction; CI +requires 8 GiB free disk and 5 GiB RAM. Let an admitted run finish naturally. +The complete workflow also sets the motion and relational UCNS source paths +needed by the rest of the English suite. + +The tests verify the actual EDCM checkout, compare all consumed semantic fields, +check exact term admission against the complete pinned corpus, replay the full +construct receipt, construct every metric origin, and bind the emitted records +through the exact merged EDCM adapter. Required missing sources fail instead of +skipping. `metric-origin-replay.json` contains all 11 origin records and a clearly +synthetic transcript measurement used only to test adapter compatibility. + +## Export for independent observations + +With the environment above, this writes an ordered JSON object ready for +EDCM's `build_semantic_metric_space`: + +```bash +python - <<'PY' +import json, os +from pathlib import Path +from english_gonol.edcm_metric_origins import ( + build_metric_origin_set, load_metric_origin_specs, +) +state = Path(os.environ["ENGLISH_GONOL_FULL_CONSTRUCT_ROOT"]) +records = {metric: build_metric_origin_set(state, metric).to_dict() + for metric in load_metric_origin_specs()["specs"]} +(state / "metric-origins.json").write_text(json.dumps(records, indent=2) + "\n") +PY +``` + +Load that JSON object in the pinned EDCM environment, build the space, and call +`bind_round_metrics` with maintained `RoundMetrics` and the separate observation's +evidence receipt. See EDCM's `docs/semantic-metric-space.md` for the runnable +measurement example and adapter input contract. Keep vector order; do not sort +the exported metric keys. + +## hmmm + +O conflicts between Overextension and Overconfidence; L conflicts between Load +and Coherence Loss. The observed-construct-to-origin projection remains +unestablished. Receipts establish content identity, not cryptographic producer +authentication, empirical validity, or canon selection. diff --git a/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json b/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json index 0ba6dd26..156f6a06 100644 --- a/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json +++ b/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json @@ -1,11 +1,11 @@ { "schema": "the-interdependency.stack-manifest", "version": "1.0.0", - "work_graph_sha256": "c0397219cf465ff2a9fb29e667d2c80ce0e259d9fcd0eda731693ad390871b1d", + "work_graph_sha256": "f4352ecef72333c3275976439f11444ae32c3f9e4364fd3fb327798d7b5566a1", "repositories": [ { "repository": "The-Interdependency/edcm", - "commit": "8f40ad6cd7a436d6223a623544285aff1b73eccb", + "commit": "91b56007f4c77bd7e939bcbe93d8095411ceff78", "authority": "metric definitions, scalar measurement, and evidence/readout contracts", "relation": "defines source-owned construction terms and binds scalar readouts to Stack origin receipts" }, diff --git a/research/english-gonol/english_gonol/edcm_metric_origins.py b/research/english-gonol/english_gonol/edcm_metric_origins.py index d1f967fc..b5f46cff 100644 --- a/research/english-gonol/english_gonol/edcm_metric_origins.py +++ b/research/english-gonol/english_gonol/edcm_metric_origins.py @@ -3,6 +3,9 @@ Only EDCM-owned construction terms enter the semantic origin. Measurement rules and observed evidence stay outside it. Resolved origins require the exact pinned English v2 construct receipt; unresolved EDCM semantics remain unclosed hmmm. + +Usage guidance: see ``docs/metric-origin-space.md`` for source checkout, +complete-corpus construction, export, and EDCM adapter commands. """ # === MODULE_BUILD === @@ -76,6 +79,9 @@ SCHEMA = "english-gonol.edcm-metric-origin-set" VERSION = "0.2.0" FIXTURE = Path(__file__).resolve().parents[1] / "EDCM_METRIC_ORIGINS_SOURCE.json" +BASE = FIXTURE.parent / "BASE.json" +# Bind the complete source projection, not only a caller-supplied commit label. +FIXTURE_SHA256 = "1ec7ddef9c41aac365131d8cf8a49df5246795897d57a4fa2e3e250ad74d3337" def _canonical(value: object) -> bytes: @@ -98,6 +104,7 @@ class OriginComponent: @dataclass(frozen=True, slots=True) class MetricOriginSet: metric_id: str + origin_id: str producer_repository: str producer_commit: str construct_receipt: str @@ -112,6 +119,7 @@ def _payload(self) -> dict[str, object]: "schema": SCHEMA, "version": VERSION, "metric_id": self.metric_id, + "origin_id": self.origin_id, "producer_repository": self.producer_repository, "producer_commit": self.producer_commit, "construct_receipt": self.construct_receipt, @@ -126,12 +134,19 @@ def to_dict(self) -> dict[str, object]: def load_metric_origin_specs(path: Path = FIXTURE) -> dict[str, object]: - data = json.loads(Path(path).read_text(encoding="utf-8")) + content = Path(path).read_bytes() + if sha256(content).hexdigest() != FIXTURE_SHA256: + raise ValueError("EDCM metric-origin fixture digest mismatch") + data = json.loads(content) if ( data.get("schema") != "edcm.metric-origin-spec-fixture" or data.get("version") != "0.3.0" ): raise ValueError("unsupported EDCM metric-origin fixture") + registered = json.loads(BASE.read_text(encoding="utf-8"))["metric_origin_source"] + if (data.get("producer_repository") != registered["repository"] + or data.get("producer_commit") != registered["commit"]): + raise ValueError("unregistered EDCM metric-origin producer") return data @@ -178,6 +193,7 @@ def build_metric_origin_set( if spec["standing"] != "resolved": common = { "metric_id": metric_id, + "origin_id": f"O_M({metric_id})", "producer_repository": source["producer_repository"], "producer_commit": source["producer_commit"], "construct_receipt": "hmmm", @@ -229,6 +245,7 @@ def build_metric_origin_set( common = { "metric_id": metric_id, + "origin_id": f"O_M({metric_id})", "producer_repository": source["producer_repository"], "producer_commit": source["producer_commit"], "construct_receipt": observed_receipt, diff --git a/research/english-gonol/tests/test_edcm_metric_origins.py b/research/english-gonol/tests/test_edcm_metric_origins.py index 6cbb7640..4a17d9b5 100644 --- a/research/english-gonol/tests/test_edcm_metric_origins.py +++ b/research/english-gonol/tests/test_edcm_metric_origins.py @@ -58,6 +58,7 @@ import json import os import sqlite3 +import subprocess import sys from pathlib import Path @@ -65,24 +66,30 @@ import english_gonol.edcm_metric_origins as origins from english_gonol.hyperspace_construct import V2_MANIFEST_RECEIPT +from english_gonol.full_construct_run import _collect_surfaces, verify_replay +from english_gonol.language.source import load_oewn_2025, OEWN_COMMIT -def _fixture(tmp_path: Path, metric="F", standing="resolved"): - source = { - "schema":"edcm.metric-origin-spec-fixture","version":"0.3.0", - "producer_repository":"The-Interdependency/edcm","producer_commit":"a"*40, - "specs":{metric:{ - "surface_terms":["Fixation"], - "construction_terms":["fixation","persistence","repetition"], - "semantic_definition":"fixation is persistence across states", - "standing":standing,"measurement_alignment":"proxy", - "unresolved":["proxy gap"] if standing=="resolved" else ["collision"]}} - } - path=tmp_path/"source.json" - path.write_text(json.dumps(source),encoding="utf-8") +def _fixture(tmp_path: Path): + path = tmp_path / "source.json" + path.write_bytes(origins.FIXTURE.read_bytes()) return path +def _source_root(variable): + root = os.environ.get(variable) + if not root: + if os.environ.get("REQUIRE_METRIC_ORIGIN_SOURCES") == "1": + pytest.fail(f"required provenance source missing: {variable}") + pytest.skip(f"{variable} not supplied for optional local replay") + return Path(root) + + +def _verify_checkout(root, commit, paths): + assert subprocess.check_output(["git", "-C", str(root), "rev-parse", "HEAD"], text=True).strip() == commit + subprocess.run(["git", "-C", str(root), "diff", "--exit-code", "HEAD", "--", *paths], check=True) + + def _db(tmp_path: Path): db=sqlite3.connect(tmp_path/"construct.db") db.executescript(""" @@ -120,7 +127,8 @@ def test_resolved_origin_uses_word_and_glyph_axes_in_order(tmp_path, monkeypatch assert record.components[0].axis_origin=="O_W" assert any(x.axis_origin=="O_G" and x.surface==" " for x in record.components) assert record.producer_repository=="The-Interdependency/edcm" - assert "proxy gap" in record.unresolved + assert "maintained implementation is a lexical structural proxy, not embedding similarity" in record.unresolved + assert record.origin_id == "O_M(F)" def test_origin_record_contains_no_measurement_value(tmp_path, monkeypatch): @@ -143,12 +151,13 @@ def test_wrong_construct_receipt_fails_closed(tmp_path, monkeypatch): def test_unresolved_origin_does_not_construct_components(tmp_path): record=origins.build_metric_origin_set( - tmp_path,"F",fixture_path=_fixture(tmp_path,standing="hmmm") + tmp_path,"O",fixture_path=_fixture(tmp_path) ) assert record.closed is False assert record.components==() assert record.construct_receipt=="hmmm" - assert record.unresolved==("collision",) + assert record.unresolved==("marker canon says Overextension; compute.py says Overconfidence",) + assert record.origin_id == "O_M(O)" def test_receipt_hashes_complete_payload_except_receipt(tmp_path, monkeypatch): @@ -165,10 +174,9 @@ def test_receipt_hashes_complete_payload_except_receipt(tmp_path, monkeypatch): def test_all_resolved_terms_are_admitted_by_pinned_oewn(): - root=os.environ.get("OEWN_SOURCE_ROOT") - if not root: - pytest.skip("exact OEWN source not present; authoritative CI supplies it") - snapshot=load_oewn_2025(Path(root)) + root = _source_root("OEWN_SOURCE_ROOT") + _verify_checkout(root, OEWN_COMMIT, ["."]) + snapshot=load_oewn_2025(root) words,_characters=_collect_surfaces(snapshot) admitted=set(words) fixture=origins.load_metric_origin_specs() @@ -183,9 +191,9 @@ def test_all_resolved_terms_are_admitted_by_pinned_oewn(): def test_stack_fixture_matches_exact_edcm_producer(): - root=os.environ.get("EDCM_METRIC_ORIGIN_ROOT") - if not root: - pytest.skip("exact EDCM metric-origin producer not present; authoritative CI supplies it") + root = _source_root("EDCM_METRIC_ORIGIN_ROOT") + fixture=origins.load_metric_origin_specs() + _verify_checkout(root, fixture["producer_commit"], ["edcm"] ) module_path=Path(root)/"edcm"/"metric_origin_spec.py" spec=importlib.util.spec_from_file_location("_pinned_edcm_metric_origin_spec",module_path) assert spec is not None and spec.loader is not None @@ -193,7 +201,7 @@ def test_stack_fixture_matches_exact_edcm_producer(): sys.modules[spec.name]=module spec.loader.exec_module(module) fixture=origins.load_metric_origin_specs() - assert fixture["producer_commit"]=="ed1b6e42b72c47f9383bd20b65e49a6c39a1a747" + assert fixture["producer_commit"]=="91b56007f4c77bd7e939bcbe93d8095411ceff78" assert tuple(fixture["specs"])==tuple(module.METRIC_ORIGIN_SPECS) for metric,source_spec in module.METRIC_ORIGIN_SPECS.items(): record=fixture["specs"][metric] @@ -203,3 +211,84 @@ def test_stack_fixture_matches_exact_edcm_producer(): assert record["standing"]==source_spec.standing assert record["measurement_alignment"]==source_spec.measurement_alignment assert record["unresolved"]==list(source_spec.unresolved) + + +@pytest.mark.parametrize("mutation", ["repository", "commit", "terms", "standing"]) +def test_unregistered_or_modified_fixture_fails_closed(tmp_path, mutation): + path = _fixture(tmp_path) + source = json.loads(path.read_text()) + if mutation == "repository": + source["producer_repository"] = "someone/else" + elif mutation == "commit": + source["producer_commit"] = "a" * 40 + elif mutation == "terms": + source["specs"]["F"]["construction_terms"] = ["invented"] + else: + source["specs"]["O"]["standing"] = "resolved" + path.write_text(json.dumps(source)) + with pytest.raises(ValueError, match="fixture digest mismatch"): + origins.build_metric_origin_set(tmp_path, "F", fixture_path=path) + + +def test_registered_producer_and_all_projections_agree(): + workspace = origins.FIXTURE.parent + stack = workspace.parents[1] + fixture = origins.load_metric_origin_specs() + producer = fixture["producer_commit"] + graph = json.loads((workspace / "docs/work-graphs/metric-origin-space-v0.json").read_text()) + participant = next(x for x in graph["repositories"] if x["repository"] == fixture["producer_repository"]) + assert participant["commit"] == producer + digest = sha256(json.dumps({k: graph[k] for k in ("repositories", "boundaries")}, sort_keys=True, separators=(",", ":")).encode()).hexdigest() + assert graph["work_graph_sha256"] == digest + manifest = json.loads((stack / "stack-manifest.json").read_text()) + participant = next(x for x in manifest["research_participants"] if x.get("participant_id") == "edcm-metric-origin-source") + assert participant["commit"] == producer + assert producer in (stack / "STACK_MANIFEST.md").read_text() + + +def test_required_provenance_source_cannot_skip(monkeypatch): + monkeypatch.setenv("REQUIRE_METRIC_ORIGIN_SOURCES", "1") + monkeypatch.delenv("OEWN_SOURCE_ROOT", raising=False) + with pytest.raises(pytest.fail.Exception, match="required provenance source missing"): + _source_root("OEWN_SOURCE_ROOT") + + +def test_full_construct_origins_bind_to_pinned_edcm(): + state_dir = _source_root("ENGLISH_GONOL_FULL_CONSTRUCT_ROOT") + edcm_root = _source_root("EDCM_METRIC_ORIGIN_ROOT") + fixture = origins.load_metric_origin_specs() + _verify_checkout(edcm_root, fixture["producer_commit"], ["edcm"]) + manifest = verify_replay(state_dir) + assert manifest["receipt_sha256"] == V2_MANIFEST_RECEIPT + records = {metric: origins.build_metric_origin_set(state_dir, metric).to_dict() + for metric in fixture["specs"]} + for metric, record in records.items(): + payload = {k: v for k, v in record.items() if k != "receipt_sha256"} + assert sha256(origins._canonical(payload)).hexdigest() == record["receipt_sha256"] + assert record["origin_id"] == f"O_M({metric})" + assert record["closed"] is (metric not in {"O", "L"}) + # A subprocess prevents an already-imported editable EDCM from shadowing + # the exact producer checkout under test. + result = subprocess.run( + [sys.executable, "-c", """ +import json, sys +from dataclasses import asdict +from edcm.measurement import compute_transcript, parse_transcript +from edcm.semantic_metric_space import build_semantic_metric_space, bind_round_metrics +origins = json.load(sys.stdin) +space = build_semantic_metric_space(origins) +assert space.unresolved_metrics == ('O', 'L') +assert not space.complete +metrics = compute_transcript(parse_transcript('A: State the constraint.\\nB: Recorded.'))[0] +rows = bind_round_metrics(metrics, space, evidence_receipt='synthetic-transcript:full-replay-test') +assert [row.value for row in rows] == metrics.vector() +assert all(row.semantic_projection == 'hmmm' for row in rows) +print(json.dumps([asdict(row) for row in rows], allow_nan=False)) +"""], cwd=edcm_root, input=json.dumps(records), text=True, capture_output=True, + env={**os.environ, "PYTHONPATH": str(edcm_root)}, check=True, + ) + evidence = {"producer_commit": fixture["producer_commit"], + "construct_receipt": manifest["receipt_sha256"], + "origin_records": records, "readouts": json.loads(result.stdout), + "unresolved_metrics": ["O", "L"], "semantic_projection": "hmmm"} + (state_dir / "metric-origin-replay.json").write_text(json.dumps(evidence, indent=2) + "\n") diff --git a/stack-manifest.json b/stack-manifest.json index 757ba6fc..54f43288 100644 --- a/stack-manifest.json +++ b/stack-manifest.json @@ -1,7 +1,7 @@ { "schema": "the-interdependency.stack-manifest", "version": "1.1.0", - "work_graph_sha256": "e3fd82189f5968b9aa7431a39e9230d79d7053de3aebfa46b621aa0590ceb793", + "work_graph_sha256": "d20c8965766caacc008c1e54de2edc0c47b5247159c7ec7da0f8d3d773b29b52", "repositories": [ { "repository": "The-Interdependency/skill-lib", @@ -335,7 +335,7 @@ "workspace": "research/english-gonol/", "participant_id": "edcm-metric-origin-source", "repository": "The-Interdependency/edcm", - "commit": "ed1b6e42b72c47f9383bd20b65e49a6c39a1a747", + "commit": "91b56007f4c77bd7e939bcbe93d8095411ceff78", "authority": "EDCM semantic metric-origin definitions and measurement-rule alignment", "relation": "exact semantic-origin producer consumed by Stack English; does not refresh libs/edcm or transfer measurement authority", "canonical_release": false, From 6d2975747c2075ac530a0f7103838ce1a234204e Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 21:10:06 -0700 Subject: [PATCH 38/40] docs: bind metric work graph to the verified Stack construction --- .../docs/work-graphs/metric-origin-space-v0.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json b/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json index 156f6a06..8c1c56a5 100644 --- a/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json +++ b/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json @@ -1,7 +1,7 @@ { "schema": "the-interdependency.stack-manifest", "version": "1.0.0", - "work_graph_sha256": "f4352ecef72333c3275976439f11444ae32c3f9e4364fd3fb327798d7b5566a1", + "work_graph_sha256": "4647103cbebb6ecf6d3771c9a9e69eae04409542ed1855845efcfbdb33fc83bb", "repositories": [ { "repository": "The-Interdependency/edcm", @@ -11,7 +11,7 @@ }, { "repository": "The-Interdependency/stack", - "commit": "20daed7f29d90fa14a01a8f4ba7bc32a78895152", + "commit": "f14351a8d167f73e34d2b4317c3ff69068f6ec91", "authority": "current English Gonol semantic construction", "relation": "constructs exact EDCM construction terms as verified O_W/O_G metric origin sets" }, From 316a8c8f10e2dacd34007e076bcf20c4d1ecda00 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 21:18:38 -0700 Subject: [PATCH 39/40] fix: consume final reviewed EDCM semantic-space admission producer Repin to merged EDCM #78 (ce645e4), carrying the same exact semantic fixture content and the strengthened readout admission boundary. Full-corpus CI and terminal review must complete before merge. --- .github/workflows/english-gonol.yml | 4 ++-- STACK_MANIFEST.md | 4 ++-- research/english-gonol/BASE.json | 2 +- research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json | 2 +- research/english-gonol/docs/metric-origin-space.md | 4 ++-- .../docs/work-graphs/metric-origin-space-v0.json | 4 ++-- research/english-gonol/english_gonol/edcm_metric_origins.py | 2 +- research/english-gonol/tests/test_edcm_metric_origins.py | 2 +- stack-manifest.json | 4 ++-- 9 files changed, 14 insertions(+), 14 deletions(-) diff --git a/.github/workflows/english-gonol.yml b/.github/workflows/english-gonol.yml index 960cd616..fef39888 100644 --- a/.github/workflows/english-gonol.yml +++ b/.github/workflows/english-gonol.yml @@ -61,7 +61,7 @@ jobs: uses: actions/checkout@v7.0.1 with: repository: The-Interdependency/edcm - ref: 91b56007f4c77bd7e939bcbe93d8095411ceff78 + ref: ce645e4b3cce0308676837f60bed118fa74f23ac path: _deps/edcm-metric-origin persist-credentials: false @@ -86,7 +86,7 @@ jobs: test "$(git -C _deps/ucns-motion rev-parse HEAD)" = "5a042416ef62abd9b674523284c2a31193918d66" test "$(git -C _deps/ucns-relational rev-parse HEAD)" = "d7c6f51304ed6c32d48badf63132bea6de8af497" test "$(git -C _deps/oewn rev-parse HEAD)" = "dc343f2683279ecbb13fab4e2fd778d7b162d287" - test "$(git -C _deps/edcm-metric-origin rev-parse HEAD)" = "91b56007f4c77bd7e939bcbe93d8095411ceff78" + test "$(git -C _deps/edcm-metric-origin rev-parse HEAD)" = "ce645e4b3cce0308676837f60bed118fa74f23ac" test "$(git -C _deps/ucns-carrier rev-parse HEAD)" = "4f863ad37096b7baab8f62820ad5cb937b62a3a7" - name: Preflight full-corpus resources diff --git a/STACK_MANIFEST.md b/STACK_MANIFEST.md index bca22793..3ee6ff36 100644 --- a/STACK_MANIFEST.md +++ b/STACK_MANIFEST.md @@ -17,7 +17,7 @@ Provenance and authority-boundary record for `The-Interdependency/stack`. - English four-view complete-corpus audit UTC: `2026-09-22`, exact view source `1f9a35eb355296fc88d09784c7a3e2e95511ca31`; all 164,864 words, native and independent agreement. - Stack-manifest schema: `the-interdependency.stack-manifest` version `1.1.0` - Work-graph digest (SHA-256 over canonical `repositories` + `research_participants` + `boundaries` JSON): - `d20c8965766caacc008c1e54de2edc0c47b5247159c7ec7da0f8d3d773b29b52` + `f0ce9606681cc053d9dcbb010805a932290207d49a5d8714297b8c3ce455ec41` - Weave workspace creation UTC: `2026-09-28`; new specification-first research starts from the intended multi-arity interleaving mechanism without URPCS inheritance - Machine-readable copy: [`stack-manifest.json`](stack-manifest.json) @@ -65,7 +65,7 @@ release identity. | `research/urpcs/` | `The-Interdependency/stack` | `a428a41a38a8b30bacb7025a4d54070b228a8089` | retired substituted-codec historical evidence only; no active URPCS authority or evidence transfer | no | | `research/weave/` | `The-Interdependency/stack` | `1ba201449731337dc20c564788f4303c8910bfdd` | full gonol/private-key/thread/corpus/interleave/asymmetric construction research; native derivation unresolved; no URPCS implementation inheritance or security standing | no | | `research/english-gonol/` | `The-Interdependency/stack` | `99b3598b02a6e683b3c84184d8ea443b12fc0e1a` | stack-local English lexical/gonol construction separated from EDCM; full pinned-corpus v2 build/replay survived; consumes UCNS geometry; EDCM may evaluate outputs but does not define construction | no | -| `research/english-gonol/` | `The-Interdependency/edcm` | `91b56007f4c77bd7e939bcbe93d8095411ceff78` | exact EDCM semantic metric-origin producer; supplies metric definitions and proxy-alignment metadata without refreshing `libs/edcm` or transferring measurement authority | no | +| `research/english-gonol/` | `The-Interdependency/edcm` | `ce645e4b3cce0308676837f60bed118fa74f23ac` | exact EDCM semantic metric-origin producer; supplies metric definitions and proxy-alignment metadata without refreshing `libs/edcm` or transferring measurement authority | no | | `research/python-gonol/` | `The-Interdependency/stack` | `0e8384bbb60e4c2189016a212bdd0030d04aed7d` | stack-local bottom-up Python 3.12 source gonol construction; applies METAPAT affixiation semantics, consumes optional UCNS geometry, and transfers no language authority to UCNS or EDCM | no | | `research/ucns/` | `The-Interdependency/ucns` | `1975fe70cf4e0826a8020c2da3047569e277af64` | explicit source base for integrated stack-local UCNS research; does not refresh or replace the manifest-pinned `libs/ucns` canonical view | no | | `research/from-photons-to-macroverse/` | `The-Interdependency/stack` | `77ef8c7fb0ff75a524181655ee9f9641372768f7` | target composition forge baseline at audit start | no | diff --git a/research/english-gonol/BASE.json b/research/english-gonol/BASE.json index eecd92c8..cb814012 100644 --- a/research/english-gonol/BASE.json +++ b/research/english-gonol/BASE.json @@ -21,7 +21,7 @@ }, "metric_origin_source": { "repository": "The-Interdependency/edcm", - "commit": "91b56007f4c77bd7e939bcbe93d8095411ceff78", + "commit": "ce645e4b3cce0308676837f60bed118fa74f23ac", "relation": "exact EDCM semantic metric-origin producer; does not refresh the historical extraction source or libs/edcm pin", "authority_transfer": false } diff --git a/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json b/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json index 60216681..75f66b5b 100644 --- a/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json +++ b/research/english-gonol/EDCM_METRIC_ORIGINS_SOURCE.json @@ -2,7 +2,7 @@ "schema": "edcm.metric-origin-spec-fixture", "version": "0.3.0", "producer_repository": "The-Interdependency/edcm", - "producer_commit": "91b56007f4c77bd7e939bcbe93d8095411ceff78", + "producer_commit": "ce645e4b3cce0308676837f60bed118fa74f23ac", "specs": { "C": { "surface_terms": [ diff --git a/research/english-gonol/docs/metric-origin-space.md b/research/english-gonol/docs/metric-origin-space.md index 9512556f..01eee09e 100644 --- a/research/english-gonol/docs/metric-origin-space.md +++ b/research/english-gonol/docs/metric-origin-space.md @@ -1,7 +1,7 @@ # EDCM metric-origin construction — usage guidance Stack consumes the merged EDCM producer -`91b56007f4c77bd7e939bcbe93d8095411ceff78`. EDCM owns the metric meanings, +`ce645e4b3cce0308676837f60bed118fa74f23ac`. EDCM owns the metric meanings, scalar computations, conflicts, and proxy limitations. Stack constructs their declared ordered English terms. Construction closure does not establish measurement validity. O and L remain unclosed `hmmm` records. @@ -18,7 +18,7 @@ From `research/english-gonol`, install `pytest` and `PyYAML`. Use clean checkout | Input | Commit | Path passed to the checks | |---|---|---| -| EDCM | `91b56007f4c77bd7e939bcbe93d8095411ceff78` | checkout root | +| EDCM | `ce645e4b3cce0308676837f60bed118fa74f23ac` | checkout root | | OEWN 2025 | `dc343f2683279ecbb13fab4e2fd778d7b162d287` | checkout `src/yaml` | | UCNS full-construct carrier | `4f863ad37096b7baab8f62820ad5cb937b62a3a7` | checkout root | diff --git a/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json b/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json index 8c1c56a5..d7e0340a 100644 --- a/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json +++ b/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json @@ -1,11 +1,11 @@ { "schema": "the-interdependency.stack-manifest", "version": "1.0.0", - "work_graph_sha256": "4647103cbebb6ecf6d3771c9a9e69eae04409542ed1855845efcfbdb33fc83bb", + "work_graph_sha256": "cf849c7d2096c4e16a856dd9c7889b7ace0be3ecd1a8e6958a6dc5efad913e47", "repositories": [ { "repository": "The-Interdependency/edcm", - "commit": "91b56007f4c77bd7e939bcbe93d8095411ceff78", + "commit": "ce645e4b3cce0308676837f60bed118fa74f23ac", "authority": "metric definitions, scalar measurement, and evidence/readout contracts", "relation": "defines source-owned construction terms and binds scalar readouts to Stack origin receipts" }, diff --git a/research/english-gonol/english_gonol/edcm_metric_origins.py b/research/english-gonol/english_gonol/edcm_metric_origins.py index b5f46cff..572c5585 100644 --- a/research/english-gonol/english_gonol/edcm_metric_origins.py +++ b/research/english-gonol/english_gonol/edcm_metric_origins.py @@ -81,7 +81,7 @@ FIXTURE = Path(__file__).resolve().parents[1] / "EDCM_METRIC_ORIGINS_SOURCE.json" BASE = FIXTURE.parent / "BASE.json" # Bind the complete source projection, not only a caller-supplied commit label. -FIXTURE_SHA256 = "1ec7ddef9c41aac365131d8cf8a49df5246795897d57a4fa2e3e250ad74d3337" +FIXTURE_SHA256 = "cd3d384399da3029833e8f1cba993e4571cfcd2dd605e3ac44869de85aba43d3" def _canonical(value: object) -> bytes: diff --git a/research/english-gonol/tests/test_edcm_metric_origins.py b/research/english-gonol/tests/test_edcm_metric_origins.py index 4a17d9b5..8aa7ace2 100644 --- a/research/english-gonol/tests/test_edcm_metric_origins.py +++ b/research/english-gonol/tests/test_edcm_metric_origins.py @@ -201,7 +201,7 @@ def test_stack_fixture_matches_exact_edcm_producer(): sys.modules[spec.name]=module spec.loader.exec_module(module) fixture=origins.load_metric_origin_specs() - assert fixture["producer_commit"]=="91b56007f4c77bd7e939bcbe93d8095411ceff78" + assert fixture["producer_commit"]=="ce645e4b3cce0308676837f60bed118fa74f23ac" assert tuple(fixture["specs"])==tuple(module.METRIC_ORIGIN_SPECS) for metric,source_spec in module.METRIC_ORIGIN_SPECS.items(): record=fixture["specs"][metric] diff --git a/stack-manifest.json b/stack-manifest.json index 54f43288..cd2d78da 100644 --- a/stack-manifest.json +++ b/stack-manifest.json @@ -1,7 +1,7 @@ { "schema": "the-interdependency.stack-manifest", "version": "1.1.0", - "work_graph_sha256": "d20c8965766caacc008c1e54de2edc0c47b5247159c7ec7da0f8d3d773b29b52", + "work_graph_sha256": "f0ce9606681cc053d9dcbb010805a932290207d49a5d8714297b8c3ce455ec41", "repositories": [ { "repository": "The-Interdependency/skill-lib", @@ -335,7 +335,7 @@ "workspace": "research/english-gonol/", "participant_id": "edcm-metric-origin-source", "repository": "The-Interdependency/edcm", - "commit": "91b56007f4c77bd7e939bcbe93d8095411ceff78", + "commit": "ce645e4b3cce0308676837f60bed118fa74f23ac", "authority": "EDCM semantic metric-origin definitions and measurement-rule alignment", "relation": "exact semantic-origin producer consumed by Stack English; does not refresh libs/edcm or transfer measurement authority", "canonical_release": false, From d6dbf3eabb7c0148de1d4b1b32502142a467e73f Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 3 Oct 2026 21:19:11 -0700 Subject: [PATCH 40/40] docs: seal the final metric-origin producer pair --- .../docs/work-graphs/metric-origin-space-v0.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json b/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json index d7e0340a..2af78b03 100644 --- a/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json +++ b/research/english-gonol/docs/work-graphs/metric-origin-space-v0.json @@ -1,7 +1,7 @@ { "schema": "the-interdependency.stack-manifest", "version": "1.0.0", - "work_graph_sha256": "cf849c7d2096c4e16a856dd9c7889b7ace0be3ecd1a8e6958a6dc5efad913e47", + "work_graph_sha256": "1950c6601417665245f17c27d9f292b243194fdf7a0cec380d6a7acfc61f0bb6", "repositories": [ { "repository": "The-Interdependency/edcm", @@ -11,7 +11,7 @@ }, { "repository": "The-Interdependency/stack", - "commit": "f14351a8d167f73e34d2b4317c3ff69068f6ec91", + "commit": "316a8c8f10e2dacd34007e076bcf20c4d1ecda00", "authority": "current English Gonol semantic construction", "relation": "constructs exact EDCM construction terms as verified O_W/O_G metric origin sets" },