@caupulican/pi-adaptative 0.81.37 → 0.81.39

package/dist/bundled-resources/runtimes/pi-shell-engine/tokens.py

@@ -0,0 +1,579 @@
+"""Tokenizer: source `str` -> `list[Token]`; resolves quoting into word segments.
+
+Splits Bash source into WORD tokens (each carrying an ordered `list[Segment]` already
+broken by quoting/expansion markers) and OPERATOR tokens (the fixed lexeme set from
+windows-shell-workpackages-2026-07-19.md §1.1/§3 WP-A). Never returns a partial or
+guessed token stream: anything outside the frozen grammar raises `UnsupportedConstruct`
+with a catalog id and an actionable message naming the construct.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from errors import UnsupportedConstruct
+from nodes import CmdSub, DQ, Lit, Param, Raw, Segment, Tilde, Word
+
+_IDENT_START_RE = re.compile(r"[A-Za-z_]")
+_IDENT_RE = re.compile(r"[A-Za-z_][A-Za-z0-9_]*")
+_ANSI_C_MAP = {
+    "\\": "\\",
+    "a": "\a",
+    "b": "\b",
+    "c": "",  # \c stops output; treated as empty here (bounded, no truncation semantics)
+    "e": "\x1b",
+    "f": "\f",
+    "n": "\n",
+    "r": "\r",
+    "t": "\t",
+    "v": "\v",
+}
+
+
+@dataclass
+class Token:
+    kind: str  # "WORD" | "OP"
+    text: str | None = None  # OP: exact operator text (e.g. ">>", "2>&1", "\n")
+    segments: list[Segment] | None = None  # WORD: ordered segments
+
+
+def _unterminated(what: str) -> UnsupportedConstruct:
+    # Not part of the frozen §2.3 catalog: a defensive, never-crash refusal for
+    # genuinely malformed input (unbalanced quote/paren/brace). No acceptance test
+    # requires this id; flagged for architect review in the WP-A report.
+    return UnsupportedConstruct("malformed-syntax", f"Unterminated {what}: the command has an unbalanced quote or bracket.")
+
+
+def _ansi_c_unescape(text: str) -> str:
+    out: list[str] = []
+    i = 0
+    n = len(text)
+    while i < n:
+        c = text[i]
+        if c != "\\" or i + 1 >= n:
+            out.append(c)
+            i += 1
+            continue
+        nxt = text[i + 1]
+        if nxt in _ANSI_C_MAP:
+            out.append(_ANSI_C_MAP[nxt])
+            i += 2
+            continue
+        if nxt == "0":
+            j = i + 2
+            digits = ""
+            while j < n and len(digits) < 3 and text[j] in "01234567":
+                digits += text[j]
+                j += 1
+            out.append(chr(int(digits, 8)) if digits else "\0")
+            i = j
+            continue
+        if nxt == "x":
+            j = i + 2
+            digits = ""
+            while j < n and len(digits) < 2 and text[j] in "0123456789abcdefABCDEF":
+                digits += text[j]
+                j += 1
+            out.append(chr(int(digits, 16)) if digits else "x")
+            i = j
+            continue
+        out.append(nxt)
+        i += 2
+    return "".join(out)
+
+
+def _find_closing_paren(src: str, pos: int) -> int:
+    """`pos` is the index right after the opening '('. Returns the index of the matching ')'."""
+    n = len(src)
+    depth = 1
+    i = pos
+    while i < n:
+        c = src[i]
+        if c == "\\" and i + 1 < n:
+            i += 2
+            continue
+        if c == "'":
+            j = src.find("'", i + 1)
+            if j == -1:
+                raise _unterminated("single quote")
+            i = j + 1
+            continue
+        if c == '"':
+            i = _skip_double_quote(src, i + 1)
+            continue
+        if c == "(":
+            depth += 1
+            i += 1
+            continue
+        if c == ")":
+            depth -= 1
+            if depth == 0:
+                return i
+            i += 1
+            continue
+        i += 1
+    raise _unterminated("'('")
+
+
+def _skip_double_quote(src: str, pos: int) -> int:
+    """`pos` is the index right after the opening '"'. Returns the index right after the closing '"'."""
+    n = len(src)
+    i = pos
+    while i < n:
+        c = src[i]
+        if c == "\\" and i + 1 < n:
+            i += 2
+            continue
+        if c == '"':
+            return i + 1
+        i += 1
+    raise _unterminated('double quote')
+
+
+def _find_closing_brace(src: str, pos: int) -> int:
+    """`pos` is the index right after the opening '{'. Returns the index of the matching '}'."""
+    n = len(src)
+    depth = 1
+    i = pos
+    while i < n:
+        c = src[i]
+        if c == "\\" and i + 1 < n:
+            i += 2
+            continue
+        if c == "'":
+            j = src.find("'", i + 1)
+            if j == -1:
+                raise _unterminated("single quote")
+            i = j + 1
+            continue
+        if c == '"':
+            i = _skip_double_quote(src, i + 1)
+            continue
+        if src[i : i + 2] == "${":
+            depth += 1
+            i += 2
+            continue
+        if src[i : i + 2] == "$(":
+            i = _find_closing_paren(src, i + 2) + 1
+            continue
+        if c == "}":
+            depth -= 1
+            if depth == 0:
+                return i
+            i += 1
+            continue
+        i += 1
+    raise _unterminated("'{'")
+
+
+def _scan_param_arg_word(text: str) -> Word:
+    """Scan a `${VAR:-arg}`-style default/assign/alt/err argument into a `Word`.
+
+    Unlike `_scan_word`, this consumes the ENTIRE `text` (already delimited by the matching
+    closing brace found by `_find_closing_brace`): whitespace inside is literal content within
+    Raw segments, not a word-boundary terminator (bash: `${V:-a b}` -> the default word is the
+    full "a b", not just "a"). Quoting and $-forms inside are still parsed as segments.
+    """
+    n = len(text)
+    segments: list[Segment] = []
+    buf: list[str] = []
+    i = 0
+
+    def flush() -> None:
+        if buf:
+            segments.append(Raw(text="".join(buf)))
+            buf.clear()
+
+    while i < n:
+        c = text[i]
+        if c == "\\":
+            if i + 1 < n:
+                flush()
+                segments.append(Lit(text=text[i + 1]))
+                i += 2
+            else:
+                buf.append(c)
+                i += 1
+            continue
+        if c == "'":
+            j = text.find("'", i + 1)
+            if j == -1:
+                raise _unterminated("single quote")
+            flush()
+            segments.append(Lit(text=text[i + 1 : j]))
+            i = j + 1
+            continue
+        if c == '"':
+            flush()
+            dq_segments, newpos = _scan_dq_segments(text, i + 1)
+            segments.append(DQ(segments=dq_segments))
+            i = newpos
+            continue
+        if c == "$" and text[i + 1 : i + 2] == "'":
+            j = i + 2
+            raw_chars: list[str] = []
+            while j < n and text[j] != "'":
+                if text[j] == "\\" and j + 1 < n:
+                    raw_chars.append(text[j])
+                    raw_chars.append(text[j + 1])
+                    j += 2
+                else:
+                    raw_chars.append(text[j])
+                    j += 1
+            if j >= n:
+                raise _unterminated("$'...' quote")
+            flush()
+            segments.append(Lit(text=_ansi_c_unescape("".join(raw_chars))))
+            i = j + 1
+            continue
+        if c == "$":
+            seg, newpos = _scan_dollar_form(text, i)
+            if isinstance(seg, Lit) and seg.text == "$" and newpos == i + 1:
+                buf.append("$")
+                i = newpos
+                continue
+            flush()
+            segments.append(seg)
+            i = newpos
+            continue
+        if c == "`":
+            j = i + 1
+            while j < n and text[j] != "`":
+                if text[j] == "\\" and j + 1 < n:
+                    j += 2
+                else:
+                    j += 1
+            if j >= n:
+                raise _unterminated("backtick")
+            flush()
+            segments.append(CmdSub(src=text[i + 1 : j]))
+            i = j + 1
+            continue
+        buf.append(c)
+        i += 1
+    flush()
+    return Word(segments=segments)
+
+
+def _parse_param_brace_content(content: str) -> Param:
+    if content.startswith("#"):
+        return Param(name=content[1:], op="#len", arg=None)
+    m = _IDENT_RE.match(content)
+    name = m.group(0) if m else ""
+    rest = content[len(name) :]
+    for candidate in (":-", ":=", ":+", ":?"):
+        if rest.startswith(candidate):
+            arg_text = rest[len(candidate) :]
+            # Scan the FULL remainder into one Word: the default/alt/assign/err argument runs
+            # up to the already-matched closing brace, so whitespace inside it is literal text
+            # within Raw segments (bash: `${V:-a b}` -> default word is "a b", not just "a").
+            # Do not truncate at the first _scan_word word-boundary space.
+            arg_word = _scan_param_arg_word(arg_text) if arg_text else Word(segments=[])
+            return Param(name=name, op=candidate, arg=arg_word)
+    if rest:
+        raise UnsupportedConstruct(
+            "parameter-expansion",
+            f"Unsupported parameter expansion form '${{{content}}}': only ${{VAR}}, ${{VAR:-w}}, "
+            "${VAR:=w}, ${VAR:+w}, ${VAR:?w}, and ${#VAR} are supported.",
+        )
+    return Param(name=name, op=None, arg=None)
+
+
+def _scan_dollar_form(src: str, pos: int) -> tuple[Segment, int]:
+    """`pos` is the index of '$'. Returns (segment, new_pos)."""
+    n = len(src)
+    nxt = src[pos + 1] if pos + 1 < n else ""
+    if nxt == "{":
+        close = _find_closing_brace(src, pos + 2)
+        return _parse_param_brace_content(src[pos + 2 : close]), close + 1
+    if nxt == "(":
+        if src[pos + 2 : pos + 3] == "(":
+            raise UnsupportedConstruct(
+                "arithmetic-expansion", "Arithmetic expansion '$((...))' is not supported."
+            )
+        close = _find_closing_paren(src, pos + 2)
+        return CmdSub(src=src[pos + 2 : close]), close + 1
+    if nxt and (_IDENT_START_RE.match(nxt)):
+        m = _IDENT_RE.match(src, pos + 1)
+        assert m is not None
+        return Param(name=m.group(0), op=None, arg=None), m.end()
+    # Bare '$' with nothing recognizable following: literal '$'.
+    return Lit(text="$"), pos + 1
+
+
+def _scan_dq_segments(src: str, pos: int) -> tuple[list[Segment], int]:
+    """`pos` is the index right after the opening '"'. Returns (segments, new_pos-after-closing-quote)."""
+    n = len(src)
+    segments: list[Segment] = []
+    buf: list[str] = []
+    i = pos
+
+    def flush() -> None:
+        if buf:
+            segments.append(Lit(text="".join(buf)))
+            buf.clear()
+
+    while i < n:
+        c = src[i]
+        if c == '"':
+            flush()
+            return segments, i + 1
+        if c == "\\" and i + 1 < n:
+            nxt = src[i + 1]
+            if nxt in ('"', "\\", "$", "`"):
+                buf.append(nxt)
+                i += 2
+            elif nxt == "\n":
+                i += 2
+            else:
+                buf.append(c)
+                buf.append(nxt)
+                i += 2
+            continue
+        if c == "$":
+            seg, newpos = _scan_dollar_form(src, i)
+            if isinstance(seg, Lit) and seg.text == "$" and newpos == i + 1:
+                buf.append("$")
+                i = newpos
+                continue
+            flush()
+            segments.append(seg)
+            i = newpos
+            continue
+        if c == "`":
+            j = i + 1
+            while j < n and src[j] != "`":
+                if src[j] == "\\" and j + 1 < n:
+                    j += 2
+                else:
+                    j += 1
+            if j >= n:
+                raise _unterminated("backtick")
+            flush()
+            segments.append(CmdSub(src=src[i + 1 : j]))
+            i = j + 1
+            continue
+        buf.append(c)
+        i += 1
+    raise _unterminated("double quote")
+
+
+_WORD_BOUNDARY_CHARS = set("|&;()<> \t\n")
+_EXTGLOB_PREFIX_CHARS = set("@!?*+")
+_DRIVE_PREFIX_RE = re.compile(r"^[A-Za-z]:")
+
+
+def _scan_word(src: str, pos: int) -> tuple[Word, int]:
+    n = len(src)
+    segments: list[Segment] = []
+    buf: list[str] = []
+    i = pos
+    at_word_start = True
+
+    def flush() -> None:
+        if buf:
+            segments.append(Raw(text="".join(buf)))
+            buf.clear()
+
+    while i < n:
+        c = src[i]
+        if at_word_start and c == "~":
+            j = i + 1
+            while j < n and src[j] not in _WORD_BOUNDARY_CHARS and src[j] not in "\"'\\$`/":
+                j += 1
+            segments.append(Tilde(user=src[i + 1 : j]))
+            i = j
+            at_word_start = False
+            continue
+        at_word_start = False
+        if c in _WORD_BOUNDARY_CHARS:
+            break
+        if c in _EXTGLOB_PREFIX_CHARS and src[i + 1 : i + 2] == "(":
+            raise UnsupportedConstruct(
+                "extended-glob", "Extended glob patterns ('@(...)','!(...)', etc.) are not supported."
+            )
+        if c == "{":
+            j = i + 1
+            depth = 1
+            has_comma = False
+            while j < n and depth > 0:
+                if src[j] == "{":
+                    depth += 1
+                elif src[j] == "}":
+                    depth -= 1
+                    if depth == 0:
+                        break
+                elif src[j] == "," and depth == 1:
+                    has_comma = True
+                j += 1
+            if depth != 0:
+                buf.append(c)
+                i += 1
+                continue
+            if has_comma:
+                raise UnsupportedConstruct(
+                    "brace-expansion", "Brace expansion ('{a,b,c}') is not supported; list the values explicitly."
+                )
+            buf.append(src[i : j + 1])
+            i = j + 1
+            continue
+        if c == "\\":
+            # Windows absolute paths: a backslash inside a word already recognized as a
+            # drive-letter path ('C:\...') or a UNC path ('\\server\...') is preserved
+            # literally rather than treated as a POSIX escape of the next character.
+            # Mirrors the TS router's identical heuristic (shell-contract-router.ts).
+            buf_text = "".join(buf)
+            if _DRIVE_PREFIX_RE.match(buf_text) or buf_text.startswith("\\\\"):
+                buf.append(c)
+                i += 1
+                continue
+            if not buf and not segments and src[i + 1 : i + 2] == "\\":
+                buf.append("\\\\")
+                i += 2
+                continue
+            if i + 1 < n:
+                flush()
+                segments.append(Lit(text=src[i + 1]))
+                i += 2
+            else:
+                buf.append(c)
+                i += 1
+            continue
+        if c == "'":
+            j = src.find("'", i + 1)
+            if j == -1:
+                raise _unterminated("single quote")
+            flush()
+            segments.append(Lit(text=src[i + 1 : j]))
+            i = j + 1
+            continue
+        if c == '"':
+            flush()
+            dq_segments, newpos = _scan_dq_segments(src, i + 1)
+            segments.append(DQ(segments=dq_segments))
+            i = newpos
+            continue
+        if c == "$" and src[i + 1 : i + 2] == "'":
+            j = i + 2
+            raw_chars: list[str] = []
+            while j < n and src[j] != "'":
+                if src[j] == "\\" and j + 1 < n:
+                    raw_chars.append(src[j])
+                    raw_chars.append(src[j + 1])
+                    j += 2
+                else:
+                    raw_chars.append(src[j])
+                    j += 1
+            if j >= n:
+                raise _unterminated("$'...' quote")
+            flush()
+            segments.append(Lit(text=_ansi_c_unescape("".join(raw_chars))))
+            i = j + 1
+            continue
+        if c == "$":
+            seg, newpos = _scan_dollar_form(src, i)
+            if isinstance(seg, Lit) and seg.text == "$" and newpos == i + 1:
+                buf.append("$")
+                i = newpos
+                continue
+            flush()
+            segments.append(seg)
+            i = newpos
+            continue
+        if c == "`":
+            j = i + 1
+            while j < n and src[j] != "`":
+                if src[j] == "\\" and j + 1 < n:
+                    j += 2
+                else:
+                    j += 1
+            if j >= n:
+                raise _unterminated("backtick")
+            flush()
+            segments.append(CmdSub(src=src[i + 1 : j]))
+            i = j + 1
+            continue
+        buf.append(c)
+        i += 1
+    flush()
+    return Word(segments=segments), i
+
+
+def _scan_operator(src: str, pos: int) -> tuple[str, int]:
+    """`src[pos]` starts an operator character. Returns (operator text, new_pos)."""
+    if src[pos : pos + 3] == "<<-":
+        raise UnsupportedConstruct("heredoc", "Heredocs ('<<-') are not supported; use a temp file or a literal argument.")
+    if src[pos : pos + 3] == "<<<":
+        raise UnsupportedConstruct("here-string", "Here-strings ('<<<') are not supported; pipe the value in instead.")
+    if src[pos : pos + 2] == "<<":
+        raise UnsupportedConstruct("heredoc", "Heredocs ('<<') are not supported; use a temp file or a literal argument.")
+    if src[pos : pos + 2] == "&>":
+        return "&>", pos + 2
+    if src[pos : pos + 2] == "&&":
+        return "&&", pos + 2
+    if src[pos : pos + 2] == "||":
+        return "||", pos + 2
+    if src[pos : pos + 2] == ">>":
+        return ">>", pos + 2
+    if src[pos : pos + 2] == ">&":
+        j = pos + 2
+        while j < len(src) and src[j].isdigit():
+            j += 1
+        return src[pos:j], j
+    if src[pos] == "<" and src[pos + 1 : pos + 2] == "(":
+        raise UnsupportedConstruct("process-substitution", "Process substitution ('<(...)') is not supported.")
+    if src[pos] == ">" and src[pos + 1 : pos + 2] == "(":
+        raise UnsupportedConstruct("process-substitution", "Process substitution ('>(...)') is not supported.")
+    if src[pos] in "|&;(){}<>":
+        return src[pos], pos + 1
+    raise AssertionError(f"unreachable operator dispatch at {pos!r}")
+
+
+def tokenize(src: str) -> list[Token]:
+    n = len(src)
+    tokens: list[Token] = []
+    pos = 0
+    while pos < n:
+        c = src[pos]
+        if c in " \t":
+            pos += 1
+            continue
+        if c == "\n":
+            tokens.append(Token(kind="OP", text="\n"))
+            pos += 1
+            continue
+        if c == "\\" and src[pos + 1 : pos + 2] == "\n":
+            pos += 2
+            continue
+        # An unquoted # starts a comment only at a token boundary. A # inside a
+        # word (for example a#b) and a quoted # are ordinary data.
+        if c == "#" and (pos == 0 or src[pos - 1] in " \t\n;|&()"):
+            newline = src.find("\n", pos)
+            pos = n if newline == -1 else newline
+            continue
+        if src[pos : pos + 2] == "((":
+            raise UnsupportedConstruct("arithmetic-expansion", "Arithmetic command '((...))' is not supported.")
+        if c.isdigit():
+            j = pos
+            while j < n and src[j].isdigit():
+                j += 1
+            if j < n and src[j] in "<>":
+                op_text, newpos = _scan_operator(src, j)
+                tokens.append(Token(kind="OP", text=src[pos:j] + op_text))
+                pos = newpos
+                continue
+        if c == "{" and not (pos + 1 >= n or src[pos + 1] in " \t\n"):
+            word, newpos = _scan_word(src, pos)
+            tokens.append(Token(kind="WORD", segments=word.segments))
+            pos = newpos
+            continue
+        if c in "|&;(){}<>":
+            op_text, newpos = _scan_operator(src, pos)
+            tokens.append(Token(kind="OP", text=op_text))
+            pos = newpos
+            continue
+        word, newpos = _scan_word(src, pos)
+        tokens.append(Token(kind="WORD", segments=word.segments))
+        pos = newpos
+    return tokens

package/dist/bundled-resources/skills/tool-call-repair/SKILL.md

@@ -43,20 +43,30 @@ compounding saving is the feature.
    `Check`. Repairs are O(validation-errors), not O(schema): a static
    `(expect, got)` dispatch Map, precompiled matchers, no RegExp/schema
    compilation/JSON parse per call except the one a mode explicitly needs.
-   Bounded work: ≤1 clone, ≤1 transform per failing path, ≤1 sub-Check per
-   transform, exactly 1 whole-args re-Check, no transform loops. A microbench
-   fixture GATES this (clean-path cost within noise of a bare Check). Adding
+   Bounded work: ≤1 clone, ≤1 transform per failing path per pass, ≤1
+   sub-Check per transform, up to `MAX_REPAIR_PASSES` (3, `repairer.ts`)
+   whole-args re-Checks — a BOUNDED multi-pass, not an unconditional loop: one
+   pass's transform can expose an error a fresh validator walk must see (an
+   outer json-string-parse turning a stringified object into a real object
+   whose own property-case/scalar drift was invisible to the first pass's
+   error list). The bound is the deepest TESTED cascade (2 passes) plus one
+   margin layer, not an arbitrary ceiling — test-enforced in
+   `tool-repair.test.ts`. A microbench fixture GATES this (clean-path cost
+   within noise of a bare Check; repaired-path under a fixed budget). Adding
    the 20th failure mode must cost the hot path nothing.
 3. **Shape repairs only.** A repair may reshape what the model clearly meant
    (parse a stringified array, wrap a bare item, drop a null optional). It may
    never invent a value. Required-but-null, cross-field constraints, and
-   semantic errors are relational: bounce those to the model. The current
-   `coercePrimitiveByType` null-to-zero-value behavior violates this rule and
-   is scheduled to be replaced by the catalogue's null rule.
+   semantic errors are relational: bounce those to the model. The catalogue's
+   null rule is what's live (`nullOptionalDrop`/`nullRequiredBounce`): an
+   optional `null` is dropped; a required `null` bounces with feedback.
+   Nothing invents a zero-value substitute.
 4. **Uniform across schema kinds.** TypeBox tools (built-ins) and plain
-   JSON-schema tools (MCP, extensions) get the same repair set. Today
-   built-ins get FEWER repairs (the `hasTypeBoxMetadata` guard skips the
-   coercion pass); that asymmetry is a defect, not a design.
+   JSON-schema tools (MCP, extensions) get the same repair set: every schema
+   compiles through the one TypeBox validator (`validation.ts`'s
+   `getValidator`, shared with `repairer.ts` per decision D3) regardless of
+   its origin, so there is no separate coercion pass that only some tools
+   reach.
 5. **Every repair is check-guarded and ordered.** Apply on a cloned candidate,
    keep only if the sub-check passes. Within string-where-array-expected, try
    JSON.parse FIRST and wrap second, or `'["a","b"]'` becomes `['["a","b"]']`.

package/dist/bundled-resources/skills/tool-call-repair/references/failure-grammar.md

@@ -41,8 +41,23 @@ Rules that keep this deterministic and safe:
   stringified array becomes an array, not a wrapped string. Across paths:
   instance-path order. Root property-key casing repair runs before these per-path
   transforms because required-property validator errors do not carry the misspelled key path.
-- **One re-Check.** After all per-path transforms, Check the whole args once.
-  Pass → return repaired; fail → bounce. Never loop transforms.
+- **Bounded multi-pass.** After all per-path transforms, Check the whole args
+  once. Pass → return repaired. Fail → repeat the walk-transform-Check cycle,
+  up to `MAX_REPAIR_PASSES` (3, `repairer.ts`) whole-args re-Checks total;
+  still failing after the bound → bounce. This is a sanctioned BOUNDED loop
+  (decision D1), not the unconditional retry banned elsewhere in this file: a
+  real cascade needs it because one pass's transform can expose an error a
+  fresh validator walk must see — e.g. an outer `jsonStringParse` (mode 2)
+  turns a stringified object into a real object whose OWN properties
+  (`propertyCaseNormalize`, `numberFromString`, ...) were invisible to the
+  first pass's error list, since those errors only exist once the outer
+  string is a real object. Each pass is still O(validation-errors) via the
+  same static dispatch, so total cost across the bound stays small and
+  linear; a microbench (D2) gates the repaired-path budget. The bound is the
+  deepest TESTED cascade (2 passes, the json-string-parse-then-nested-fixture
+  case) plus one margin layer — not an arbitrary ceiling; a test
+  (`tool-repair.test.ts`, "repair multi-pass bound (D1)") fails if any tested
+  cascade needs more passes than the bound allows.
 - Modes 2b and 6–11 are the increment past the original four; each is guard-gated so
   it can only ever turn an invalid call into a valid one, never change a
   valid call (the hot path never reaches them — see Performance).
@@ -119,9 +134,11 @@ The failure grammar only ever runs on ALREADY-FAILED calls. The hot path
    at module load. Nothing in the repair path constructs a RegExp, compiles a
    schema, or parses JSON except the one `JSON.parse` a mode explicitly needs.
 4. **Bounded work.** At most: one clone of args, one transform per failing
-   path, one sub-Check per attempted transform, one whole-args re-Check. No
-   loops over transforms, no backtracking search. Worst case is linear in the
-   number of validation errors, which is itself tiny.
+   path PER PASS, one sub-Check per attempted transform, up to
+   `MAX_REPAIR_PASSES` (3) whole-args re-Checks (decision D1's sanctioned
+   bounded multi-pass — see above; not an unbounded loop, no backtracking
+   search). Worst case is linear in the number of validation errors times the
+   pass bound, both of which are themselves tiny.
 5. **Text protocol only for flagged models.** The parser (R38) runs only when
    a model is configured for text mode; native-tool-call models never invoke
    it. The primer is generated once per session, not per turn.

package/dist/bundled-resources/skills/tool-call-repair/references/repair-catalogue.md

@@ -41,7 +41,9 @@ Registry mode names currently in force:
 - Repair: delete key P from its parent object.
 - If P IS required: no repair. Bounce. Inventing `0`/`""`/`false` corrupts
   intent (`limit: null` becoming `limit: 0` changes the program). This
-  replaces the current `coercePrimitiveByType` null branches.
+  replaced the old `coercePrimitiveByType` null-to-zero-value branches, which
+  are gone from the code (verified: zero references in `validation.ts` /
+  `tool-repair/`).
 
 ### 2. json-string-encoded array or object (`jsonStringParse`)
 - Error signature: expected array (or object) at P, received string.
@@ -102,11 +104,9 @@ touching the live path.
 |---|---|---|
 | Streaming args assembly | each provider, `parseStreamingJson(partialJson)`; e.g. `openai-completions.ts` ~:382, `anthropic.ts` ~:623 | tolerant partial parse; no repair here (correct; keep providers dumb) |
 | Blind pre-repair hook | `Tool.prepareArguments`, only user: `edit.ts` `prepareEditArguments` ~:95 | legacy special case of repair 2 for `edits` only (comment names GLM-5.1); delete once general repair lands |
-| Scalar conversion | `validation.ts` ~:294 `Value.Convert` | fine (string "5" to 5 etc.) |
-| Custom coercion | `validation.ts` `coerceWithJsonSchema` ~:205 | runs ONLY for non-TypeBox schemas (`hasTypeBoxMetadata` guard ~:297): built-ins get fewer repairs, backwards. null-to-zero-value branches ~:80-145 violate the relational rule |
-| Check + error | `validation.ts` ~:311-323 | per-path errors + received args; does NOT echo expected schema fragment |
+| Check + error | `validation.ts` `validateToolArguments` ~:409-467, `getValidator` ~:97 | ONE TypeBox-compiled validator per schema regardless of origin (D5: the old ad-hoc `coerceWithJsonSchema`/`coerceWithUnionSchema`/`Value.Convert` coercion layer and its `hasTypeBoxMetadata` non-TypeBox-only guard are gone from the code — grep confirms zero references); per-path errors + received args feed `analyzer.ts`; does NOT itself echo the expected schema fragment (see gap 3 below) |
 | Failure feedback | `agent-loop.ts` ~:700-704 | validation error becomes error tool result; model-side retry is the only recovery today |
-| Check-guarded pattern precedent | `validation.ts` `coerceWithUnionSchema` ~:193 | clone, coerce, Check; reuse this shape for all repairs |
+| Check-guarded pattern precedent | `repairer.ts` `repairToolArguments` ~:376-420 | clone, transform, sub-Check, keep-iff-passes; every named repair in the registry follows this shape (decision 5) |
 
 ## Adjacent gap backlog (separate items, code-anchored)