@caupulican/pi-adaptative 0.85.0 → 0.85.4

package/CHANGELOG.md

@@ -1,3 +1,57 @@
+## [0.85.4] - 2026-08-04
+
+### Breaking Changes
+
+- Removed model-visible `action` and `intentId` phases from `write` and `edit`; callers now send one semantic mutation containing the path and payload while the harness owns preflight.
+
+### Added
+
+- Added a Pi-managed local execution path for the complete Bonsai and Ternary-Bonsai GGUF families through a pinned Prism llama.cpp runtime, with exact model identity checks, bounded host-derived resource profiles, warm residency, validated paired-drafter policy, and complete Windows x64 CUDA archive installation.
+- Added LFM2.5-8B-A1B Q4_K_M to the curated local-model roster as a native-tool-first sparse-MoE worker candidate, with task-scale `/fitness` gating before role assignment and phone-protocol calibration only after native-call failure.
+
+### Changed
+
+- Shape and hard-gate the stable system prompt from the same model-capability profile that filters tools and lanes: lean, minimal, and chat models receive bounded role-specific contracts, oversized project instructions are deferred by path, constrained static memory obeys its prompt budget, and aggregate expansion is rejected after extension overrides without changing native-versus-phone tool protocol selection.
+- Made `write` and `edit` single-call model operations while keeping path/capability preflight, serialized stale-target rechecks, and exclusive create semantics harness-owned.
+
+### Fixed
+
+- Hardened phone-protocol tool execution for non-native local models with reasoning-channel envelope recovery, parallel-call identity, single-call write/edit examples, bounded corrective teaching after failures, and protection against repeating an already-successful mutation.
+- Prevented write/edit safety preparation from duplicating model tool calls; edit now also rechecks target identity immediately before writing and discards preview plans when source bytes differ, preserving and reporting external changes.
+- Retained an exact, digest-verified write or edit payload after a target-only collision or path failure so repair needs only a corrected path; references are session-isolated, bounded, expiring, kind-checked, and consumed after a successful mutation, while invalid references and non-target failures are never presented as retargetable.
+- Prevented active goals from becoming permanently blocked by an `Agent is already processing` race: foreground ownership now spans retry/follow-up idle gaps, background handoffs queue into that owner, and goal continuation waits event-first without counting rejected admission as a turn or failure.
+- Kept sanitized tool-failure projections authoritative through session context extensions and invoked each extension context handler once per provider request.
+- Fixed simultaneous background-tool completions racing separate notification prompts: terminal handoffs are now bounded, coalesced, and serialized while every task result remains individually retrievable through `tool_task`.
+- Required Amazon Bedrock to use a durable verified profile-and-region scope, with STS/control-plane discovery, bounded runtime probes, exact model visibility, and request-level region/profile binding; `us-east-2` now resolves only US inference profiles.
+- Kept source and bundled extension loading compatible with the lean Bedrock provider entry so startup and transactional reload resolve the same module boundary.
+- Updated Undici to 8.9.0 to fix cache-directive parsing, retry framing, blob media-type, cache-control whitespace, and cookie-attribute advisories.
+- Serialized asynchronous foreground preparation and terminal background delivery under one identity-bound owner; isolated retained mutation payloads per session and lane without cross-tenant eviction; incrementally indexed worker-input handoffs for long sessions; and transactionally reconciled concurrent `MEMORY.md`/`USER.md` writers with interrupted-write recovery.
+
+## [0.85.3] - 2026-08-03
+
+### Fixed
+
+- Fixed the bundled Windows incident collector on PowerShell 5.1 hosts where the module-provided `Get-FileHash` command is unavailable.
+- Fixed native Windows path canonicalization so 8.3 short paths and their long-path spellings resolve to one resource identity.
+- Fixed cooperative worker cleanup under Windows file-lock contention so terminal state is durably persisted, including cleanup requested during the adoption grace window.
+- Fixed system Python detection incorrectly accepting the Windows Store execution alias or another non-Python executable as an installed interpreter.
+
+## [0.85.2] - 2026-08-03
+
+### Fixed
+
+- Fixed fresh Windows search-tool provisioning by pinning checksum-verified `fd` release assets instead of relying on GitHub's rate-limited latest-release API, and hardened Windows release-gate portability without enabling unsupported native tmux.
+
+## [0.85.1] - 2026-08-03
+
+### Fixed
+
+- Prevented concurrent and ineffective repeated auto-compaction runs in image-heavy sessions and contexts with protected recent messages.
+- Fixed Windows runtime probes and case-insensitive context-file identity, plus Bash-like path parsing, portable `printf`, word-list and arithmetic `for` loops, and nested `break`/`continue` in the managed shell.
+- Preserved managed-tool provisioning causes and bounded execution-failure guidance in recovery logs, failure corpora, and `/toolhealth`.
+- Kept proven native tool-call models off the phone/text protocol and routed phone validation, repair teaching, and failure guidance through the shared tool pipeline.
+- Required the exact release ref to pass Linux and Windows CI before publishing binaries.
+
 ## [0.85.0] - 2026-08-02
 
 ### Breaking Changes

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

