@appchy/jarvis 0.1.129 → 0.1.131

package/harness/harness/model.py

@@ -6,6 +6,7 @@ from pathlib import Path
 from .tree import (archive_dir, backlog_dir, BUCKETS, cli, DONE_TIER,
                    PRIORITIES, RESERVED_MD)
 from .frontmatter import as_list, parse_frontmatter, read_item, rewrite_file, title_of
+from . import tree as _tree
 
 
 def current_session_id() -> str:
@@ -222,6 +223,10 @@ class Version:
         self.end = (str(self.fm.get("end", "")).strip() or None)
         self.target = str(self.fm.get("target", "")).strip()
         self.released = str(self.fm.get("released", "")).strip()
+        # A cut deliberately sized past its ceiling says so here and stops being
+        # flagged — the same written escape an epic and a task already carry. A
+        # planned size is legal; an accreted one is what the flag is for.
+        self.one_goal = str(self.fm.get("one_goal", "")).strip()
         # Loose tasks — the pre-epic shape, still read so grandfathered versions
         # keep working untouched (v20/v24 hold live work at the reshape).
         self.tasks: dict = {b: [] for b in BUCKETS}
@@ -276,6 +281,27 @@ class Version:
         return bool(tasks) and not self.released and all(
             t.status == "complete" for t in tasks)
 
