notegraph 0.2.0__tar.gz → 0.3.0__tar.gz

{notegraph-0.2.0/notegraph.egg-info → notegraph-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: notegraph
-Version: 0.2.0
+Version: 0.3.0
 Summary: Decision-graph and goal notebook for a git repo, shared across every worktree
 Author-email: 송재훈 <sjh030504@i-screammedia.com>
 License: MIT

{notegraph-0.2.0 → notegraph-0.3.0}/note_cli/SKILL.md

@@ -37,15 +37,20 @@ to agents working other branches in parallel.
 - **Only criteria named in the current goal are accepted.** If a rubric no
   longer fits the work, change the goal (`note goal --set ... --criterion ...`)
   rather than inventing a criterion at score time.
-- **Totals are recomputed against the current goal.** When the goal moves, old
-  attempts visibly drop until they are re-judged. That is correct.
+- **Totals are recomputed against the current goal**, so when the goal moves,
+  every earlier score is marked `STALE` and `note check` fails until you
+  re-score. A stale total is arithmetic, not judgement — do not compare arms
+  on one. `note goal --set` tells you how many scores it just invalidated.
 
 ## Correcting a node
 
 Nothing is ever edited in place. `note supersede <id> "corrected content"`
 appends a new node and an edge `old -superseded_by-> new`, which moves the
 frontier to the new node and takes the old one out of `note tails`. Type and
-tags are inherited unless you pass new ones.
+tags are inherited unless you pass new ones, along with whatever goal the
+original targeted — so the correction is already linked and only needs a
+score. The node you corrected stops competing for best and stops being asked
+for one.
 
 ## Orientation
 

{notegraph-0.2.0 → notegraph-0.3.0}/note_cli/_cli_check.py

@@ -78,8 +78,40 @@ def main_check():
     after = {n["id"] for n in graphtails()}
     assert 5 not in after and 6 in after, (before, after)
 
+    # supersede carries the targets edge forward, so the correction is already
+    # linked and only needs judging
+    from note_cli import store as _st
+    assert {"from": 6, "to": 1, "relation": "targets"} in _st.read("edges.jsonl")
+    run("score", "6", "consistency=0.5")
+
+    # and the node it corrected must no longer compete for best
+    from note_cli import goal as _g
+    rows, _unassigned = _g.rollup()
+    winners = [b[1] for _n, b in rows if b]
+    assert 5 not in winners, f"superseded #5 still winning: {winners}"
+
     run("status")
 
+    # the bug this feature exists for: moving the goal must not leave a
+    # confident-looking number with `check` calling it clean
+    import time
+    time.sleep(1)                       # timestamps are second-resolution
+    run("goal", "--set", "moved the bar",
+        "--criterion", "consistency:3:style holds",
+        "--criterion", "renamed:1:was legibility")
+    try:
+        run("check")
+        raise AssertionError("expected SystemExit(1): every score is now stale")
+    except SystemExit as e:
+        assert e.code == 1, e.code
+    run("goals")                        # must mark the stale rows, not just print
+    run("show", "3")
+
+    for nid in ("2", "3", "4", "5", "6"):
+        run("score", nid, "consistency=0.5", "renamed=0.5")
+    run("check")                        # re-scored under the new goal: clean again
+
+
     # --version must report what the package metadata says, so a bug report
     # names a real release
     from note_cli import __version__

{notegraph-0.2.0 → notegraph-0.3.0}/note_cli/cli.py

@@ -50,8 +50,13 @@ def cmd_goal(args):
         criteria = [goalmod.parse_criterion(c) for c in (args.criterion or [])]
         if not criteria:
             raise SystemExit("--set needs at least one --criterion name:weight:rubric")
+        was_fresh = [s for s in goalmod.latest_scores().values()
+                     if not goalmod.is_stale(s, goalmod.current_goal())]
         goalmod.set_goal(args.set, criteria)
         print(f"goal set, {len(criteria)} criteria")
+        if was_fresh:
+            print(f"{len(was_fresh)} score(s) now judged against an older goal — "
+                  f"`note check` lists them")
         return
     g = goalmod.current_goal()
     if not g:
@@ -87,18 +92,26 @@ def cmd_score(args):
     print(f"{goalmod.add_score(args.id, scores, args.note):.3f}")
 
 
+def _stale_mark(score, g):
+    return "  STALE — judged against an older goal" if goalmod.is_stale(score, g) else ""
+
+
 def cmd_goals(args):
     rows, unassigned = goalmod.rollup()
+    g = goalmod.current_goal()
     for n, best in rows:
         if best:
-            total, aid, ts = best
-            print(f"{n['id']:>4}  {n['content']}\n        best {total:.3f} from #{aid} ({ts})")
+            total, aid, score = best
+            mark = _stale_mark(score, g)
+            print(f"{n['id']:>4}  {n['content']}\n"
+                  f"        best {total:.3f} from #{aid} ({score['timestamp']}){mark}")
         else:
             print(f"{n['id']:>4}  {n['content']}\n        (no scored attempts)")
     if unassigned:
         print("\n(unassigned) — scored but targeting no goal:")
-        for n, total, ts in unassigned:
-            print(f"{n['id']:>4}  {total:.3f}  {n['content']} ({ts})")
+        for n, total, score in unassigned:
+            print(f"{n['id']:>4}  {total:.3f}  {n['content']} "
+                  f"({score['timestamp']}){_stale_mark(score, g)}")
 
 
 def cmd_supersede(args):
@@ -109,9 +122,9 @@ def cmd_supersede(args):
 def cmd_check(args):
     """Exit nonzero while any attempt is loose, so a hook or an agent can gate
     on it rather than trusting itself to remember the loop."""
-    untargeted, unscored = goalmod.unfinished()
-    if not untargeted and not unscored:
-        print("clean: every attempt targets a goal and carries a score")
+    untargeted, unscored, stale = goalmod.unfinished()
+    if not untargeted and not unscored and not stale:
+        print("clean: every attempt targets a goal and is scored against the current one")
         return
     if untargeted:
         print("attempts targeting no goal — `note link <id> <goal> --rel targets`:")
@@ -121,6 +134,11 @@ def cmd_check(args):
         print("attempts with no score — `note score <id> name=0.0-1.0`:")
         for n in unscored:
             print(_line(n))
+    if stale:
+        print("attempts judged against an older goal — their totals are "
+              "arithmetic, not judgement. Re-score them:")
+        for n in stale:
+            print(_line(n))
     raise SystemExit(1)
 
 
@@ -152,7 +170,8 @@ def cmd_show(args):
     if s:
         g = goalmod.current_goal()
         total = goalmod.weighted_total(s["scores"], g["criteria"] if g else [])
-        print(f"  score: {total:.3f}  {s['scores']}  ({s['timestamp']})")
+        print(f"  score: {total:.3f}  {s['scores']}  ({s['timestamp']})"
+              f"{_stale_mark(s, g)}")
         if s.get("note"):
             print(f"         {s['note']}")
     if args.id in {m["id"] for m in graphmod.merges(nodes, edges)}:

{notegraph-0.2.0 → notegraph-0.3.0}/note_cli/goal.py

@@ -21,6 +21,39 @@ def set_goal(text, criteria):
                                  "timestamp": store.now()})
 
 
