hypgraph 0.5.0__tar.gz → 0.5.1__tar.gz

{hypgraph-0.5.0 → hypgraph-0.5.1}/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.5.1 — 2026-10-26
+
+What wiring HypSwarm's scheduler to the stages (P2) found the workflows had no honest ending or no right answer for:
+- **Declining a thesis is a decision.** A decision `kind=no_position` based on the claim meets `positioned` and
+  `position_sized` ("1 declined"); only `kind=position` needs size, stop, review date and `paper=true`.
+- **An honest "it can't be answered" settles a question whatever its stage.** A checked claim of kind
+  `inconclusive` or `exclusion` that answers the question (no source says it; too few trades; infeasible) completes
+  it; `stage()` reports `settled_by` and `settled_how`. The claim still needs its evidence — the search's own
+  result ("read 3 of 3 pages; 0 mention it") is what it derives from.
+- **A verified failure settles a software requirement.** A checked claim resting on an instrument-recorded
+  *negative* result ("1 of 2 checks pass", re-run by the instrument) completes the question; `tests_pass_current`
+  stays unmet and `requirements_verified_current` says so.
+- **The same bytes, registered again, are one node that learns.** A second `create` of an artifact with the same
+  sha adds the links given now (`part_of` a question, `supersedes`) and, when the node was untyped, its `kind` /
+  `meta` / `path` as a new version. Before, the task's own file silently swallowed the diff registered on it.
+- **A decision that settles a work order is the harness's, not the question's** (`decided` ignores it).
+- **optimization gains a `checked` stage** (the verifier checks the claim after the result): a question settles on a
+  checked claim, so the workflow had to ask for one.
+- A review order's target predates the order; `reviewed` / `result_reviewed` now ask that the *review* be new.
+- `report()` names experiments by aim and decisions by choice.
+
 ## 0.5.0 — 2026-10-26: profiles carry their discipline's workflow
 
 Each discipline's method, as the record enforces it — one page each in `docs/workflows/`, taken from the method

{hypgraph-0.5.0 → hypgraph-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hypgraph
-Version: 0.5.0
+Version: 0.5.1
 Summary: The evidence layer for AI research agents: a hash-chained research record that checks every claim as it is written and derives how well each is known.
 Project-URL: Homepage, https://hypgraph.com
 Project-URL: Documentation, https://hypgraph.com/engineers/

{hypgraph-0.5.0 → hypgraph-0.5.1}/docs/profile-workflows-plan.md

@@ -91,7 +91,11 @@ needs a migration story. P0 is a day and decides whether P1 is right. P3 is the
 `tests/test_workflows.py`; CHANGELOG). The schema change turned out additive (fields and relation endpoints), so
 no migration: `@1` records derive exactly as before, the `@2` profiles opt in. Left for later phases, each named in
 its spec: per-workflow evidence rank (documented, not derived), the knowledge re-fetch check, CI as the software
-instrument, mechanical feasibility recomputation (P3). P2 (HypSwarm issues orders from stages) is next.
+instrument, mechanical feasibility recomputation (P3). **P2 built in HypSwarm 0.1.0a4** (`scheduler.py`: stage
+orders, review on the node the previous gate produced, the record's word on done; the examples' scripted models walk
+the stages; the discovery stub run through its stages). P2 fed back into hypgraph 0.5.1: honest endings the stages
+lacked (a declined thesis, an inconclusive answer, a verified failure), artifacts that learn their kind on
+re-registration, optimization's `checked` stage. P3 is next.
 
 ## 4. What stays as it is, on purpose
 

{hypgraph-0.5.0 → hypgraph-0.5.1}/docs/workflows/optimization.md

@@ -20,7 +20,8 @@ model is a hypothesis about the problem and can be wrong independently of the so
 | 4 | solved | run `executes` the experiment, `uses` the instance; result with `objective`, `feasible`, `bound`, `gap`, `runtime_s`, `solution` artifact | `feasible_bounded` (today) | solver, instrument |
 | 5 | verified | review by the verifier: the solution satisfies the constraints of the **instance artifact** (recomputed, not trusted) | `reviewed` with method naming the check | verifier |
 | 6 | claimed | claim "best found, gap g" or "optimal" with the bound; `OPTIMAL_WITHOUT_BOUND` (today) | `claim_made` | solver |