+    def open_tasks(self) -> list:
+        """Every task in this cut still owed — queued, in progress or blocked."""
+        return [t for t in self.all_tasks() if t.status in _tree.ACTIVE]
+
+    def over_ceiling(self) -> int:
+        """How many open tasks past its ceiling this cut is, or 0.
+
+        A FLAG, never a status and never a gate. Whether a cut is full says nothing
+        about whether it is planned, current or ready, so it sits beside those rather
+        than replacing one, and nothing refuses or re-routes work because of it. It
+        is what a person reads to know a reshape is owed — move work to a later cut,
+        or reshape an epic — so that the cut which closes is not a half-built one.
+
+        Zero for a released cut, which owes nothing, and zero for one that has written
+        why its size is deliberate: the difference between planning a big cut and
+        accreting one is recorded, never guessed.
+        """
+        if self.released or self.one_goal:
+            return 0
+        return max(0, len(self.open_tasks()) - _tree.CUT_TASK_CEILING)
+
     def status(self) -> str:
         """`released` if version.md carries a released date; `ready` if every task
         is complete and nobody has closed it; `current` if any task is in-progress;

package/harness/harness/peers.cases.json

@@ -11,15 +11,18 @@
     "not say, and that is where every agent publishing nothing sits.",
     "",
     "`pid` is a marker, never a number: `self` is the running test's own process, which is the",
-    "only pid a test can be sure is alive, and `dead` is one nothing can be occupying."
+    "only pid a test can be sure is alive, and `dead` is one nothing can be occupying.",
+    "",
+    "Ids are shaped like the session ids the registry publishes, because only that shape can be",
+    "declared ended by its absence — the last case is the one that is not."
   ],
   "cases": [
     {
       "name": "a run with one live process is reachable by the name it published",
       "sessions": [
-        { "file": "1.json", "sessionId": "alive-2222", "name": "repo-a8", "pid": "self", "entrypoint": "cli" }
+        { "file": "1.json", "sessionId": "22222222-2222-4222-8222-222222222222", "name": "repo-a8", "pid": "self", "entrypoint": "cli" }
       ],
-      "ask": "alive-2222",
+      "ask": "22222222-2222-4222-8222-222222222222",
       "expect": {
         "live": "running",
         "processes": 1,
@@ -29,24 +32,24 @@
     {
       "name": "a run whose process is gone is ended, not merely unlisted",
       "sessions": [
-        { "file": "1.json", "sessionId": "alive-2222", "name": "repo-a8", "pid": "self", "entrypoint": "cli" },
-        { "file": "2.json", "sessionId": "ghost-3333", "name": "repo-b7", "pid": "dead", "entrypoint": "cli" }
+        { "file": "1.json", "sessionId": "22222222-2222-4222-8222-222222222222", "name": "repo-a8", "pid": "self", "entrypoint": "cli" },
+        { "file": "2.json", "sessionId": "33333333-3333-4333-8333-333333333333", "name": "repo-b7", "pid": "dead", "entrypoint": "cli" }
       ],
-      "ask": "ghost-3333",
+      "ask": "33333333-3333-4333-8333-333333333333",
       "expect": { "live": "ended", "processes": 0, "addresses": [] }
     },
     {
       "name": "a run nothing published is ended, because something published a list without it",
       "sessions": [
-        { "file": "1.json", "sessionId": "alive-2222", "name": "repo-a8", "pid": "self", "entrypoint": "cli" }
+        { "file": "1.json", "sessionId": "22222222-2222-4222-8222-222222222222", "name": "repo-a8", "pid": "self", "entrypoint": "cli" }
       ],
-      "ask": "never-heard-of-it",
+      "ask": "12121212-1212-4121-8121-121212121212",
       "expect": { "live": "ended", "processes": 0, "addresses": [] }
     },
     {
       "name": "a take that named no run at all concludes nothing, because there is nothing to look up",
       "sessions": [
-        { "file": "1.json", "sessionId": "alive-2222", "name": "repo-a8", "pid": "self", "entrypoint": "cli" }
+        { "file": "1.json", "sessionId": "22222222-2222-4222-8222-222222222222", "name": "repo-a8", "pid": "self", "entrypoint": "cli" }
       ],
       "ask": "",
       "expect": { "live": "unknown", "processes": 0, "addresses": [] }
@@ -54,22 +57,22 @@
     {
       "name": "a client that publishes no list makes every run unknown, never ended",
       "sessions": null,
-      "ask": "alive-2222",
+      "ask": "22222222-2222-4222-8222-222222222222",
       "expect": { "live": "unknown", "processes": 0, "addresses": [] }
     },
     {
       "name": "an empty list is a claim, so a run not on it has ended",
       "sessions": [],
-      "ask": "alive-2222",
+      "ask": "22222222-2222-4222-8222-222222222222",
       "expect": { "live": "ended", "processes": 0, "addresses": [] }
     },
     {
       "name": "two live processes on one id are a fork, named both ways and neither picked",
       "sessions": [
-        { "file": "20558.json", "sessionId": "forked-4444", "name": "jarvis-9a", "pid": "self", "entrypoint": "claude-vscode" },
-        { "file": "15750.json", "sessionId": "forked-4444", "name": "the harness stops", "pid": "self", "entrypoint": "cli" }
+        { "file": "20558.json", "sessionId": "44444444-4444-4444-8444-444444444444", "name": "jarvis-9a", "pid": "self", "entrypoint": "claude-vscode" },
+        { "file": "15750.json", "sessionId": "44444444-4444-4444-8444-444444444444", "name": "the harness stops", "pid": "self", "entrypoint": "cli" }
       ],
-      "ask": "forked-4444",
+      "ask": "44444444-4444-4444-8444-444444444444",
       "expect": {
         "live": "forked",
         "processes": 2,
@@ -82,10 +85,10 @@
     {
       "name": "a fork is counted by its processes even when one of them published no name",
       "sessions": [
-        { "file": "1.json", "sessionId": "forked-5555", "name": "named-one", "pid": "self", "entrypoint": "cli" },
-        { "file": "2.json", "sessionId": "forked-5555", "name": "", "pid": "self", "entrypoint": "claude-vscode" }
+        { "file": "1.json", "sessionId": "55555555-5555-4555-8555-555555555555", "name": "named-one", "pid": "self", "entrypoint": "cli" },
+        { "file": "2.json", "sessionId": "55555555-5555-4555-8555-555555555555", "name": "", "pid": "self", "entrypoint": "claude-vscode" }
       ],
-      "ask": "forked-5555",
+      "ask": "55555555-5555-4555-8555-555555555555",
       "expect": {
         "live": "forked",
         "processes": 2,
@@ -95,17 +98,17 @@
     {
       "name": "a live run that published no name is running, with nothing to address it by",
       "sessions": [
-        { "file": "1.json", "sessionId": "nameless-6666", "name": "", "pid": "self", "entrypoint": "cli" }
+        { "file": "1.json", "sessionId": "66666666-6666-4666-8666-666666666666", "name": "", "pid": "self", "entrypoint": "cli" }
       ],
-      "ask": "nameless-6666",
+      "ask": "66666666-6666-4666-8666-666666666666",
       "expect": { "live": "running", "processes": 1, "addresses": [] }
     },
     {
       "name": "a door this does not know is passed through under the name its client gave it",
       "sessions": [
-        { "file": "1.json", "sessionId": "alive-7777", "name": "repo-c1", "pid": "self", "entrypoint": "some-future-client" }
+        { "file": "1.json", "sessionId": "77777777-7777-4777-8777-777777777777", "name": "repo-c1", "pid": "self", "entrypoint": "some-future-client" }
       ],
-      "ask": "alive-7777",
+      "ask": "77777777-7777-4777-8777-777777777777",
       "expect": {
         "live": "running",
         "processes": 1,
@@ -115,9 +118,9 @@
     {
       "name": "a run that names no door at all is still reachable by name",
       "sessions": [
-        { "file": "1.json", "sessionId": "alive-8888", "name": "repo-d2", "pid": "self" }
+        { "file": "1.json", "sessionId": "88888888-8888-4888-8888-888888888888", "name": "repo-d2", "pid": "self" }
       ],
-      "ask": "alive-8888",
+      "ask": "88888888-8888-4888-8888-888888888888",
       "expect": {
         "live": "running",
         "processes": 1,
@@ -127,15 +130,23 @@
     {
       "name": "a half-written file is skipped rather than read as a dead session",
       "sessions": [
-        { "file": "1.json", "sessionId": "alive-9999", "name": "repo-e3", "pid": "self", "entrypoint": "cli" },
+        { "file": "1.json", "sessionId": "99999999-9999-4999-8999-999999999999", "name": "repo-e3", "pid": "self", "entrypoint": "cli" },
         { "file": "2.json", "raw": "{\"sessionId\": \"tru" }
       ],
-      "ask": "alive-9999",
+      "ask": "99999999-9999-4999-8999-999999999999",
       "expect": {
         "live": "running",
         "processes": 1,
         "addresses": [{ "name": "repo-e3", "from": "a terminal" }]
       }
+    },
+    {
+      "name": "a shift that names itself was never going to be on the list, so it is unknown and never ended",
+      "sessions": [
+        { "file": "1.json", "sessionId": "22222222-2222-4222-8222-222222222222", "name": "repo-a8", "pid": "self", "entrypoint": "cli" }
+      ],
+      "ask": "nightly-shift",
+      "expect": { "live": "unknown", "processes": 0, "addresses": [] }
     }
   ]
 }

package/harness/harness/peers.py

@@ -1,11 +1,10 @@
 """Somebody else is on this — and here is whether you can reach them.
 
 **What was already known, and thrown away.** The harness has always recorded who
