engineering-argument-language 3.2.3__py3-none-any.whl

eal/dialectic.py

@@ -0,0 +1,321 @@
+"""Finite abstract argumentation with Dung's least-fixed-point grounded semantics.
+
+Argument identifiers and attacks are supplied explicitly by the caller. This
+module does not infer attacks from natural language or interpret EAL declarations.
+"""
+from __future__ import annotations
+from .limits import current_limits
+
+MAX_ARGUMENTS = 4096
+MAX_ATTACKS = 65536
+MAX_IDENTIFIER_LENGTH = 256
+MAX_COMPOSED_NODES = 4096
+MAX_COMPOSED_CLAIMS = 4096
+MAX_COMPOSED_EDGES = 131072
+
+
+class ArgumentationError(ValueError):
+    """An abstract argumentation graph violates the input contract."""
+
+
+def _identifier(value: object, location: str) -> str:
+    if not isinstance(value, str):
+        raise ArgumentationError(f"{location} must be a string")
+    if not value or value != value.strip() or not value.isprintable():
+        raise ArgumentationError(
+            f"{location} must be nonempty and printable without surrounding whitespace"
+        )
+    if len(value) > MAX_IDENTIFIER_LENGTH:
+        raise ArgumentationError(
+            f"{location} exceeds {MAX_IDENTIFIER_LENGTH} characters"
+        )
+    return value
+
+
+def solve_grounded(arguments: list[str], attacks: list[list[str]]) -> dict:
+    """Return the grounded labelling and deterministic, replayable defence trace.
+
+    ``[source, target]`` means source attacks target. The accepted arguments form
+    the least fixed point of the defence function F, starting with the empty set.
+    Rejected arguments are attacked by an accepted argument; the rest remain
+    undecided. These are graph-relative argument statuses, not truth values.
+
+    Input lists must contain distinct identifiers and distinct directed edges.
+    Cycles and self-attacks are valid. All result identifiers use Python's sorted
+    string order, independent of input order. No caller-owned value is modified.
+    Propagation visits each node and edge a bounded number of times. Deterministic
+    sorting gives O((V + E) log(V + E)) worst-case time; space is O(V + E), including
+    the trace. No recursion, network, clock or tool execution is used.
+    """
+    if not isinstance(arguments, list):
+        raise ArgumentationError("arguments must be a list")
+    if not isinstance(attacks, list):
+        raise ArgumentationError("attacks must be a list")
+    if len(arguments) > current_limits().declarations:
+        raise ArgumentationError(f"arguments exceeds the limit of {current_limits().declarations}")
+    if len(attacks) > current_limits().abstract_attacks:
+        raise ArgumentationError(f"attacks exceeds the limit of {current_limits().abstract_attacks}")
+
+    nodes: set[str] = set()
+    for index, value in enumerate(arguments):
+        argument = _identifier(value, f"arguments[{index}]")
+        if argument in nodes:
+            raise ArgumentationError(f"duplicate argument: {argument!r}")
+        nodes.add(argument)
+
+    edges: set[tuple[str, str]] = set()
+    for index, edge in enumerate(attacks):
+        if not isinstance(edge, list) or len(edge) != 2:
+            raise ArgumentationError(f"attacks[{index}] must be a two-element list")
+        source = _identifier(edge[0], f"attacks[{index}][0]")
+        target = _identifier(edge[1], f"attacks[{index}][1]")
+        if source not in nodes or target not in nodes:
+            raise ArgumentationError(f"attack contains an undeclared argument: {edge!r}")
+        pair = (source, target)
+        if pair in edges:
+            raise ArgumentationError(f"duplicate attack: {edge!r}")
+        edges.add(pair)
+
+    ordered = sorted(nodes)
+    incoming: dict[str, list[str]] = {node: [] for node in ordered}
+    outgoing: dict[str, list[str]] = {node: [] for node in ordered}
+    for source, target in sorted(edges):
+        incoming[target].append(source)
+        outgoing[source].append(target)
+
+    # An argument is defended once all its attackers have been rejected. The
+    # remaining count is reduced once per rejected attacker, never per defender.
+    remaining = {node: len(incoming[node]) for node in ordered}
+    accepted: set[str] = set()
+    rejected: set[str] = set()
+    rejected_by: dict[str, str] = {}
+    wave = [node for node in ordered if remaining[node] == 0]
+    trace: list[dict] = []
+    round_number = 0
+
+    while wave:
+        round_number += 1
+        # Certificates only refer to defenders accepted in an earlier round.
+        accepted_trace = [
+            {
+                "argument": node,
+                "defence": [
+                    {"attacker": attacker, "defender": rejected_by[attacker]}
+                    for attacker in incoming[node]
+                ],
+            }
+            for node in wave
+        ]
+        accepted.update(wave)
+        defeated: dict[str, list[str]] = {}
+        for defender in wave:
+            for target in outgoing[defender]:
+                if target not in rejected:
+                    defeated.setdefault(target, []).append(defender)
+        rejected.update(defeated)
+        for target, defenders in defeated.items():
+            rejected_by[target] = defenders[0]
+
+        trace.append(
+            {
+                "round": round_number,
+                "accepted": accepted_trace,
+                "rejected": [
+                    {"argument": target, "attacked_by": defeated[target]}
+                    for target in sorted(defeated)
+                ],
+            }
+        )
+        next_wave: set[str] = set()
+        for target in defeated:
+            for dependent in outgoing[target]:
+                remaining[dependent] -= 1
+                if (
+                    remaining[dependent] == 0
+                    and dependent not in accepted
+                    and dependent not in rejected
+                ):
+                    next_wave.add(dependent)
+        wave = sorted(next_wave)
+
+    undecided = sorted(nodes - accepted - rejected)
+    return {
+        "semantics": "grounded",
+        "accepted": sorted(accepted),
+        "rejected": sorted(rejected),
+        "undecided": undecided,
+        "trace": trace,
+        "unresolved_attackers": {
+            node: [attacker for attacker in incoming[node] if attacker not in rejected]
+            for node in undecided
+        },
+    }
+
+
+def solve_composed(nodes: dict[str, dict], claims: dict[str, list[str]],
+                   attacks: list[list[str]]) -> dict:
+    """Solve the explicit AND/OR support extension by least information.
+
+    A node has exactly ``usable: bool`` and ``premises: list[claim_id]``. It is
+    accepted when locally usable, all premise claims are accepted and all its
+    attackers are rejected. It is rejected when locally unusable, a premise is
+    rejected or an attacker is accepted. A claim is accepted if any of its listed
+    nodes is accepted, and rejected if all are rejected (including an empty list).
+
+    Starting with every label undecided, apply these rules until no label changes.
+    This is an explicit support extension, not full ASPIC+. The attack-only
+    fragment, with all nodes usable, is Dung grounded labelling. Dependencies can
+    be cyclic: an unresolved cycle does not generate acceptance.
+
+    Node and claim identifiers occupy separate namespaces. Each node can support
+    zero, one or several claims. Local usability must already reflect the caller's
+    evidence and computational checks, before attack/support status is applied.
+    Invalid input raises ArgumentationError. Nothing is executed or mutated.
+    """
+    if not isinstance(nodes, dict) or not isinstance(claims, dict):
+        raise ArgumentationError("nodes and claims must be dictionaries")
+    if not isinstance(attacks, list):
+        raise ArgumentationError("attacks must be a list")
+    if len(nodes) > current_limits().declarations:
+        raise ArgumentationError(f"nodes exceeds the limit of {current_limits().declarations}")
+    if len(claims) > current_limits().declarations:
+        raise ArgumentationError(f"claims exceeds the limit of {current_limits().declarations}")
+    if len(attacks) > current_limits().composed_edges:
+        raise ArgumentationError(f"relationships exceeds the limit of {current_limits().composed_edges}")
+    for node in nodes:
+        _identifier(node, "node identifier")
+    for claim in claims:
+        _identifier(claim, "claim identifier")
+    node_ids, claim_ids = sorted(nodes), sorted(claims)
+    edge_count = len(attacks)
+
+    def references(value, declared, location):
+        nonlocal edge_count
+        if not isinstance(value, list):
+            raise ArgumentationError(f"{location} must be a list")
+        edge_count += len(value)
+        if edge_count > current_limits().composed_edges:
+            raise ArgumentationError(f"relationships exceeds the limit of {current_limits().composed_edges}")
+        found = set()
+        for item in value:
+            _identifier(item, location)
+            if item not in declared:
+                raise ArgumentationError(f"{location} contains an undeclared identifier: {item!r}")
+            if item in found:
+                raise ArgumentationError(f"{location} contains a duplicate identifier: {item!r}")
+            found.add(item)
+        return sorted(found)
+
+    premises = {}
+    for node in node_ids:
+        declaration = nodes[node]
+        if not isinstance(declaration, dict) or set(declaration) != {"usable", "premises"}:
+            raise ArgumentationError(f"Node {node!r} requires exactly usable and premises")
+        if type(declaration["usable"]) is not bool:
+            raise ArgumentationError(f"Node {node!r} usable must be a boolean")
+        premises[node] = references(declaration["premises"], claims, f"Node {node!r} premises")
+    derivations = {
+        claim: references(claims[claim], nodes, f"Claim {claim!r} derivations")
+        for claim in claim_ids
+    }
+    edge_set = set()
+    for index, edge in enumerate(attacks):
+        if not isinstance(edge, list) or len(edge) != 2:
+            raise ArgumentationError(f"attacks[{index}] must be a two-element list")
+        source = _identifier(edge[0], f"attacks[{index}][0]")
+        target = _identifier(edge[1], f"attacks[{index}][1]")
+        if source not in nodes or target not in nodes:
+            raise ArgumentationError(f"attack contains an undeclared node: {edge!r}")
+        pair = (source, target)
+        if pair in edge_set:
+            raise ArgumentationError(f"duplicate attack: {edge!r}")
+        edge_set.add(pair)
+
+    attackers = {node: [] for node in node_ids}
+    attacked_nodes = {node: [] for node in node_ids}
+    for source, target in sorted(edge_set):
+        attackers[target].append(source)
+        attacked_nodes[source].append(target)
+    premise_dependants = {claim: [] for claim in claim_ids}
+    derived_claims = {node: [] for node in node_ids}
+    for node in node_ids:
+        for claim in premises[node]:
+            premise_dependants[claim].append(node)
+    for claim in claim_ids:
+        for node in derivations[claim]:
+            derived_claims[node].append(claim)
+
+    node_labels = {node: "undecided" for node in node_ids}
+    claim_labels = {claim: "undecided" for claim in claim_ids}
+    premises_in = dict.fromkeys(node_ids, 0)
+    premises_out = dict.fromkeys(node_ids, 0)
+    attackers_in = dict.fromkeys(node_ids, 0)
+    attackers_out = dict.fromkeys(node_ids, 0)
+    derivations_in = dict.fromkeys(claim_ids, 0)
+    derivations_out = dict.fromkeys(claim_ids, 0)
+    pending_nodes, pending_claims = set(node_ids), set(claim_ids)
+    trace = []
+
+    while pending_nodes or pending_claims:
+        new_nodes, new_claims = {}, {}
+        # Each batch reads only labels determined in earlier batches. Counts
+        # prevent rescanning all undecided dependencies on every iteration.
+        for node in sorted(pending_nodes):
+            if node_labels[node] != "undecided":
+                continue
+            if not nodes[node]["usable"] or premises_out[node] or attackers_in[node]:
+                new_nodes[node] = "rejected"
+            elif (premises_in[node] == len(premises[node])
+                  and attackers_out[node] == len(attackers[node])):
+                new_nodes[node] = "accepted"
+        for claim in sorted(pending_claims):
+            if claim_labels[claim] != "undecided":
+                continue
+            if derivations_in[claim]:
+                new_claims[claim] = "accepted"
+            elif derivations_out[claim] == len(derivations[claim]):
+                new_claims[claim] = "rejected"
+        if not new_nodes and not new_claims:
+            break
+
+        node_trace, claim_trace = [], []
+        for node, label in new_nodes.items():
+            if label == "accepted":
+                reasons = [{"kind": "local", "usable": True}]
+                reasons.extend({"kind": "premise", "id": claim, "status": "accepted"}
+                               for claim in premises[node])
+                reasons.extend({"kind": "attacker", "id": attacker, "status": "rejected"}
+                               for attacker in attackers[node])
+            else:
+                reasons = ([{"kind": "local", "usable": False}]
+                           if not nodes[node]["usable"] else [])
+                reasons.extend({"kind": "premise", "id": claim, "status": "rejected"}
+                               for claim in premises[node] if claim_labels[claim] == "rejected")
+                reasons.extend({"kind": "attacker", "id": attacker, "status": "accepted"}
+                               for attacker in attackers[node] if node_labels[attacker] == "accepted")
+            node_trace.append({"id": node, "status": label, "reasons": reasons})
+        for claim, label in new_claims.items():
+            reasons = [
+                {"kind": "derivation", "id": node, "status": label}
+                for node in derivations[claim] if node_labels[node] == label
+            ] or [{"kind": "no_derivation"}]
+            claim_trace.append({"id": claim, "status": label, "reasons": reasons})
+        trace.append({"round": len(trace) + 1, "nodes": node_trace, "claims": claim_trace})
+
+        node_labels.update(new_nodes)
+        claim_labels.update(new_claims)
+        pending_nodes, pending_claims = set(), set()
+        for node, label in new_nodes.items():
+            for target in attacked_nodes[node]:
+                (attackers_in if label == "accepted" else attackers_out)[target] += 1
+                pending_nodes.add(target)
+            for claim in derived_claims[node]:
+                (derivations_in if label == "accepted" else derivations_out)[claim] += 1
+                pending_claims.add(claim)
+        for claim, label in new_claims.items():
+            for node in premise_dependants[claim]:
+                (premises_in if label == "accepted" else premises_out)[node] += 1
+                pending_nodes.add(node)
+
+    return {"semantics": "grounded_with_support", "nodes": node_labels,
+            "claims": claim_labels, "trace": trace}

