@intutic/sync-daemon 2.9.1 → 3.0.1

package/dist/lib/scopeMatchPy.js

@@ -0,0 +1,278 @@
+/**
+ * The scope and plan match in Python, for the bash gates (their extractor already requires
+ * python3), emitted after the phrase matcher (`phrasesPy.ts`) in `GATE_PY_LIB`.
+ *
+ * Byte-identical to `packages/intutic-clawde/intutic_clawde/gate/scope_match.py`,
+ * which a test compares; edit that file and copy it here. It is the
+ * transliteration of `@intutic/shared-types`'s scopeMatch.ts, and both run the
+ * shared vectors. No backtick or dollar-brace, which this copy cannot hold.
+ */
+export const SCOPE_MATCH_PY_SOURCE = String.raw `"""Scope and plan semantics, ported from the proxy so every surface answers
+"is this change inside the scope?" and "is this run on its plan?" the same way
+.
+
+A transliteration of packages/shared-types/src/scopeMatch.ts; read that
+module's docstring for each function's port of origin (detectors.rs,
+sops.rs, manifest.rs). Every port runs
+packages/shared-types/fixtures/scope-plan-vectors.json.
+
+The bash hook gates emit this file after the phrase matcher's (phrases.py),
+which is_file_write_call calls: imported here as a module, and found in the
+emitting script's scope when it is not one. Otherwise the standard library
+only, and no backtick or dollar-brace, which a TypeScript copy cannot hold.
+"""
+
+try:
+    from .phrases import has_phrase, phrase_text
+except (ImportError, KeyError):  # embedded in a bash gate (exec without __name__), beside the phrase matcher's source
+    pass
+
+PLAN_DEVIATION_TOLERANCE = 0.4
+NARROWED_TO_NOTHING = "<none: workspace list disjoint from org ceiling>"
+
+SCOPE_WRITE_TOOLS = ("write", "write_file", "writefile", "create_file", "createfile")
+SCOPE_EDIT_TOOLS = ("edit", "edit_file", "editfile", "multiedit", "apply_patch", "str_replace", "notebookedit")
+SCOPE_DELETE_TOOLS = ("delete_file", "deletefile", "remove_file", "rm_file")
+SCOPE_MOVE_TOOLS = ("move_file", "movefile", "rename_file", "rename")
+SCOPE_EDITOR_TOOLS = ("str_replace_editor", "text_editor", "texteditor", "str_replace_based_edit_tool")
+SCOPE_PATH_KEYS = ("file_path", "filepath", "path", "filename", "target_file", "notebook_path")
+SCOPE_COMMAND_KEYS = ("command", "cmd", "script")
+SCOPE_SHELL_TOOLS = ("bash", "shell", "run_command", "runcommand", "execute_command", "run_shell_command",
+                     "terminal", "execute", "exec")
+SCOPE_READ_TOOLS = ("read", "readfile", "view", "cat", "open_file")
+SCOPE_MOVE_FROM_KEYS = ("source", "source_path", "from", "old_path")
+SCOPE_MOVE_TO_KEYS = ("destination", "destination_path", "to", "new_path")
+SCOPE_TARGET_MAX_BYTES = 512
+PLAN_EXEMPT_TOOLS = ("read", "readfile", "view", "cat", "open_file", "glob", "grep", "ls", "list_dir", "search",
+                     "todowrite")
+FILE_WRITE_SHELL_PHRASES = ("sed -i", "perl -i", "perl -pi", "git apply", "git am", "git checkout", "git switch",
+                            "git restore", "git reset", "git merge", "git pull", "git rebase", "git cherry-pick",
+                            "git revert", "git stash pop", "git stash apply", "patch -p")
+
+
+def _ascii_lower(s):
+    return "".join(chr(ord(c) + 32) if "A" <= c <= "Z" else c for c in s)
+
+
+def _tool_is(name, group):
+    lower = name.lower()
+    return any(lower == t or lower.endswith(t) for t in group)
+
+
+def _keyed(inp, keys):
+    if not isinstance(inp, dict):
+        return None
+    for k in keys:
+        v = inp.get(k)
+        if isinstance(v, str) and v != "":
+            return v
+    return None
+
+
+def _utf8_len(ch):
+    cp = ord(ch)
+    return 1 if cp < 0x80 else 2 if cp < 0x800 else 3 if cp < 0x10000 else 4
+
+
+def _clip(s):
+    total = 0
+    for i, ch in enumerate(s):
+        n = _utf8_len(ch)
+        if total + n > SCOPE_TARGET_MAX_BYTES:
+            return s[:i] + "…"
+        total += n
+    return s
+
+
+def _norm_scope(s):
+    t = s
+    while t[:2] == "./":
+        t = t[2:]
+    t = t.lstrip("/").rstrip("/")
+    return _ascii_lower(t)
+
+
+def is_within_scope(target, scopes):
+    """Segment-prefix match of target against scopes, ignoring ASCII case and leading ./ or /."""
+    t = _norm_scope(target)
+    for raw in scopes:
+        s = _norm_scope(raw)
+        if s == "" or t == s or t[:len(s) + 1] == s + "/":
+            return True
+    return False
+
+
+def sop_applies_to_role(roles, role):
+    if not roles:
+        return True
+    if role == "":
+        return False
+    return _ascii_lower(role) in roles
+
+
+def collect_scope_paths(sops, role):
+    """The path scope in force for role (sops.rs collect_scope_paths), org ceiling included."""
+    workspace, org = [], []
+    for s in sops:
+        if not sop_applies_to_role(s["roles"], role):
+            continue
+        (org if s["scope"] == "org" else workspace).extend(s["scopePaths"])
+    if not org:
+        out = workspace
+    elif not workspace:
+        out = org
+    else:
+        out = [w for w in workspace if is_within_scope(w, org)] or [NARROWED_TO_NOTHING]
+    return sorted(set(out))
+
+
+def collect_plan_steps(sops, role):
+    """The plan in force for role (sops.rs collect_plan_steps), org ceiling included."""
+    workspace, org = [], []
+    for s in sops:
+        if not sop_applies_to_role(s["roles"], role):
+            continue
+        (org if s["scope"] == "org" else workspace).extend(s["planSteps"])
+    if not org:
+        return workspace
+    if not workspace:
+        return org
+    allowed = {_ascii_lower(o) for o in org}
+    return [w for w in workspace if _ascii_lower(w) in allowed] or [NARROWED_TO_NOTHING]
+
+
+def plan_off_steps(sequence, plan_steps, tolerance):
+    """{"offPlan", "ratio"}: the off-plan names, sorted and deduplicated, when their share is over tolerance."""
+    if not plan_steps or not sequence:
+        return {"offPlan": [], "ratio": 0}
+    plan = {_ascii_lower(p) for p in plan_steps}
+    off = [t for t in sequence if _ascii_lower(t) not in plan]
+    if not off:
+        return {"offPlan": [], "ratio": 0}
+    ratio = len(off) / len(sequence)
+    if ratio <= tolerance:
+        return {"offPlan": [], "ratio": ratio}
+    return {"offPlan": sorted(set(off)), "ratio": min(1, ratio)}
+
+
+def change_targets(tool, inp):
+    """The mutations one tool call makes, as the proxy's change manifest records them."""
+    if _tool_is(tool, SCOPE_MOVE_TOOLS):
+        src = _keyed(inp, SCOPE_MOVE_FROM_KEYS)
+        dst = _keyed(inp, SCOPE_MOVE_TO_KEYS)
+        if src is not None or dst is not None:
+            return [{"op": "move", "target": _clip(t)} for t in (src, dst) if t is not None]
+    op = None
+    if _tool_is(tool, SCOPE_EDITOR_TOOLS):
+        command = inp.get("command") if isinstance(inp, dict) else None
+        command = _ascii_lower(command) if isinstance(command, str) else ""
+        if command == "view":
+            return []
+        op = "write" if command == "create" else "edit"
+    elif _tool_is(tool, SCOPE_WRITE_TOOLS):
+        op = "write"
+    elif _tool_is(tool, SCOPE_EDIT_TOOLS):
+        op = "edit"
+    elif _tool_is(tool, SCOPE_DELETE_TOOLS):
+        op = "delete"
+    if op is None:
+        return []
+    target = _keyed(inp, SCOPE_PATH_KEYS)
+    return [] if target is None else [{"op": op, "target": _clip(target)}]
+
+
+def _diff_path(raw, prefix):
+    p = raw
+    tab = p.find("\t")
+    if tab != -1:
+        p = p[:tab]
+    p = p.strip(" ")
+    if len(p) >= 2 and p[0] == '"' and p[-1] == '"':
+        p = p[1:-1]
+    if p in ("/dev/null", ""):
+        return None
+    if prefix and p[:len(prefix)] == prefix:
+        p = p[len(prefix):]
+    return p or None
+
+
+def diff_changed_paths(diff):
+    """The paths a diff changes, in the order first seen, each once."""
+    out = []
+
+    def add(p):
+        if p is not None and p not in out:
+            out.append(p)
+
+    for raw in diff.split("\n"):
+        line = raw[:-1] if raw.endswith("\r") else raw
+        if line[:11] == "diff --git ":
+            rest = line[11:]
+            if rest[:2] != "a/":
+                continue
+            first = rest.find(" b/")
+            if first == -1:
+                continue
+            if rest.find(" b/", first + 1) == -1:
+                add(_diff_path(rest[:first], "a/"))
+                add(_diff_path(rest[first + 1:], "b/"))
+            elif (len(rest) - 5) % 2 == 0:
+                n = (len(rest) - 5) // 2
+                a = rest[2:2 + n]
+                if rest[2 + n:5 + n] == " b/" and rest[5 + n:] == a:
+                    add(_diff_path(a, ""))
+        elif line[:4] == "--- ":
+            add(_diff_path(line[4:], "a/"))
+        elif line[:4] == "+++ ":
+            add(_diff_path(line[4:], "b/"))
+        elif line[:12] == "rename from ":
+            add(_diff_path(line[12:], ""))
+        elif line[:10] == "rename to ":
+            add(_diff_path(line[10:], ""))
+    return out
+
+
+def _normalise_path(p):
+    parts = []
+    for seg in p.split("/"):
+        if seg in ("", "."):
+            continue
+        if seg == "..":
+            if parts:
+                parts.pop()
+        else:
+            parts.append(seg)
+    return "/" + "/".join(parts)
+
+
+def scope_relative_path(target, cwd, root):
+    """target relative to the workspace root, or None when outside it, under ~, or unresolvable."""
+    if target == "" or target[:1] == "~" or cwd[:1] != "/" or root[:1] != "/":
+        return None
+    absolute = _normalise_path(target if target[:1] == "/" else cwd + "/" + target)
+    base = _normalise_path(root)
+    if absolute == base:
+        return ""
+    head = "/" if base == "/" else base + "/"
+    return absolute[len(head):] if absolute[:len(head)] == head else None
+
+
+def is_plan_exempt_tool(tool):
+    """Whether plan_approval: lets tool run before approval: a PLAN_EXEMPT_TOOLS name, bare or mcp__<server>__<name>."""
+    lower = tool.lower()
+    return any(lower == t or lower[-(len(t) + 2):] == "__" + t for t in PLAN_EXEMPT_TOOLS)
+
+
+def is_file_write_call(tool, inp):
+    """Whether the call changed files: a mutation, or a shell command with a FILE_WRITE_SHELL_PHRASES phrase."""
+    if change_targets(tool, inp):
+        return True
+    if not _tool_is(tool, SCOPE_SHELL_TOOLS):
+        return False
+    command = _keyed(inp, SCOPE_COMMAND_KEYS)
+    if command is None:
+        return False
+    words = phrase_text(command)
+    return any(has_phrase(words, p) for p in FILE_WRITE_SHELL_PHRASES)
+`;
+//# sourceMappingURL=scopeMatchPy.js.map