-| 7 | recommended | decision `based_on` the claim: the incumbent to use, with the sensitivity note | `decided` **new** | lead |
+| 7 | checked | the verifier checks the claim's wording against the result (a question settles on a checked claim) | `reviewed` | verifier |
+| 8 | recommended | decision `based_on` the claim: the incumbent to use, with the sensitivity note | `decided` **new** (optional) | lead |
 
 Infeasibility is a settled outcome: a result with `feasible: false` and a claim of `kind=exclusion` ("no feasible
 assignment exists: total capacity 7 < 8 customers") settles the question. Today that path trips

{hypgraph-0.5.0 → hypgraph-0.5.1}/docs/workflows/software.md

@@ -76,3 +76,8 @@ superseded heads, listed as superseded); open requirements.
    reads, so a CI reproducer only has to file a lab run that `uses` the diff.
 
 Also decided: `REVIEW_BY_AUTHOR` covers the diff's author (built); `supersedes` joins artifacts (built).
+
+**Verified failure (0.5.1).** When the instrument's run on the current head records a negative result ("1 of 2
+checks pass"), `tests_pass_current` can never be met; a checked claim resting on that result settles the
+requirement as a verified failure (`stage()` says so), and `requirements_verified_current` stays unmet. The record
+holds why the change did not ship.

{hypgraph-0.5.0 → hypgraph-0.5.1}/src/hypgraph/__init__.py

@@ -16,7 +16,7 @@ Standing is derived on every read, never stored; every write is an event in a SH
 their numbers; reviews pin versions; independence is counted, not assumed. See https://hypgraph.com.
 """
 
-__version__ = "0.5.0"
+__version__ = "0.5.1"
 
 from .bundle import verify_bundle  # noqa: E402
 from .graph import Author, Graph, GraphError, file_sha256  # noqa: E402

{hypgraph-0.5.0 → hypgraph-0.5.1}/src/hypgraph/graph.py

@@ -558,7 +558,7 @@ class Graph:
                 if type == "artifact":
                     node_id = "a-" + str(body["sha256"]).lower()[:16]
                     if node_id in s.nodes:
-                        return self.get(node_id)
+                        return self._absorb_artifact(s, node_id, body, links, author, at=at)
                 nid = node_id or ("inv-" + secrets.token_hex(4) if type == "investigation"
                                   else "n" + secrets.token_hex(6))
                 if nid in s.nodes:
@@ -773,6 +773,50 @@ class Graph:
         if lines:
             out["orders"] = lines
 
+    def _absorb_artifact(self, s: D.Snap, nid: str, body: dict, links: list, author: str, *, at: str = "") -> dict:
+        """The same bytes are one node. A second registration adds what the first lacked: the links given now
+        (part_of a question, supersedes an older file) and, when the node was untyped, its kind / meta / path — a
+        classification of the bytes, by anyone, as a new version (the bytes never change). Called inside create()'s
+        lock; the caller's finally refreshes the snapshot."""
+        n = s.nodes[nid]
+        at = self._when(author, at)
+        have = {(e["rel"], e["dst"]) for e in s.out.get(nid, [])} | {(e["rel"], e["src"]) for e in s.inn.get(nid, [])}
+        oriented = [self._orient(s, *self._link_spec(nid, l)) for l in links]
+        pending = [(a, rel, b, l) for (a, rel, b, _f), l in zip(oriented, links)
+                   if (rel, b if a == nid else a) not in have]
+        for a, rel, b, _l in pending:
+            self._check_link(s, a, rel, b)
+        merged = None
+        if not n["body"].get("kind") and body.get("kind"):
+            merged = clean_body("artifact", {**n["body"], **{k: v for k, v in body.items()
+                                                             if k in ("kind", "meta", "path", "format", "size") and v}})
+            if author not in self.policy.curators:
+                np_ = profiles.node_issues(s, n["inv"], "artifact", merged, [(a, rel, b) for a, rel, b, _l in pending])
+                if np_:
+                    raise GraphError("artifact refused:\n- " + "\n- ".join(p.text() for p in np_), [p.to_dict() for p in np_])
+        if not pending and merged is None:
+            return self.get(nid)
+
+        def write(con):
+            if merged is not None:
+                v = con.execute("SELECT MAX(v) FROM versions WHERE node=?", (nid,)).fetchone()[0] + 1
+                sha = self._version_row(con, nid, v, at, author, f"typed as {merged.get('kind')}", merged)
+                self._event(con, author, "revise", nid, {"v": v, "reason": f"typed as {merged.get('kind')}",
+                                                         "body_sha": sha}, at)
+            for a, rel, b, l in pending:
+                self._insert_edge(con, s, a, rel, b, l.get("data") or {}, l.get("why") or "", author, at)
+        self._transaction(write)
+        self._after_write()
+        out = self.get(nid)
+        notes = ["the same bytes were already registered: one node"]
+        if merged is not None:
+            notes.append(f"typed as {merged.get('kind')} (v{out['v']})")
+        if pending:
+            notes.append("linked: " + ", ".join(f"{rel} {s.nodes[b if a == nid else a].get('code') or b}"
+                                                for a, rel, b, _l in pending))
+        out["notes"] = notes
+        return out
+
     def _may_revise(self, s: D.Snap, author: str, n: dict) -> bool:
         return author in {n["created_by"]} | self.policy.curators or author in D.board(s, n["id"])
 