eal/discovery.py

@@ -0,0 +1,127 @@
+"""Packaged language reference for models with no prior knowledge of EAL."""
+from __future__ import annotations
+
+from . import __version__
+
+
+EXAMPLE = '''language "EAL/3"
+environment bench {
+  require site == "bench"
+}
+tool collector {
+  version "1"
+}
+context environment bench, tool collector, max_age 3600 {
+  evidence observation {
+    kind test
+    require passed == true
+  }
+  reasoning measured {
+    method "structured/1"
+    rationale "The observation supports only the stated test result in this environment."
+  }
+  claim checked {
+    statement "The supplied test passes at the bench."
+  }
+  argument measurement = [evidence observation] via measured => checked
+}
+'''
+
+
+def describe_language(*, registry=None) -> dict:
+    from .methods import default_registry
+    from .propositions import describe_bindings
+
+    registry = default_registry() if registry is None else registry
+
+    return {
+        "implementation_version": __version__,
+        "languages": ["EAL/3"],
+        "source_syntax": "EAL/3",
+        "method_registry_fingerprint": registry.fingerprint,
+        "syntax": {
+            'notation': 'Capitalised placeholders denote values. Fields end at newlines and may appear in any order. Square brackets are literal lists/support groups. Names are unique within lexical modules and argument blocks; dotted names identify lowered declarations. Forward references are allowed. Strings use JSON quoting; comments use // or /* */.',
+            'program': 'language "EAL/3"\nDECLARATIONS',
+            'context': 'context environment ENV, tool TOOL, max_age SECONDS, kind KIND {\nDECLARATIONS\n}',
+            'module': 'module NAME {\nDECLARATIONS\n}',
+            'import': 'import \"WORKSPACE_SOURCE.eal\" as ALIAS',
+            'block_argument': 'argument NAME {\nLOCAL_DECLARATIONS\n[evidence E, premises LOCAL_CLAIM] via REASONING => CLAIM\n}',
+            'compound_pattern': 'pattern NAME(c: claim, r: reasoning, es: evidence[], env: environment) {\nLOCAL_DECLARATIONS_AND_APPLICATIONS\n}',
+            'recursive_pattern': 'pattern NAME(c: claim, r: reasoning, es: evidence[]) decreases es {\nwhen es {\nargument item = [evidence head(es)] via r => c\napply rest = NAME(c=c, r=r, es=tail(es))\n}\n}',
+            'scope_transfer': 'reasoning NAME {\nmethod \"structured/1\"\nrationale \"CONDITIONAL_RELATION\"\ntransfer from SOURCE_ENV to TARGET_ENV assuming ASSUMPTION reviewed \"REVIEW\"\n}',
+            'environment': 'environment NAME {\nrequire CONTEXT.FIELD OP SCALAR\n}',
+            'tool': 'tool NAME {\nversion "VERSION"\n}',
+            'evidence': 'evidence NAME {\ntool TOOL\nkind KIND\nenvironment ENV\nmax_age SECONDS\ninput JSON\nrequire VALUE.FIELD OP SCALAR\n}',
+            'assumption': 'assumption NAME {\nstatement "TEXT"\nenvironment ENV\nvalidate EVIDENCE\nvalid_from "TIME"\nvalid_until "TIME"\n}',
+            'reasoning': 'reasoning NAME {\nmethod "VERSIONED_METHOD_ID"\nrationale "TEXT"\nbacking [EVIDENCE_LIST]\nrequire OUTPUT.FIELD OP SCALAR\n}',
+            'claim': 'claim NAME {\nstatement "TEXT"\nenvironment ENV\nproposition {\nsubject "ENTITY"\nquantity "QUANTITY"\nunit "UNIT"\nscope "SCOPE"\nvalid_from "TIME"\nvalid_until "TIME"\nquery JSON\nresult OUTPUT.FIELD OP SCALAR\n}\n}',
+            'argument': 'argument NAME = [evidence EVIDENCE_LIST, assumptions ASSUMPTION_LIST, premises CLAIM_LIST] via REASONING => CLAIM binding EVIDENCE',
+            'objection': 'objection NAME = [evidence EVIDENCE_LIST, premises CLAIM_LIST] -x> TARGET_KIND TARGET_NAME',
+            'pattern': 'pattern NAME(c: claim, r: reasoning, e: evidence) = [evidence e] via r => c',
+            'apply': 'apply ARGUMENT = PATTERN(PARAM=REFERENCE, ...)',
+            'formal_relations': 'strict ARGUMENT reviewed "REVIEW_REFERENCE"\nrank EVIDENCE_OR_ASSUMPTION_OR_ARGUMENT INTEGER reviewed "REVIEW_REFERENCE"\nprefer FALLIBLE_ELEMENT over FALLIBLE_ELEMENT reviewed \"REVIEW_REFERENCE\"\ncontrary CLAIM to CLAIM reviewed "REVIEW_REFERENCE". These are ASPIC+ formalisation directives. reason validates them; compile-aspic applies their effects. Ranks are integers 0-1000; claim contraries are directed.',
+            'scope_defaults': 'Multiple declarations retain distinct identities, inputs and predicates. Nearest context wins; explicit fields override defaults. Defaults are restricted by declaration type: tool version; evidence environment/tool/kind/input/max_age; assumption environment/validate/dates; claim environment; reasoning method; proposition subject/quantity/unit/scope/dates/query. Required fields are checked after inheritance. Contexts group metadata; modules and block arguments introduce lexical namespaces.',
+            'optional_fields': 'Evidence input, reasoning backing, claim proposition, assumption validity dates, each support group and binding are optional. Evidence/environment require predicates; arguments/objections require nonempty support. All proposition fields are required.',
+            'nested_derivations': 'Block arguments contain local declarations and finish with a support flow. Compound patterns contain multiple routes, local definitions and nested applications. Premises still reference claims, retaining acyclic engineering derivations. Recursive template expansion is separate from logical self-support: recursive calls must consume a guarded tail of a finite typed list.',
+            'abstraction': 'Patterns have closed typed parameters. Data references name typed parameters or local declarations; helper pattern calls are resolved lexically. Expansion preserves dependency identities and qualifies generated names by application. Forward references are allowed; invalid bindings are diagnosed.',
+            'operators': ['==', '!=', '<', '<=', '>', '>=', 'and', 'or', 'not', '+', '-', '*', '/', '%'],
+            'expressions': 'Pure functions: field, literal, count, sum, min, max, abs, all, any, quantity. Boolean operands are strict; missing data remains unknown under negation. Numerical operations require finite values; quantity arithmetic checks registered dimensions and rational unit scales. Invalid operations are never masked by Boolean composition.',
+            'lists': 'Comma-separated identifiers retain their order. Computational methods need output predicates and typed claims need an evidence binding on each supporting argument.',
+        },
+        "methods": {
+            "structured/1": {"input": "Author-supplied evidence/premise relation", "meaning": "Checks availability and composition; does not prove prose"},
+            "deductive/1": {"kind": "logical_case", "input": {"premises": ["FORMULA"], "conclusion": "FORMULA"}, "formula": 'An atom string, {"not":f}, {"and":[f,...]}, {"or":[f,...]} or {"implies":[f,g]}', "outputs": ["entailed", "consistent_premises", "counterexample"], "limit": "At most 12 atoms; inconsistent premises are unusable"},
+            "inductive/1": {"kind": "sample", "input": {"successes": "INTEGER", "trials": "POSITIVE_INTEGER", "confidence": "NUMBER"}, "outputs": ["estimate", "lower", "upper", "sample_size", "confidence"], "meaning": "Wilson interval; sampling assumptions are supplied, not established"},
+            "abductive/1": {"kind": "hypotheses", "input": {"observed": "JOINT_EVENT", "candidates": [{"name": "HYPOTHESIS", "prior": "NUMBER", "likelihood": "NUMBER"}]}, "outputs": ["posterior", "best", "best_posterior", "ties"], "meaning": "Bayesian update within supplied candidates and joint likelihoods"},
+            "causal/1": {"kind": "experiment", "input": {"assignment": "randomised", "treatment": ["NUMBER"], "control": ["NUMBER"]}, "outputs": ["estimate", "standard_error"], "meaning": "Difference of group means with standard error; at least two values per group; design metadata is asserted"},
+            "counterfactual/1": {"kind": "causal_model", "input": {"variables": {"VARIABLE": {"intercept": "NUMBER", "coefficients": {"PARENT": "NUMBER"}, "noise": "NUMBER"}}, "intervention": {"variable": "VARIABLE", "value": "NUMBER"}, "outcome": "VARIABLE"}, "outputs": ["factual", "counterfactual", "difference"], "meaning": "Acyclic affine structural model, supplied fixed noise; at most 32 variables"},
+            "analogical/1": {"kind": "analogy", "input": {"relevant_features": ["FEATURE"], "source": {"FEATURE": "SCALAR"}, "target": {"FEATURE": "SCALAR"}}, "outputs": ["match_fraction"], "meaning": "Exact declared feature comparisons, not a probability or proof of transfer"},
+            "temporal/1": {"kind": "trace", "input": {"start": "NUMBER", "end": "NUMBER", "max_gap": "NUMBER", "events": [{"time": "NUMBER", "value": "NUMBER"}], "property": {"operator": "lt|le|eq|ne|ge|gt", "value": "NUMBER"}, "semantics": "sampled"}, "outputs": ["holds"], "meaning": "Ordered, bounded finite samples with endpoint/gap coverage; no continuous-time conclusion"},
+        },
+        "environment_contexts": "Supply flat context for one shared environment, or {$environments: {ENV: CONTEXT}} for explicit separate contexts. Scope transfer still requires a reviewed relation and validated target assumption.",
+        "optional_compilation": {
+            "profile": "EAL/3-compiled-aspic/5",
+            "cli": "compile-aspic SOURCE --context JSON --collection COLLECTION_ID --goal CLAIM [--now TIME]",
+            "mcp": "eal_compile_aspic(source, context, collection_id, goal, now?)",
+            "input": "Validated EAL/3 source, matching stored observation collection, declared goal claim and explicit or current assessment time",
+            "meaning": "Check EAL observations and local methods, then translate available evidence, locally usable argument routes, assumptions and targeted objections into a bounded ASPIC+ theory with explicit source mapping; reviewed EAL argumentation relations supply optional strict rules, ranks and directed claim contraries; ordinary EAL reasoning is unchanged",
+            "output": ["profile", "theory", "formal", "routes", "source_map", "claim_status", "authored_claim_status", "source_digest", "snapshot_digest", "collection_id"],
+            "limits": "Unannotated fallible elements use rank 500 and authored routes remain defeasible; strictness, claim contrariness and ranks require checked source annotations. Objections cannot undercut strict routes or carry ranks. Accepted contrary conclusions are rejected as outside this profile. Finite premise-founded construction, including cyclic rule graphs without repeated branch conclusions. Grounded, preferred and stable extensions; credulous or sceptical conclusion queries; minimum-rank, rank-based last-link or reviewed partial last-link preference. Host budgets bound construction and extension search; exhaustion is incomplete; no inferred prose semantics, full ASPIC+ expressiveness or general EAL/ASPIC+ equivalence",
+        },
+        "aspic_export": {
+            "cli": "export-aspic RESULT.json --output VIEW.json",
+            "input": "A previously computed compiled result, or an explicit theory and matching formal solver result",
+            "output": "aspic-view/3 JSON for the separate Vue/TypeScript visualisation app: arguments, direct derivations, grounded labels, selected extensions and query mode, explicit preferences and execution budgets, defeat witnesses, typed unavailable-evidence issues and supplied source locations",
+            "meaning": "Recompute the bounded formal result and require exact agreement before exporting. The separate app imports JSON locally; neither export nor viewing collects evidence or authenticates supplied provenance",
+        },
+        "typed_bindings": describe_bindings(registry=registry),
+        "composition": "Default EAL/3 computes the least-information fixed point of authored conjunctive support, alternative derivations and objection attacks. Objections can depend on claim subarguments; targeting an objection expresses defence. Attack cycles may remain undecided. Default assessment does not construct ASPIC+ rule arguments or preference-sensitive defeat. The separate opt-in compiler constructs a bounded ASPIC+ snapshot from checked EAL declarations. Rejected acceptance does not assert falsity.",
+        "statuses": {
+            "valid": "Static language well-formedness only",
+            "incomplete": "A host budget or timeout prevented a complete calculation; no false or accepted conclusion is manufactured",
+            "supported": "At least one usable, uncontested derivation under the declared model",
+            "contested": "A usable derivation or dependency is challenged; no independent uncontested derivation",
+            "unsupported": "No usable derivation; does not imply false",
+            "out_of_scope": "The supplied environment does not match the declared conditions",
+        },
+        "workflow": ["describe", "validate", "plan", "collect_claim|collect", "reason", "packet|explain"],
+        "registered_workflow": ["register", "sources|find", "assess_known", "operator_explain_if_needed"],
+        "model_context": {
+            "schema": "EAL/model-context/2",
+            "packet_schema": "EAL/assessment-packet/2",
+            "meaning": "A decision-focused projection retains bounded authored statements and explicit prose_verified qualifications for selected and premise claims, checked method outputs, assumption applicability times and bounded field-level evidence failures. Formal support does not verify authored prose. Statement truncation and other omissions mark the summary incomplete. Complete source, acquisition values and trace identities remain in host state. Numeric method results are exposed through declared output contracts, not by copying raw tool records.",
+        },
+        "registered_assessment": "The developer registers exact EAL source and selected claims once. Later sessions identify an entry and claim; the host plans all relevant argument routes, reuses eligible observations at their original age, collects missing evidence, evaluates the declared methods and returns a bounded packet. Model-facing registered MCP calls require a trusted launcher --known-entry allowlist and use registered context. A text-only model can receive this packet from ModelContextAdapter without tool or native reasoning calls.",
+        "acquisition_plan": "eal_plan(source, claim) computes the complete potentially decisive evidence closure, including alternative arguments, transitive premises, backing, assumption validation, objections and defences. eal_collect_claim runs that plan with operator-granted tools.",
+        "tool_binding": "A sibling operator-owned TOML registry chooses command or json_file, bounded execution, optional parallel_safe and command environment inheritance. Registered claims use those bindings through the host. Only operator-declared independent read-only calls may overlap.",
+        "source_identity": "Collections bind exact root source bytes, imported-source digests and context. Imports contain EAL source only and resolve inside the operator workspace. Registered assessment creates a new collection for a revision and can reuse matching observations at their original age. Reasoning refuses a mismatched collection.",
+        "observation_import": {
+            "required_envelope_fields": ["value", "observed_at", "context", "request"],
+            "acquisition_request_fields": ["tool", "tool_version", "input", "context"],
+            "correspondence": "File observations must match the requested acquisition. Explicit stored-observation rebinding also checks the same evidence ID, environment, kind, request, context and operator binding, preserving the original measurement time.",
+            "interpretation": "Matching metadata checks correspondence; it does not authenticate a measurement. Importing again preserves original observation time.",
+        },
+        "time": "Timezone-aware ISO-8601; applicability intervals are [valid_from, valid_until). Evidence age is usable through max_age inclusively. New ingestion does not refresh original observation time.",
+        "interpretation": "Statements and rationales are prose. Typed bindings check represented correspondence and numerical predicates, not empirical truth. Model premises, scope, sampling and causal assumptions require their own grounds. Reusing an observation does not create independent evidence.",
+        "example": EXAMPLE,
+    }