+SUPERSEDED = "superseded_by"
+
+
+def superseded_ids(edges):
+    """Nodes that have been corrected by a later one.
+
+    Append-only never removes anything, so a superseded node keeps its goal
+    link and its score. Both the rollup and the loop check have to skip them:
+    otherwise a corrected-away attempt goes on competing for best, and a goal
+    revision makes the check demand that it be re-judged.
+    """
+    return {e["from"] for e in edges if e["relation"] == SUPERSEDED}
+
+
+def goal_revision(g):
+    """Identity of a goal revision. `goal.jsonl` is append-only and written
+    under the lock, so its timestamp identifies the revision."""
+    return g["timestamp"] if g else None
+
+
+def is_stale(score, g):
+    """True when this score was judged against a different goal revision than
+    the current one.
+
+    Its total is still computed — against today's criteria — which is exactly
+    why it has to be flagged: the number looks like a judgement and is
+    arithmetic. A score line written before this field existed has no
+    `goal_ts`, so it reads stale, which is the honest answer: we do not know
+    what standard it was made against.
+    """
+    return score.get("goal_ts") != goal_revision(g)
+
+
 def parse_criterion(s):
     parts = s.split(":", 2)          # first two colons only; rubrics contain colons
     if len(parts) != 3:
@@ -69,6 +102,7 @@ def add_score(nid, scores, note=None):
         if unknown:
             raise SystemExit(f"unknown criteria {unknown}; goal has {sorted(known)}")
         store.append(SCORE_FILE, {"node": nid, "scores": scores, "note": note,
+                                  "goal_ts": goal_revision(g),
                                   "timestamp": store.now()})
         return weighted_total(scores, g["criteria"])
 