-else is working. A `.claim` holds an instance id; a board commit holds
-`Work-Session` and `Work-Machine`. What every surface then DID with that knowledge
-was print eight hex characters — `held by a7c5d0cb` — which names a session without
-reaching one. The id was right there and led nowhere, so the only move left was to
-wait for a lease to expire, or take the work and collide.
+else is working: a board commit holds `Work-Session` and `Work-Machine`. What every
+surface then DID with that knowledge was print eight hex characters — `held by
+a7c5d0cb` — which names a session without reaching one. The id was right there and
+led nowhere, so the only move left was to wait, or take the work and collide.
 
 So one function turns an id into the thing a session can act on: whether that
 instance is on THIS machine, where `ListAgents` lists it and `SendMessage` reaches
@@ -260,6 +259,19 @@ def sharing(root) -> str:
     return line
 
 
+def session_shaped(instance: str) -> bool:
+    """Whether an id has the shape of the session ids the registry publishes.
+
+    Only an id of this shape could ever have been on that list, so only an id of this
+    shape can be declared ended by its absence. A shift that names itself, a script,
+    a take recorded with no run at all — none of those was ever going to appear there,
+    and reading them as ended would free work somebody may still be doing.
+    """
+    parts = (instance or "").strip().split("-")
+    return ([len(p) for p in parts] == [8, 4, 4, 4, 12]
+            and all(c in "0123456789abcdefABCDEF" for p in parts for c in p))
+
+
 def reach(instance: str, host: str = "") -> dict:
     """Whether a run is live and what reaches it — `{"live": …, "addresses": […]}`.
 
@@ -270,18 +282,16 @@ def reach(instance: str, host: str = "") -> dict:
     than two answers a person has to reconcile.
 
     Four states, and the difference between two of them is the whole point. `ended`
-    is a CLAIM — something published a list and this run was not on it. `unknown` is
-    the absence of a claim: nothing here publishes one, or the run is on a machine
-    this one cannot see into. Collapsing them reports every peer of every client that
+    is a CLAIM — something published a list, this run was not on it, and it is the
+    kind of run that list would have held. `unknown` is the absence of a claim: nothing
+    here publishes one, the run is on a machine this one cannot see into, or it is not
+    a run the list could name. Collapsing them reports every peer of every client that
     publishes nothing as dead, which is worse than the silence it replaces.
     """
     who = (instance or "").strip()
     away = bool(host.strip()) and bool(here()) and host.strip() != here()
     live = None if away else _live()