{hypgraph-0.5.0 → hypgraph-0.5.1}/src/hypgraph/plan.py

@@ -229,7 +229,8 @@ def _brief_min(s: D.Snap, i: str) -> dict:
     m = s.nodes[i]
     b = m["body"]
     return {"id": i, "code": m.get("code", ""), "type": m["type"],
-            "title": str(b.get("title") or b.get("statement") or b.get("text") or b.get("summary") or i)[:160]}
+            "title": str(b.get("title") or b.get("statement") or b.get("text") or b.get("summary") or b.get("aim")
+                         or b.get("choice") or b.get("citation") or b.get("name") or b.get("path") or i)[:160]}
 
 
 def report(g: "Graph", inv: str) -> dict:

{hypgraph-0.5.0 → hypgraph-0.5.1}/src/hypgraph/profiles.py

@@ -347,6 +347,7 @@ OPTIMIZATION2 = _add(Profile(
                 _S("solved", "a result: objective, feasible, bound / gap (or infeasible)", "solved", "solver, instrument"),
                 _S("verified", "a verifier recomputed feasibility and checked the result", "result_reviewed", "verifier"),
                 _S("claimed", "a claim: best found with its gap, or optimal with its bound", "claim_made", "solver"),
+                _S("checked", "the verifier checked the claim's wording against the result", "reviewed", "verifier"),
                 _S("recommended", "a decision: the incumbent to use, with its sensitivity", "decided", "lead", optional=True)),
         invalidates=("uses",),
         artifacts={"instance": (), "solution": ("objective", "feasible"), "model": ("solver",)},

{hypgraph-0.5.0 → hypgraph-0.5.1}/src/hypgraph/workflow.py

@@ -27,6 +27,7 @@ from . import language as L
 from .checks import Problem
 from .profiles import (_EDGE, _OPTIMAL, _PASSES, Profile, _cites_source, _has, _instrument_backed, _lab_positive,
                        _live, _producing_run, _vals, profile_of)
+from .schema import POSITIVE
 
 _LIVE_ORDER = re.compile(r"\b(live (order|trade|position)|market order|limit order|place[ds]? (an? )?order|"
                          r"execute[sd]? (a |the )?trade|sen[dt] (it |the order )?to (the )?(exchange|broker|venue)|"
@@ -210,9 +211,21 @@ def g_claim_made(sc: Scope, now: str) -> dict:
     return _g(bool(cs), cs, f"no live claim answers {sc.code(sc.root)}")
 
 
+def _checked_since(sc: Scope, nid: str) -> bool:
+    """Checked — and, under an order, by a review written since the order (the node itself may well predate it:
+    a review order's target is the claim or result it is to review)."""
+    s = sc.s
+    if (D.state(s, nid).get("review") or {}).get("state") != "checked":
+        return False
+    if not sc.since:
+        return True
+    return any(e["rel"] == "reviews" and s.nodes[e["src"]]["created_at"] >= sc.since
+               and s.nodes[e["src"]]["body"].get("verdict") in POSITIVE for e in s.inn.get(nid, []))
+
+
 def g_reviewed(sc: Scope, now: str) -> dict:
     s = sc.s
-    checked = [c for c in sc.fresh(sc.claims) if (D.state(s, c).get("review") or {}).get("state") == "checked"]
+    checked = [c for c in sc.claims if _live(s, c) and _checked_since(sc, c)]
     fresh = [c for c in checked if not D.stale(s, c)]
     if fresh:
         return _g(True, fresh, "")
@@ -224,7 +237,8 @@ def g_reviewed(sc: Scope, now: str) -> dict:
 
 
 def g_decided(sc: Scope, now: str) -> dict:
-    ds = sc.fresh(sc.decisions)
+    # a decision that settles a work order is the harness accepting work, not a decision on the question
+    ds = [d for d in sc.fresh(sc.decisions) if not any(e["rel"] == "settles" for e in sc.s.out.get(d, []))]
     return _g(bool(ds), ds, f"no decision is based on a claim or result on {sc.code(sc.root)}")
 
 
@@ -238,8 +252,9 @@ def _current_diffs(sc: Scope, kind: str) -> tuple[list[str], list[str]]:
 
 
 def g_diff_registered(sc: Scope, now: str) -> dict:
+    # the question's current diff is a state, not work since the order: a change registered before the order (the
+    # task's own files are artifacts from the start, and the same bytes are one node) meets it
     live, _old = _current_diffs(sc, "diff")
-    live = [a for a in live if not sc.since or sc.s.nodes[a]["created_at"] >= sc.since]
     return _g(bool(live), live[:1], f"no live artifact kind=diff (meta: base_sha, head_sha, files) part_of "
                                     f"{sc.code(sc.root)}")
 
@@ -331,12 +346,18 @@ def _positions(sc: Scope) -> list[str]:
     return [d for d in sc.decisions if _live(sc.s, d) and (sc.s.nodes[d]["body"].get("kind") or "") == "position"]
 
 
+def _no_positions(sc: Scope) -> list[str]:
+    """Decisions not to trade (kind=no_position): a decision too — the thesis was judged and declined."""
+    return [d for d in sc.decisions if _live(sc.s, d) and (sc.s.nodes[d]["body"].get("kind") or "") == "no_position"]
+
+
 def g_positioned(sc: Scope, now: str) -> dict:
     s = sc.s
     ds = [d for d in _positions(sc) if (not sc.since or s.nodes[d]["created_at"] >= sc.since)
           and not _position_missing(s.nodes[d]["body"])]
-    return _g(bool(ds), ds, f"no decision kind=position (size, stop, review_date, paper=true) based on a claim on "
-                            f"{sc.code(sc.root)}")
+    ds += [d for d in _no_positions(sc) if not sc.since or s.nodes[d]["created_at"] >= sc.since]
+    return _g(bool(ds), ds, f"no decision based on a claim on {sc.code(sc.root)}: kind=position (size, stop, "
+                            "review_date, paper=true), or kind=no_position when the thesis is declined")
 
 
 def _past_review(sc: Scope, d: str, now: str) -> bool:
@@ -378,7 +399,7 @@ def g_solved(sc: Scope, now: str) -> dict:
 
 def g_result_reviewed(sc: Scope, now: str) -> dict:
     s = sc.s
-    rs = [r for r in sc.fresh(sc.results) if (D.state(s, r).get("review") or {}).get("state") == "checked"]
+    rs = [r for r in sc.results if _live(s, r) and _checked_since(sc, r)]
     return _g(bool(rs), rs, f"no result on {sc.code(sc.root)} is checked by a reviewer")
 
 
@@ -401,6 +422,25 @@ def evaluate_predicate(p: str, s: D.Snap, t: str, at: str, inv: str, who: str =
     return GATES[p](Scope(s, t, since=at, who=who), s.now)
 
 
+def _claim_results(s: D.Snap, c: str) -> list[str]:
+    rs = [e["src"] for e in s.inn.get(c, []) if e["rel"] == "supports" and s.nodes[e["src"]]["type"] == "result"]
+    rs += [e["dst"] for e in s.out.get(c, []) if e["rel"] == "derived_from" and s.nodes[e["dst"]]["type"] == "result"]
+    return _uniq(rs)
+
+
+def _lab_negative(s: D.Snap, r: str) -> bool:
+    """The instrument stands behind a failure: the result's own lab run, or a live lab run replicating the run that
+    produced it, has a live result with outcome negative."""
+    run = _producing_run(s, r)
+    if not run:
+        return False
+    labs = [run] if s.nodes[run]["body"].get("kind") == "lab" else []
+    labs += [e["src"] for e in s.inn.get(run, []) if e["rel"] == "replicates" and s.nodes[e["src"]]["body"].get("kind") == "lab"]
+    return any(_live(s, lab) and any(s.nodes[e["dst"]]["type"] == "result" and s.nodes[e["dst"]]["body"].get("outcome") == "negative"
+                                     and _live(s, e["dst"]) for e in s.out.get(lab, []) if e["rel"] == "produced")
+               for lab in labs)
+
+
 # ── the derived stage ──────────────────────────────────────────────
 
 def stage_of(s: D.Snap, t: str, now: str = "") -> dict:
@@ -422,6 +462,23 @@ def stage_of(s: D.Snap, t: str, now: str = "") -> dict:
         if stage is None and not r["met"] and not st.optional:
             stage, nxt = (i, st.name), r["why"]
     stages = p.workflow.stages
+    # An honest "it can't be answered" ends a question whatever its stage: a checked claim of kind inconclusive
+    # (or exclusion) that answers it — no source found, too few trades, infeasible. The record holds the reason.
+    checked = [c for c in sc.claims if _live(s, c) and not D.stale(s, c)
+               and (D.state(s, c).get("review") or {}).get("state") == "checked"]
+    settled = [(c, f"{s.nodes[c]['body'].get('kind')} answer, checked") for c in checked
+               if (s.nodes[c]["body"].get("kind") or "finding") in ("inconclusive", "exclusion")]
+    # A verified failure settles a requirement too: a checked claim resting on an instrument-recorded negative
+    # result ("1 of 2 checks pass", re-run by the instrument) — the gate that asks for a passing run can never be met,
+    # and the record now holds why. Only workflows whose gate is an instrument pass have this ending.
+    if any(st.gate == "tests_pass_current" for st in stages):
+        settled += [(c, "verified failure: an instrument-recorded negative result, checked") for c in checked
+                    if any(_lab_negative(s, r) for r in _claim_results(s, c))]
+    if stage is not None and settled:
+        rv = next((i for i, st in enumerate(stages) if st.gate == "reviewed"), len(stages) - 1)
+        return {**base, "workflow": True, "stage": stages[rv].name, "index": rv + 1, "of": len(stages),
+                "complete": True, "next": "", "gates": gates, "settled_by": sc.code(settled[0][0]),
+                "settled_how": settled[0][1]}
     if stage is None:                            # every required gate met: the stage is the last one whose gate is
         last = max(i for i, gt in enumerate(gates) if gt["met"])
         return {**base, "workflow": True, "stage": stages[last].name, "index": last + 1, "of": len(stages),
@@ -541,6 +598,25 @@ def review_refusal(p: Profile, s: D.Snap, target: str, author: str) -> str:
 
 # ── completion criteria the workflows add ──────────────────────────
 
+def _backed_fresh(s: D.Snap, r: str) -> bool:
+    """A result the instrument stands behind on the current artifacts: its own lab run, or a live lab run that
+    replicates the run that produced it with a positive result — and every artifact that lab run used is live, and
+    the result itself is not stale."""
+    if D.stale(s, r):
+        return False
+    run = _producing_run(s, r)
+    if not run:
+        return False
+    labs = [run] if s.nodes[run]["body"].get("kind") == "lab" else []
+    labs += [e["src"] for e in s.inn.get(run, []) if e["rel"] == "replicates" and s.nodes[e["src"]]["body"].get("kind") == "lab"]
+    for lab in labs:
+        if not _live(s, lab) or not _positive_results(s, lab):
+            continue
+        if all(D.lifecycle(s, a) == "active" for a in _uses(s, lab)):
+            return True
+    return False
+
+
 def _checked_claims(s: D.Snap, q: str) -> list[str]:
     return [e["src"] for e in s.inn.get(q, []) if e["rel"] == "answers" and s.nodes[e["src"]]["type"] == "claim"
             and _live(s, e["src"]) and (D.state(s, e["src"]).get("review") or {}).get("state") == "checked"]
@@ -557,7 +633,7 @@ def criterion(name: str, s: D.Snap, inv: str) -> dict:
             for c in _checked_claims(s, q):              # any checked answer resting on a fresh instrument run
                 rs = [e["src"] for e in s.inn.get(c, []) if e["rel"] == "supports"] + \
                      [e["dst"] for e in s.out.get(c, []) if e["rel"] == "derived_from"]
-                if any(s.nodes[r]["type"] == "result" and _lab_positive(s, r) and not D.stale(s, r) for r in rs):
+                if any(s.nodes[r]["type"] == "result" and _backed_fresh(s, r) for r in rs):
                     ok = True
                     break
             if not ok:
@@ -566,10 +642,14 @@ def criterion(name: str, s: D.Snap, inv: str) -> dict:
                 "current head" if qs and not bad else "no current instrument-run evidence for: " + ", ".join(bad)}
     if name == "position_sized":
         ds = [i for i, n in s.nodes.items() if n["inv"] == inv and n["type"] == "decision" and _live(s, i)
-              and (n["body"].get("kind") or "") == "position" and not _position_missing(n["body"])
-              and any(e["rel"] == "based_on" for e in s.out.get(i, []))]
-        return {"met": bool(ds), "why": f"{len(ds)} paper position(s) with size, stop and review date" if ds else
-                "no decision kind=position with size, stop, review_date and paper=true based on a claim"}
+              and any(e["rel"] == "based_on" for e in s.out.get(i, []))
+              and (((n["body"].get("kind") or "") == "position" and not _position_missing(n["body"]))
+                   or (n["body"].get("kind") or "") == "no_position")]
+        taken = sum(1 for d in ds if s.nodes[d]["body"].get("kind") == "position")
+        return {"met": bool(ds), "why": f"{taken} paper position(s) with size, stop and review date, "
+                f"{len(ds) - taken} declined" if ds else
+                "no decision based on a claim: kind=position with size, stop, review_date and paper=true, or "
+                "kind=no_position"}
     if name == "nothing_past_review":
         late = []
         for i, n in s.nodes.items():

{hypgraph-0.5.0 → hypgraph-0.5.1}/tests/test_workflows.py

@@ -361,3 +361,93 @@ def test_server_serves_stages():
     assert st == 200 and body["code"] == "Q1" and [x["gate"] for x in body["gates"]][:3] == ["stated", "diff_registered", "tests_pass_current"]
     st, body = dispatch(g, "GET", "/profiles")
     assert st == 200 and body["trading@2"]["workflow"]["decisions"] == {"position": ["size", "stop", "review_date", "paper"]}
+
+
+# ── 0.5.1: declining a thesis is a decision; an honest "can't be answered" settles a question ──
+
+def test_no_position_is_a_decision():
+    g, inv, q = _g("trading@2", reviewers=("risk",))
+    h = g.create(author="quant", type="hypothesis", inv=inv, fields={"statement": "Momentum over 12 months persists for a month.",
+                 "predictions": ["the top decile outperforms after costs out of sample"]}, links=[{"rel": "answers", "to": q}])["id"]
+    x = g.create(author="quant", type="experiment", inv=inv, fields={"aim": "Backtest 12-1 momentum.",
+                 "protocol": "In sample 2015-2021, out of sample 2022-2024; fees 10 bp, slippage 5 bp; 24 configurations.",
+                 "success_criteria": "positive out-of-sample return after costs"},
+                 links=[{"rel": "tests", "to": h, "data": {"expected": "positive oos return after costs"}}])["id"]
+    rs = _bt(g, inv, "quant", {"oos_return": {"value": -0.02}, "fees": {"value": 0.002}, "trials": {"value": 24}},
+             summary="Backtested the thesis out of sample: it loses after costs.", q=q, x=x)
+    c = g.create(author="quant", type="claim", inv=inv, fields={"statement": "The thesis has no edge out of sample: -0.02 a year after fees.",
+                 "scope": "Daily bars, 2022–2024 held out, after fees, 24 configurations tried."},
+                 links=[{"rel": "answers", "to": q}, {"rel": "derived_from", "to": rs}])["id"]
+    g.review(author="risk", target=c, verdict="checked", method="Re-ran the OOS window.", notes="Negative after costs, as stated.")
+    assert _stage(g, q) == ("positioned", 7, False)
+    g.create(author=H, type="decision", inv=inv, fields={"choice": "No position: the thesis loses after costs out of sample.",
+             "reasons": "A negative out-of-sample return after costs is not a thesis to fund.", "kind": "no_position"},
+             links=[{"rel": "based_on", "to": c}])
+    assert g.stage(q)["complete"]
+    comp = {x_["name"]: x_ for x_ in g.completion(inv)["criteria"]}
+    assert comp["position_sized"]["met"] and "1 declined" in comp["position_sized"]["why"] and comp["nothing_past_review"]["met"]
+
+
+def test_a_checked_inconclusive_answer_settles_a_question_without_a_source():
+    g, inv, q = _g("knowledge@2")
+    assert _stage(g, q) == ("sourced", 3, False)
+    # the search is a run; what it found (nothing) is a result; the honest answer derives from it
+    run = g.create(author="r", type="run", inv=inv, fields={"kind": "agent", "name": "search", "state": "succeeded"})["id"]
+    rs = g.create(author="r", type="result", inv=inv, fields={"summary": "Read 3 of 3 pages on the host; 0 mention decommissioning.",
+                  "values": {"pages_read": {"k": 3, "n": 3}, "mentions": {"value": 0}}, "outcome": "negative", "kind": "observed"},
+                  links=[{"rel": "produced", "from": run}])["id"]
+    c = g.create(author="r", type="claim", inv=inv, fields={"statement": "No page on the source host says when the dam was decommissioned.",
+                 "scope": "The 3 of 3 pages on the source host, read in full.", "kind": "inconclusive"},
+                 links=[{"rel": "answers", "to": q}, {"rel": "derived_from", "to": rs}])["id"]
+    assert _stage(g, q) == ("sourced", 3, False)                     # a claim alone settles nothing
+    g.review(author="critic", target=c, verdict="checked", method="Read the three pages.", notes="Nothing on decommissioning.")
+    x = g.stage(q)
+    assert x["complete"] and x["stage"] == "checked" and x["settled_by"] == "CL1" and "inconclusive" in x["settled_how"]
+
+
+def test_accepting_an_order_is_not_the_questions_decision():
+    g, inv, q = _g("scientific@2")
+    o = g.issue_work(author=H, inv=inv, target=q, assignee="w", objective="State a hypothesis for Q1.", done_when=[{"p": "hypothesis_stated"}])
+    g.create(author="w", type="hypothesis", inv=inv, fields={"statement": "Caching halves the latency.", "predictions": ["p50 halves"]},
+             links=[{"rel": "answers", "to": q}])
+    g.return_work(author="w", order=o["order"], note="stated")
+    assert g.settle(author=H, inv=inv)                               # a decision that settles the order, based on H1
+    assert not _gate(g, q, "decided")["met"]                         # … is the harness accepting work, not a decision on Q1
+    assert "X1" not in g.report(inv)["markdown"] or "n" not in g.report(inv)["markdown"]
+
+
+def test_registering_the_same_bytes_again_types_and_links_the_one_node():
+    g, inv, q = _g("software@2")
+    a = g.create(author=H, type="artifact", inv=inv, fields={"sha256": SHA_A, "path": "mod.py", "size": 20})   # the task's file
+    assert a["body"].get("kind") is None and not _gate(g, q, "diff_registered")["met"]
+    b = g.create(author="dev", type="artifact", inv=inv, fields={"sha256": SHA_A, "path": "mod.py", "kind": "diff",
+                 "meta": {"base_sha": "0000000", "head_sha": "1111111", "files": ["mod.py"]}}, links=[{"rel": "part_of", "to": q}])
+    assert b["id"] == a["id"] and b["v"] == 2 and b["body"]["kind"] == "diff" and "typed as diff" in " ".join(b["notes"])
+    assert any(e["rel"] == "part_of" for e in b["out"])
+    assert _gate(g, q, "diff_registered")["met"] and _gate(g, q, "diff_registered")["evidence"] == ["A1"]
+    c = g.create(author="dev", type="artifact", inv=inv, fields={"sha256": SHA_A, "kind": "diff"}, links=[{"rel": "part_of", "to": q}])
+    assert c["v"] == 2 and len([e for e in c["out"] if e["rel"] == "part_of"]) == 1       # idempotent: nothing added twice
+    with pytest.raises(GraphError, match="ARTIFACT_MISSING_FIELDS"):
+        g.create(author="dev", type="artifact", inv=inv, fields={"sha256": SHA_B, "path": "x.py"})
+        g.create(author="dev", type="artifact", inv=inv, fields={"sha256": SHA_B, "path": "x.py", "kind": "diff"})
+
+
+def test_a_verified_failure_settles_a_software_requirement():
+    g, inv, q = _g("software@2")
+    a1 = _diff(g, inv, q, "dev", SHA_A, "1111111")
+    run = g.create(author="tester", type="run", inv=inv, fields={"kind": "agent", "name": "checks", "state": "succeeded"},
+                   links=[{"rel": "uses", "to": a1, "data": {"role": "code"}}])["id"]
+    rs = g.create(author="tester", type="result", inv=inv, fields={"summary": "Ran the checks: 1 of 2 pass.",
+                  "values": {"passed": {"k": 1, "n": 2}}, "outcome": "negative"}, links=[{"rel": "produced", "from": run}])["id"]
+    lab = g.create(author="lab", type="run", inv=inv, fields={"kind": "lab", "name": "re-run", "state": "succeeded"},
+                   links=[{"rel": "replicates", "to": run, "data": {"differs": "same_code"}}, {"rel": "uses", "to": a1, "data": {"role": "code"}}])["id"]
+    g.create(author="lab", type="result", inv=inv, fields={"summary": "Re-ran the checks: 1 of 2 pass.",
+             "values": {"passed": {"k": 1, "n": 2}}, "outcome": "negative"}, links=[{"rel": "produced", "from": lab}])
+    c = g.create(author="tester", type="claim", inv=inv, fields={"statement": "The change does not meet the requirement: 1 of 2 checks pass.",
+                 "scope": "mod.py at head 1111111."}, links=[{"rel": "answers", "to": q}, {"rel": "derived_from", "to": rs}])["id"]
+    assert _stage(g, q) == ("verified", 3, False)                    # no passing run on the head, and there never will be
+    g.review(author="critic", target=c, verdict="checked", method="Read the lab run.", notes="One of two, as stated.")
+    x = g.stage(q)
+    assert x["complete"] and "verified failure" in x["settled_how"] and x["settled_by"] == "CL1"
+    assert not _gate(g, q, "tests_pass_current")["met"]
+    assert not next(c_ for c_ in g.completion(inv)["criteria"] if c_["name"] == "requirements_verified_current")["met"]