@@ -86,6 +120,7 @@ def rollup():
     latest = latest_scores()
     by_id = {n["id"]: n for n in nodes}
 
+    corrected = superseded_ids(edges)
     targeted, assigned = {}, set()
     for e in edges:
         if e["relation"] == "targets":
@@ -98,10 +133,10 @@ def rollup():
             continue
         best = None
         for aid in targeted.get(n["id"], ()):
-            if aid not in latest:
+            if aid not in latest or aid in corrected:
                 continue
             cand = (weighted_total(latest[aid]["scores"], criteria), aid,
-                    latest[aid]["timestamp"])
+                    latest[aid])
             if best is None or cand[0] > best[0]:
                 best = cand
         rows.append((n, best))
@@ -109,31 +144,40 @@ def rollup():
     # a scored attempt with no goal is a linking mistake, not a category of
     # work — it must not simply vanish from the rollup
     unassigned = [(by_id[i], weighted_total(latest[i]["scores"], criteria),
-                   latest[i]["timestamp"])
-                  for i in sorted(latest) if i not in assigned and i in by_id]
+                   latest[i])
+                  for i in sorted(latest)
+                  if i not in assigned and i in by_id and i not in corrected]
     return rows, unassigned
 
 
 def unfinished():
-    """Attempts that break the loop, as (untargeted, unscored).
+    """Attempts that break the loop, as (untargeted, unscored, stale).
 
     Only `attempt` nodes are held to it — a decision or a plain note has
     nothing to score. This is what `note check` exits nonzero on, so a hook
     or an agent can gate on it instead of trusting itself to remember.