-    # A take that named no run at all is not a run that has ended — there is nothing to
-    # look up, so there is nothing to conclude. Reading the miss as `ended` would have
-    # every board write made without a session id report as abandoned work.
-    if live is None or not who:
+    if live is None or not session_shaped(who):
         return {"live": "unknown", "processes": 0, "addresses": []}
     entries = live.get(who)
     if not entries:
@@ -319,6 +329,10 @@ def describe(instance: str, host: str = "") -> str:
                 f"here; the board is the only thing you share")
     got = reach(who)
     found = got["addresses"]
+    if got["live"] == "unknown" and not session_shaped(who):
+        return (f"{short} — this machine, but it names no session this machine "
+                f"publishes (a shift that names itself, or a script), so whether it "
+                f"is still running cannot be told from here")
     if got["live"] == "unknown":
         return (f"{short} — this machine: `ListAgents` lists it, `SendMessage` reaches "
                 f"it if the plan needs to change")
@@ -341,12 +355,6 @@ def describe(instance: str, host: str = "") -> str:
             f"`SendMessage` reaches it if the plan needs to change")
 
 
-def of_claim(claim: dict) -> str:
-    """The same line, from a `.claim` — which carries the machine since this
-    landed, so a hold taken elsewhere reads as elsewhere rather than as local."""
-    return describe(str(claim.get("instance", "")), str(claim.get("machine", "")))
-
-
 def briefing(root, rows: list, branch: str = "") -> str:
     """Who else is working this checkout right now and what they are on, or `""`.
 

package/harness/harness/report.py

@@ -128,6 +128,12 @@ def cmd_list(args) -> int:
         }.get(v.status(), f" · {v.status()}")
         target = f" · target {v.target}" if v.target and not v.released else ""
         print(f"\nVERSION  {v.name} — {v.title}{flag}{target}")
+        # Being FULL sits beside the status rather than replacing it: a cut can be
+        # planned or current and still owe a reshape.
+        over = v.over_ceiling()
+        if over:
+            print(f"         over its ceiling by {over} — a reshape is owed "
+                  f"({len(v.open_tasks())} open)")
         if v.outcome:
             print(f"         {v.outcome}")
         for t in _ordered(v.tasks):