package/dist/lib/scopeMatchPy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scopeMatchPy.js","sourceRoot":"","sources":["../../src/lib/scopeMatchPy.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2Q9C,CAAA"}

package/dist/lib/testOutcomePy.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The test outcome decision and the per-session outcome state in Python, for the bash gates (their extractor already requires
+ * python3), emitted after the phrase matcher (`phrasesPy.ts`) in `GATE_PY_LIB`.
+ *
+ * Byte-identical to `packages/intutic-clawde/intutic_clawde/gate/test_outcome.py`,
+ * which a test compares; edit that file and copy it here. It is the
+ * transliteration of `@intutic/shared-types`'s testOutcome.ts, and both run the
+ * shared vectors. No backtick or dollar-brace, which this copy cannot hold.
+ */
+export declare const TEST_OUTCOME_PY_SOURCE: string;
+//# sourceMappingURL=testOutcomePy.d.ts.map

package/dist/lib/testOutcomePy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testOutcomePy.d.ts","sourceRoot":"","sources":["../../src/lib/testOutcomePy.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,QAwWlC,CAAA"}

package/dist/lib/testOutcomePy.js

@@ -0,0 +1,371 @@
+/**
+ * The test outcome decision and the per-session outcome state in Python, for the bash gates (their extractor already requires
+ * python3), emitted after the phrase matcher (`phrasesPy.ts`) in `GATE_PY_LIB`.
+ *
+ * Byte-identical to `packages/intutic-clawde/intutic_clawde/gate/test_outcome.py`,
+ * which a test compares; edit that file and copy it here. It is the
+ * transliteration of `@intutic/shared-types`'s testOutcome.ts, and both run the
+ * shared vectors. No backtick or dollar-brace, which this copy cannot hold.
+ */
+export const TEST_OUTCOME_PY_SOURCE = String.raw `"""Did the tests pass? The deciding function behind the qualified ordering rule
+requires_before: action:run_tests[ok] -> action:deploy, and the
+per-session state a gate keeps of it.
+
+A transliteration of packages/shared-types/src/testOutcome.ts; read that
+module's docstring for the steps. In short, decide_test_outcome says failed
+for a non-zero exit code, an error flag, a false success flag, a runner
+summary with failures, or a summary saying no tests ran; ok for exit code 0,
+or, with no exit code, a summary that counts a pass; and unknown otherwise,
+which leaves a qualified rule unmet as a failure does.
+
+Every port runs packages/shared-types/fixtures/test-outcome-vectors.json. The
+bash hook gates emit this file verbatim, so it must stay self-contained: the
+standard library only, no module state beyond the constants below, and no
+backtick or dollar-brace, which a TypeScript copy cannot hold.
+
+Inputs and states are plain dicts with the TypeScript field names
+(exitCode, isError, success, output; {"v": 1, "outcomes":
+{...}}), so a gate can read and write the same state file.
+"""
+
+import json
+import re
+
+OUTCOME_TOKENS = ("action:run_tests",)
+OUTCOME_QUALIFIERS = ("ok",)
+TEST_OUTPUT_TAIL_BYTES = 65536
+TEST_OUTPUT_LINE_BYTES = 1024
+TEST_OUTPUT_JSON_MAX_CHARS = 1048576
+OUTCOME_STATE_TTL_MS = 86400000
+_MAX_SAFE_INTEGER = 9007199254740991
+
+_ANSI = re.compile(r"\x1b\[[0-9;?]*[A-Za-z]")
+_EXIT_CODE = re.compile(r"exit code:? (-?[0-9]{1,9})\Z", re.IGNORECASE | re.ASCII)
+_EXIT_STATUS = re.compile(r"exit status ([0-9]{1,9})\Z")
+_EXITED = re.compile(r"(?:Process|Command) exited with code (-?[0-9]{1,9})")
+_COUNT = re.compile(r"([0-9]{1,9}) ([a-z]+)")
+_PYTEST_NONE = re.compile(r"=+ no tests ran")
+_PYTEST = re.compile(r"=+ (.+) in [0-9.]+s.* =+\Z")
+_JEST = re.compile(r"Tests:[ \t]+(.+)\Z")
+_VITEST = re.compile(r"[ \t]*Tests[ \t]+(.+)\Z")
+_GO_OK = re.compile(r"ok[ \t]+[^ \t]+")
+_GO_FAIL = re.compile(r"FAIL(?:[ \t]|\Z)")
+_GO_FAIL_TEST = re.compile(r"--- FAIL:")
+_CARGO = re.compile(r"test result: (ok|FAILED)\. ([0-9]{1,9}) passed; ([0-9]{1,9}) failed;")
+_MOCHA_PASS = re.compile(r"[ \t]*([0-9]{1,9}) passing")
+_MOCHA_FAIL = re.compile(r"[ \t]*([0-9]{1,9}) failing")
+_RSPEC = re.compile(r"([0-9]{1,9}) examples?, ([0-9]{1,9}) failures?")
+
+
+def _utf8_len(ch):
+    cp = ord(ch)
+    if cp < 0x80:
+        return 1
+    if cp < 0x800:
+        return 2
+    if cp < 0x10000:
+        return 3
+    return 4
+
+
+def _utf8_tail(s, max_bytes):
+    """The last max_bytes bytes of s as UTF-8, starting on a character."""
+    total = 0
+    i = len(s)
+    while i > 0:
+        n = _utf8_len(s[i - 1])
+        if total + n > max_bytes:
+            break
+        total += n
+        i -= 1
+    return s[i:]
+
+
+def _utf8_head(s, max_bytes):
+    """The first max_bytes bytes of s as UTF-8, ending on a character."""
+    total = 0
+    i = 0
+    while i < len(s):
+        n = _utf8_len(s[i])
+        if total + n > max_bytes:
+            break
+        total += n
+        i += 1
+    return s[:i]
+
+
+def _lines(text):
+    """The lines of text, each cut to 1 KiB, without carriage returns or ANSI sequences."""
+    return [_ANSI.sub("", _utf8_head(raw, TEST_OUTPUT_LINE_BYTES).replace("\r", "")) for raw in text.split("\n")]
+
+
+def _integer_or_none(v):
+    """A JSON integer exit code, or None."""
+    if isinstance(v, bool):
+        return None
+    if isinstance(v, int) and abs(v) <= _MAX_SAFE_INTEGER:
+        return v
+    if isinstance(v, float) and v.is_integer() and abs(v) <= _MAX_SAFE_INTEGER:
+        return int(v)
+    return None
+
+
+def extract_exit_code(output):
+    """The exit code a run's text reports, or None. See testOutcome.ts extractExitCode."""
+    if not isinstance(output, str) or output == "":
+        return None
+    trimmed = output.strip()
+    if len(trimmed) <= TEST_OUTPUT_JSON_MAX_CHARS and trimmed[:1] == "{" and trimmed[-1:] == "}":
+        try:
+            parsed = json.loads(trimmed)
+        except ValueError:
+            parsed = None
+        if isinstance(parsed, dict):
+            meta = parsed.get("metadata")
+            if isinstance(meta, dict):
+                m = _integer_or_none(meta.get("exit_code"))
+                if m is not None:
+                    return m
+            for key in ("exit_code", "exitCode"):
+                v = _integer_or_none(parsed.get(key))
+                if v is not None:
+                    return v
+    head = _utf8_head(output, TEST_OUTPUT_TAIL_BYTES)
+    parts = [head] if len(head) == len(output) else [head, _utf8_tail(output[len(head):], TEST_OUTPUT_TAIL_BYTES)]
+    for part in parts:
+        for raw in _lines(part):
+            line = raw.lstrip(" \t").rstrip(" \t")
+            m = _EXIT_CODE.match(line) or _EXIT_STATUS.match(line) or _EXITED.match(line)
+            if m:
+                return int(m.group(1))
+    return None
+
+
+def _counts(text):
+    """'N word' pieces of a summary, split on ',' and '|': the count of each word."""
+    counts = {}
+    for piece in re.split(r"[,|]", text):
+        m = _COUNT.match(piece.lstrip(" \t"))
+        if m:
+            counts[m.group(2)] = counts.get(m.group(2), 0) + int(m.group(1))
+    return counts
+
+
+def parse_test_summaries(output):
+    """The runner summaries in the last 64 KiB of output, in order (go and mocha folded into one each)."""
+    if not isinstance(output, str) or output == "":
+        return []
+    out = []
+    go = None
+    mocha = None
+    for line in _lines(_utf8_tail(output, TEST_OUTPUT_TAIL_BYTES)):
+        if _PYTEST_NONE.match(line):
+            out.append({"runner": "pytest", "passed": 0, "failed": 0, "noTests": True})
+            continue
+        m = _PYTEST.match(line)
+        if m:
+            c = _counts(m.group(1))
+            if not any(k in c for k in ("passed", "failed", "error", "errors")):
+                continue
+            out.append({"runner": "pytest", "passed": c.get("passed", 0),
+                        "failed": c.get("failed", 0) + c.get("error", 0) + c.get("errors", 0),
+                        "noTests": c.get("passed") == 0})
+            continue
+        m = _JEST.match(line)
+        if m:
+            c = _counts(m.group(1))
+            out.append({"runner": "jest", "passed": c.get("passed", 0), "failed": c.get("failed", 0),
+                        "noTests": c.get("passed") == 0 or c.get("total") == 0})
+            continue
+        m = _VITEST.match(line)
+        if m:
+            c = _counts(m.group(1))
+            if "passed" not in c and "failed" not in c:
+                continue
+            out.append({"runner": "vitest", "passed": c.get("passed", 0), "failed": c.get("failed", 0),
+                        "noTests": c.get("passed") == 0})
+            continue
+        if _GO_OK.match(line):
+            if go is None:
+                go = {"runner": "go", "passed": 0, "failed": 0, "noTests": False}
+                out.append(go)
+            go["passed"] += 1
+            continue
+        if _GO_FAIL.match(line) or _GO_FAIL_TEST.match(line):
+            if go is None:
+                go = {"runner": "go", "passed": 0, "failed": 0, "noTests": False}
+                out.append(go)
+            go["failed"] += 1
+            continue
+        m = _CARGO.match(line)
+        if m:
+            passed, failed = int(m.group(2)), int(m.group(3))
+            out.append({"runner": "cargo", "passed": passed,
+                        "failed": 1 if m.group(1) == "FAILED" and failed == 0 else failed,
+                        "noTests": passed == 0})
+            continue
+        m = _MOCHA_PASS.match(line)
+        if m:
+            if mocha is None:
+                mocha = {"runner": "mocha", "passed": 0, "failed": 0, "noTests": False}
+                out.append(mocha)
+            mocha["passed"] += int(m.group(1))
+            if int(m.group(1)) == 0:
+                mocha["noTests"] = True
+            continue
+        m = _MOCHA_FAIL.match(line)
+        if m:
+            if mocha is None:
+                mocha = {"runner": "mocha", "passed": 0, "failed": 0, "noTests": False}
+                out.append(mocha)
+            mocha["failed"] += int(m.group(1))
+            continue
+        m = _RSPEC.match(line)
+        if m:
+            examples, failures = int(m.group(1)), int(m.group(2))
+            out.append({"runner": "rspec", "passed": max(0, examples - failures), "failed": failures,
+                        "noTests": examples == 0})
+    return out
+
+
+def decide_test_outcome(inp):
+    """The outcome of one test run, as {"outcome": ok|failed|unknown, "why": ...}.
+
+    'inp' carries any of exitCode, isError, success and output.
+    """
+    exit_code = inp.get("exitCode")
+    if isinstance(exit_code, bool) or not isinstance(exit_code, (int, float)) or _integer_or_none(exit_code) is None:
+        exit_code = None
+    else:
+        exit_code = int(exit_code)
+    if exit_code is not None and exit_code != 0:
+        return {"outcome": "failed", "why": "exit_code"}
+    if inp.get("isError") is True:
+        return {"outcome": "failed", "why": "is_error"}
+    if inp.get("success") is False:
+        return {"outcome": "failed", "why": "success_false"}
+    passed = 0
+    no_tests = False
+    for s in parse_test_summaries(inp.get("output")):
+        if s["failed"] > 0:
+            return {"outcome": "failed", "why": "summary_failed"}
+        passed += s["passed"]
+        if s["noTests"]:
+            no_tests = True
+    if passed == 0 and no_tests:
+        return {"outcome": "failed", "why": "no_tests"}
+    if exit_code == 0:
+        return {"outcome": "ok", "why": "exit_zero"}
+    if passed >= 1:
+        return {"outcome": "ok", "why": "summary_passed"}
+    return {"outcome": "unknown", "why": "no_signal"}
+
+
+def ordering_qualifier_error(side, left):
+    """Why one side of an ordering rule cannot carry its qualifier, or None."""
+    if "[" not in side and "]" not in side:
+        return None
+    if left and side == "action:run_tests[ok]":
+        return None
+    return json.dumps(side, ensure_ascii=False) + ": [ok] qualifies only action:run_tests, on the left of ->"
+
+
+def split_qualifier(token):
+    """action:run_tests[ok] as ("action:run_tests", "ok"); any other token unqualified."""
+    return ("action:run_tests", "ok") if token == "action:run_tests[ok]" else (token, None)
+
+
+def empty_outcome_state():
+    return {"v": 1, "outcomes": {}}
+
+
+def outcome_state_file_name(harness, session_id, sha256_hex):
+    """The first 32 hex of sha256(harness NUL session_id), and .json."""
+    return sha256_hex(harness + "\0" + session_id)[:32] + ".json"
+
+
+def parse_outcome_state(text):
+    """A state file's text as a state, or None when it is not one."""
+    try:
+        v = json.loads(text)
+    except ValueError:
+        return None
+    if not isinstance(v, dict) or v.get("v") != 1 or isinstance(v.get("v"), bool) or not isinstance(v.get("outcomes"), dict):
+        return None
+    outcomes = {}
+    for key, e in v["outcomes"].items():
+        if not isinstance(e, dict):
+            return None
+        at = e.get("at")
+        if e.get("o") not in ("ok", "failed", "unknown") or isinstance(at, bool) or not isinstance(at, (int, float)):
+            return None
+        if at != at or at in (float("inf"), float("-inf")):
+            return None
+        if "why" in e and not isinstance(e["why"], str):
+            return None
+        if "changed" in e and e["changed"] is not True:
+            return None
+        if "later" in e and e["later"] is not True:
+            return None
+        outcomes[key] = e
+    return {"v": 1, "outcomes": outcomes}
+
+
+def record_test_outcome(state, token, decision, at_ms):
+    """state with token's outcome replaced by this run's."""
+    outcomes = dict(state["outcomes"])
+    outcomes[token] = {"o": decision["outcome"], "at": at_ms, "why": decision["why"]}
+    return {"v": 1, "outcomes": outcomes}
+
+
+def note_completed_call(state, changed_files):
+    """state after another call completed: none adjacent any more, and stale after a file change."""
+    outcomes = {}
+    for key, e in state["outcomes"].items():
+        nxt = {"o": e["o"], "at": e["at"]}
+        if "why" in e:
+            nxt["why"] = e["why"]
+        if e.get("changed") or changed_files:
+            nxt["changed"] = True
+        nxt["later"] = True
+        outcomes[key] = nxt
+    return {"v": 1, "outcomes": outcomes}
+
+
+def prerequisite_case(state, token, adjacent, now_ms):
+    """(case, why): met only for an ok younger than a day that no file change followed
+    (and, adjacent, no other call)."""
+    e = None if state is None else state["outcomes"].get(token)
+    if e is None or not (now_ms - e["at"] < OUTCOME_STATE_TTL_MS) or e["at"] > now_ms:
+        return ("none", None)
+    if e["o"] == "failed":
+        return ("failed", e.get("why"))
+    if e["o"] == "unknown":
+        return ("unknown", e.get("why"))
+    if e.get("changed"):
+        return ("changed", None)
+    if adjacent and e.get("later"):
+        return ("not_adjacent", None)
+    return ("met", None)
+
+
+def prerequisite_unmet_reason(first, then, case, why, harness):
+    """The PREREQUISITE_UNMET reason for every case but met, byte for byte as every port words it."""
+    head = then + " needs a passing " + first + " first; "
+    if case == "none":
+        return head + "none ran in this session"
+    if case == "failed":
+        return head + "the last " + first + " failed (" + (why if why is not None else "failed") + ")"
+    if case == "unknown":
+        return head + "the result of the last " + first + " could not be read; rerun the tests so their summary is visible"
+    if case == "changed":
+        return head + "files changed after the last passing " + first + "; rerun the tests"
+    if case == "not_adjacent":
+        return head + then + " must come directly after it, and another call came between"
+    if case == "not_observable":
+        return head + harness + " reports no tool results Intutic can read, so a passing run cannot be observed here"
+    if case == "no_session":
+        return head + harness + " sent no session id, so test results cannot be tied to this session"
+    return ""
+`;
+//# sourceMappingURL=testOutcomePy.js.map

package/dist/lib/testOutcomePy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"testOutcomePy.js","sourceRoot":"","sources":["../../src/lib/testOutcomePy.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwW/C,CAAA"}