+
+    `stale` is the one that used to pass silently: the attempt is linked and
+    scored, but judged against a goal revision that is no longer current, so
+    its total is arithmetic rather than judgement.
     """
     nodes = store.read("nodes.jsonl")
     edges = store.read("edges.jsonl")
     latest = latest_scores()
+    g = current_goal()
     targeting = {e["from"] for e in edges if e["relation"] == "targets"}
-    untargeted, unscored = [], []
+    corrected = superseded_ids(edges)
+    untargeted, unscored, stale = [], [], []
     for n in nodes:
-        if n["type"] != "attempt":
+        if n["type"] != "attempt" or n["id"] in corrected:
             continue
         if n["id"] not in targeting:
             untargeted.append(n)
         elif n["id"] not in latest:
             unscored.append(n)
-    return untargeted, unscored
+        elif is_stale(latest[n["id"]], g):
+            stale.append(n)
+    return untargeted, unscored, stale
 
 
 def demo():
@@ -196,15 +240,54 @@ def demo():
     assert [u[0]["id"] for u in unassigned] == [orphan], unassigned
 
     # orphan targets nothing; a1/a2 target g and are scored
-    untargeted, unscored = unfinished()
+    untargeted, unscored, stale = unfinished()
     assert [n["id"] for n in untargeted] == [orphan], untargeted
-    assert unscored == [], unscored
+    assert unscored == [] and stale == [], (unscored, stale)
 
     fresh = store.add_node("just tried, not judged yet", type="attempt")
     store.add_edge(fresh, g, "targets")
-    untargeted, unscored = unfinished()
+    untargeted, unscored, stale = unfinished()
     assert [n["id"] for n in untargeted] == [orphan], untargeted
     assert [n["id"] for n in unscored] == [fresh], unscored
+    assert stale == [], stale
+
+    # a score carries the goal revision it was judged against
+    assert latest_scores()[a1]["goal_ts"] == current_goal()["timestamp"]
+    assert not is_stale(latest_scores()[a1], current_goal())
+
+    # renaming a criterion must NOT silently leave a confident-looking number
+    import time
+    time.sleep(1)                       # timestamps are second-resolution
+    set_goal("moved the bar", [{"name": "consistency", "weight": 3.0, "rubric": "x"},
+                               {"name": "renamed", "weight": 1.0, "rubric": "y"}])
+    assert is_stale(latest_scores()[a1], current_goal())
+    untargeted, unscored, stale = unfinished()
+    assert [n["id"] for n in stale] == [a1, a2], stale   # orphan is untargeted, fresh unscored
+
+    # a re-score under the new goal clears it
+    add_score(a1, {"consistency": 1.0})
+    assert not is_stale(latest_scores()[a1], current_goal())
+    _, _, stale = unfinished()
+    assert [n["id"] for n in stale] == [a2], stale
+
+    # a score line predating this feature has no goal_ts and must read stale
+    assert is_stale({"scores": {}}, current_goal())
+
+    # --- a corrected attempt must stop competing ---
+    add_score(a2, {"consistency": 1.0, "renamed": 1.0})     # a2 is now the best
+    rows, _ = rollup()
+    assert rows[0][1][1] == a2, rows[0]
+
+    fixed = store.supersede(a2, "arm B1_P2, corrected")
+    rows, _ = rollup()
+    best_id = rows[0][1][1] if rows[0][1] else None
+    assert best_id != a2, "a superseded attempt must not win the rollup"
+    assert best_id == a1, (best_id, a1)          # fixed is unscored, so a1 wins
+
+    # and it must not be demanded back by the loop check either
+    _, unscored, stale = unfinished()
+    assert a2 not in [n["id"] for n in unscored] + [n["id"] for n in stale]
+    assert fixed in [n["id"] for n in unscored], "the correction still needs judging"
 
     print("goal: ok")
 

{notegraph-0.2.0 → notegraph-0.3.0}/note_cli/store.py

@@ -138,6 +138,14 @@ def supersede(old, content, type=None, tags=()):
             "timestamp": now(),
         })
         append("edges.jsonl", {"from": old, "to": nid, "relation": "superseded_by"})
+        # Carry the goal links forward. Without this the correction targets
+        # nothing while the corrected node keeps its link AND its score, so
+        # `note goals` can report an attempt that was corrected away as the
+        # best one — silently.
+        for e in read("edges.jsonl"):
+            if e["from"] == old and e["relation"] == "targets":
+                append("edges.jsonl", {"from": nid, "to": e["to"],
+                                       "relation": "targets"})
     return nid
 
 
@@ -198,6 +206,9 @@ def demo():
     assert rows[new_id]["type"] == rows[a]["type"], "type is inherited"
     assert rows[new_id]["tags"] == rows[a]["tags"], "tags are inherited"
     assert {"from": a, "to": new_id, "relation": "superseded_by"} in read("edges.jsonl")
+    # the correction must inherit what the original targeted, or the rollup
+    # keeps crediting the node that was corrected away
+    assert {"from": new_id, "to": g, "relation": "targets"} in read("edges.jsonl")
     try:
         supersede(999, "nope")
         raise AssertionError("expected SystemExit")

{notegraph-0.2.0 → notegraph-0.3.0/notegraph.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: notegraph
-Version: 0.2.0
+Version: 0.3.0
 Summary: Decision-graph and goal notebook for a git repo, shared across every worktree
 Author-email: 송재훈 <sjh030504@i-screammedia.com>
 License: MIT

{notegraph-0.2.0 → notegraph-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "notegraph"
-version = "0.2.0"
+version = "0.3.0"
 description = "Decision-graph and goal notebook for a git repo, shared across every worktree"
 readme = "README.md"
 license = { text = "MIT" }