@@ -0,0 +1,364 @@
+"""Safe integer-expression parser/evaluator for arithmetic ``for ((...))`` loops.
+
+The evaluator deliberately does not call Python ``eval``. It accepts the integer,
+variable, update, assignment, comparison, logical, bitwise, and conditional operators
+used by Bash loop headers, then applies signed 64-bit wrapping after arithmetic writes.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from state import ShellState
+
+_MASK = (1 << 64) - 1
+_SIGN_BIT = 1 << 63
+_ASSIGNMENT_OPERATORS = frozenset(
+    {"=", "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", "&=", "^=", "|="}
+)
+_TOKEN_RE = re.compile(
+    r"\s*(?:"
+    r"(?P<number>0[xX][0-9A-Fa-f]+|0[bB][01]+|0[0-7]+|[0-9]+)"
+    r"|(?P<variable>\$?[A-Za-z_][A-Za-z0-9_]*)"
+    r"|(?P<operator>\*\*|\+\+|--|<<=|>>=|\+=|-=|\*=|/=|%=|&=|\^=|\|="
+    r"|\|\||&&|==|!=|<=|>=|<<|>>|[=+\-*/%<>()!~&^|?:,])"
+    r")"
+)
+
+
+class ArithmeticError(ValueError):
+    """A bounded syntax or runtime failure in a loop arithmetic expression."""
+
+
+@dataclass(frozen=True)
+class _Token:
+    kind: str
+    text: str
+
+
+@dataclass(frozen=True)
+class _Number:
+    value: int
+
+
+@dataclass(frozen=True)
+class _Variable:
+    name: str
+
+
+@dataclass(frozen=True)
+class _Unary:
+    operator: str
+    operand: "_Expression"
+
+
+@dataclass(frozen=True)
+class _Binary:
+    operator: str
+    left: "_Expression"
+    right: "_Expression"
+
+
+@dataclass(frozen=True)
+class _Conditional:
+    condition: "_Expression"
+    when_true: "_Expression"
+    when_false: "_Expression"
+
+
+@dataclass(frozen=True)
+class _Assignment:
+    operator: str
+    target: _Variable
+    value: "_Expression"
+
+
+@dataclass(frozen=True)
+class _Update:
+    operator: str
+    target: _Variable
+    prefix: bool
+
+
+@dataclass(frozen=True)
+class _Sequence:
+    expressions: tuple["_Expression", ...]
+
+
+_Expression = _Number | _Variable | _Unary | _Binary | _Conditional | _Assignment | _Update | _Sequence
+
+
+def _wrap(value: int) -> int:
+    unsigned = value & _MASK
+    return unsigned - (1 << 64) if unsigned & _SIGN_BIT else unsigned
+
+
+def _parse_integer(text: str) -> int:
+    if text.lower().startswith(("0x", "0b")):
+        return _wrap(int(text, 0))
+    if len(text) > 1 and text.startswith("0"):
+        return _wrap(int(text, 8))
+    return _wrap(int(text, 10))
+
+
+def _tokenize(source: str) -> list[_Token]:
+    tokens: list[_Token] = []
+    position = 0
+    while position < len(source):
+        match = _TOKEN_RE.match(source, position)
+        if match is None:
+            excerpt = source[position : position + 16]
+            raise ArithmeticError(f"unexpected arithmetic token near {excerpt!r}")
+        kind = match.lastgroup
+        assert kind is not None
+        text = match.group(kind)
+        if kind == "variable" and text.startswith("$"):
+            text = text[1:]
+        tokens.append(_Token(kind, text))
+        position = match.end()
+    tokens.append(_Token("end", ""))
+    return tokens
+
+
+class _Parser:
+    def __init__(self, source: str) -> None:
+        self.tokens = _tokenize(source)
+        self.index = 0
+
+    def current(self) -> _Token:
+        return self.tokens[self.index]
+
+    def accept(self, operator: str) -> bool:
+        if self.current().kind == "operator" and self.current().text == operator:
+            self.index += 1
+            return True
+        return False
+
+    def require(self, operator: str) -> None:
+        if not self.accept(operator):
+            raise ArithmeticError(f"expected {operator!r} in arithmetic expression")
+
+    def parse(self) -> _Expression:
+        expression = self.parse_sequence()
+        if self.current().kind != "end":
+            raise ArithmeticError(f"unexpected arithmetic token {self.current().text!r}")
+        return expression
+
+    def parse_sequence(self) -> _Expression:
+        expressions = [self.parse_assignment()]
+        while self.accept(","):
+            expressions.append(self.parse_assignment())
+        return expressions[0] if len(expressions) == 1 else _Sequence(tuple(expressions))
+
+    def parse_assignment(self) -> _Expression:
+        target = self.parse_conditional()
+        token = self.current()
+        if token.kind != "operator" or token.text not in _ASSIGNMENT_OPERATORS:
+            return target
+        self.index += 1
+        if not isinstance(target, _Variable):
+            raise ArithmeticError("the left side of an arithmetic assignment must be a variable")
+        return _Assignment(token.text, target, self.parse_assignment())
+
+    def parse_conditional(self) -> _Expression:
+        condition = self.parse_logical_or()
+        if not self.accept("?"):
+            return condition
+        when_true = self.parse_sequence()
+        self.require(":")
+        return _Conditional(condition, when_true, self.parse_assignment())
+
+    def parse_logical_or(self) -> _Expression:
+        return self._parse_left_associative(self.parse_logical_and, frozenset({"||"}))
+
+    def parse_logical_and(self) -> _Expression:
+        return self._parse_left_associative(self.parse_bitwise_or, frozenset({"&&"}))
+
+    def parse_bitwise_or(self) -> _Expression:
+        return self._parse_left_associative(self.parse_bitwise_xor, frozenset({"|"}))
+
+    def parse_bitwise_xor(self) -> _Expression:
+        return self._parse_left_associative(self.parse_bitwise_and, frozenset({"^"}))
+
+    def parse_bitwise_and(self) -> _Expression:
+        return self._parse_left_associative(self.parse_equality, frozenset({"&"}))
+
+    def parse_equality(self) -> _Expression:
+        return self._parse_left_associative(self.parse_relational, frozenset({"==", "!="}))
+
+    def parse_relational(self) -> _Expression:
+        return self._parse_left_associative(self.parse_shift, frozenset({"<", "<=", ">", ">="}))
+
+    def parse_shift(self) -> _Expression:
+        return self._parse_left_associative(self.parse_additive, frozenset({"<<", ">>"}))
+
+    def parse_additive(self) -> _Expression:
+        return self._parse_left_associative(self.parse_multiplicative, frozenset({"+", "-"}))
+
+    def parse_multiplicative(self) -> _Expression:
+        return self._parse_left_associative(self.parse_power, frozenset({"*", "/", "%"}))
+
+    def parse_power(self) -> _Expression:
+        left = self.parse_unary()
+        if self.accept("**"):
+            return _Binary("**", left, self.parse_power())
+        return left
+
+    def parse_unary(self) -> _Expression:
+        token = self.current()
+        if token.kind == "operator" and token.text in ("+", "-", "!", "~"):
+            self.index += 1
+            return _Unary(token.text, self.parse_unary())
+        if token.kind == "operator" and token.text in ("++", "--"):
+            self.index += 1
+            target = self.parse_unary()
+            if not isinstance(target, _Variable):
+                raise ArithmeticError(f"{token.text} requires a variable")
+            return _Update(token.text, target, True)
+        return self.parse_postfix()
+
+    def parse_postfix(self) -> _Expression:
+        expression = self.parse_primary()
+        token = self.current()
+        if token.kind == "operator" and token.text in ("++", "--"):
+            self.index += 1
+            if not isinstance(expression, _Variable):
+                raise ArithmeticError(f"{token.text} requires a variable")
+            return _Update(token.text, expression, False)
+        return expression
+
+    def parse_primary(self) -> _Expression:
+        token = self.current()
+        if token.kind == "number":
+            self.index += 1
+            return _Number(_parse_integer(token.text))
+        if token.kind == "variable":
+            self.index += 1
+            return _Variable(token.text)
+        if self.accept("("):
+            expression = self.parse_sequence()
+            self.require(")")
+            return expression
+        raise ArithmeticError(f"expected an integer, variable, or '('; found {token.text!r}")
+
+    def _parse_left_associative(self, operand_parser, operators: frozenset[str]) -> _Expression:
+        expression = operand_parser()
+        while self.current().kind == "operator" and self.current().text in operators:
+            operator = self.current().text
+            self.index += 1
+            expression = _Binary(operator, expression, operand_parser())
+        return expression
+
+
+def compile_arithmetic(source: str) -> _Expression | None:
+    stripped = source.strip()
+    return None if not stripped else _Parser(stripped).parse()
+
+
+def _variable_value(variable: _Variable, state: ShellState) -> int:
+    text = state.env.get(variable.name, "").strip()
+    if not text:
+        return 0
+    try:
+        return _parse_integer(text)
+    except ValueError:
+        return 0
+
+
+def _set_variable(variable: _Variable, value: int, state: ShellState) -> int:
+    wrapped = _wrap(value)
+    state.setenv(variable.name, str(wrapped))
+    return wrapped
+
+
+def _divide(left: int, right: int) -> int:
+    if right == 0:
+        raise ArithmeticError("division by zero")
+    quotient = abs(left) // abs(right)
+    return -quotient if (left < 0) != (right < 0) else quotient
+
+
+def _binary(operator: str, left: int, right: int) -> int:
+    if operator == "+":
+        return _wrap(left + right)
+    if operator == "-":
+        return _wrap(left - right)
+    if operator == "*":
+        return _wrap(left * right)
+    if operator == "/":
+        return _wrap(_divide(left, right))
+    if operator == "%":
+        return _wrap(left - _divide(left, right) * right)
+    if operator == "**":
+        if right < 0:
+            raise ArithmeticError("negative exponent")
+        return _wrap(pow(left & _MASK, right, 1 << 64))
+    if operator in ("<<", ">>"):
+        if right < 0 or right >= 64:
+            raise ArithmeticError("shift count must be between 0 and 63")
+        return _wrap(left << right) if operator == "<<" else _wrap(left >> right)
+    if operator == "&":
+        return _wrap(left & right)
+    if operator == "^":
+        return _wrap(left ^ right)
+    if operator == "|":
+        return _wrap(left | right)
+    if operator == "==":
+        return int(left == right)
+    if operator == "!=":
+        return int(left != right)
+    if operator == "<":
+        return int(left < right)
+    if operator == "<=":
+        return int(left <= right)
+    if operator == ">":
+        return int(left > right)
+    if operator == ">=":
+        return int(left >= right)
+    raise ArithmeticError(f"unsupported arithmetic operator {operator!r}")
+
+
+def evaluate_arithmetic(expression: _Expression | None, state: ShellState) -> int:
+    if expression is None:
+        return 0
+    if isinstance(expression, _Number):
+        return expression.value
+    if isinstance(expression, _Variable):
+        return _variable_value(expression, state)
+    if isinstance(expression, _Sequence):
+        result = 0
+        for item in expression.expressions:
+            result = evaluate_arithmetic(item, state)
+        return result
+    if isinstance(expression, _Conditional):
+        branch = expression.when_true if evaluate_arithmetic(expression.condition, state) != 0 else expression.when_false
+        return evaluate_arithmetic(branch, state)
+    if isinstance(expression, _Unary):
+        value = evaluate_arithmetic(expression.operand, state)
+        if expression.operator == "+":
+            return value
+        if expression.operator == "-":
+            return _wrap(-value)
+        if expression.operator == "!":
+            return int(value == 0)
+        if expression.operator == "~":
+            return _wrap(~value)
+    if isinstance(expression, _Binary):
+        left = evaluate_arithmetic(expression.left, state)
+        if expression.operator == "&&":
+            return int(left != 0 and evaluate_arithmetic(expression.right, state) != 0)
+        if expression.operator == "||":
+            return int(left != 0 or evaluate_arithmetic(expression.right, state) != 0)
+        return _binary(expression.operator, left, evaluate_arithmetic(expression.right, state))
+    if isinstance(expression, _Assignment):
+        right = evaluate_arithmetic(expression.value, state)
+        if expression.operator == "=":
+            return _set_variable(expression.target, right, state)
+        left = _variable_value(expression.target, state)
+        return _set_variable(expression.target, _binary(expression.operator[:-1], left, right), state)
+    if isinstance(expression, _Update):
+        old = _variable_value(expression.target, state)
+        new = _set_variable(expression.target, old + (1 if expression.operator == "++" else -1), state)
+        return new if expression.prefix else old
+    raise ArithmeticError("unrecognized arithmetic expression")

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

@@ -44,9 +44,10 @@ class ExecContext:
     builtins: Mapping[str, BuiltinFn]
     deadline: float | None
     stderr: BinaryIO | int | None = None
+    loop_depth: int = 0
 
 
 # Executor-owned builtins are NOT in commands/REGISTRY: state mutators and `exit`
 # need ShellState/control-flow access, while the runner needs the executor.
-STATE_BUILTINS = {"cd", "export", "unset", "exit"}
+STATE_BUILTINS = {"cd", "export", "unset", "exit", "break", "continue"}
 RUNNER_BUILTINS = {"xargs"}

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

@@ -55,3 +55,19 @@ class ShellExit(Exception):
     def __init__(self, exit_code: int) -> None:
         super().__init__(exit_code)
         self.exit_code = exit_code
+
+
+class LoopControl(Exception):
+    """Internal non-local control transfer consumed by enclosing loop nodes."""
+
+    def __init__(self, levels: int) -> None:
+        super().__init__(levels)
+        self.levels = levels
+
+
+class LoopBreak(LoopControl):
+    """Leave one or more enclosing loops."""
+
+
+class LoopContinue(LoopControl):
+    """Continue one or more enclosing loops."""