qlogicagent 2.18.11 → 2.19.1

package/dist/vendor/hatch-pet/scripts/render_animation_previews.py

@@ -1,78 +1,78 @@
-#!/usr/bin/env python3
-"""Render lightweight animated QA previews from extracted Codex pet frames."""
-
-from __future__ import annotations
-
-import argparse
-import json
-from pathlib import Path
-
-from PIL import Image
-
-ROW_DURATIONS = {
-    "idle": [280, 110, 110, 140, 140, 320],
-    "running-right": [120, 120, 120, 120, 120, 120, 120, 220],
-    "running-left": [120, 120, 120, 120, 120, 120, 120, 220],
-    "waving": [140, 140, 140, 280],
-    "jumping": [140, 140, 140, 140, 280],
-    "failed": [140, 140, 140, 140, 140, 140, 140, 240],
-    "waiting": [150, 150, 150, 150, 150, 260],
-    "running": [120, 120, 120, 120, 120, 220],
-    "review": [150, 150, 150, 150, 150, 280],
-}
-IMAGE_SUFFIXES = {".png", ".webp", ".jpg", ".jpeg"}
-
-
-def frame_files(state_dir: Path) -> list[Path]:
-    if not state_dir.is_dir():
-        return []
-    return sorted(path for path in state_dir.iterdir() if path.suffix.lower() in IMAGE_SUFFIXES)
-
-
-def load_frames(frames_root: Path, state: str, expected_count: int) -> list[Image.Image]:
-    files = frame_files(frames_root / state)
-    if len(files) != expected_count:
-        raise SystemExit(
-            f"{state} preview needs {expected_count} frames, found {len(files)} under {frames_root / state}"
-        )
-    frames = []
-    for path in files:
-        with Image.open(path) as opened:
-            frames.append(opened.convert("RGBA"))
-    return frames
-
-
-def save_preview(frames: list[Image.Image], durations: list[int], output: Path) -> None:
-    output.parent.mkdir(parents=True, exist_ok=True)
-    frames[0].save(
-        output,
-        save_all=True,
-        append_images=frames[1:],
-        duration=durations,
-        loop=0,
-        disposal=2,
-        optimize=False,
-    )
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--frames-root", required=True)
-    parser.add_argument("--output-dir", required=True)
-    args = parser.parse_args()
-
-    frames_root = Path(args.frames_root).expanduser().resolve()
-    output_dir = Path(args.output_dir).expanduser().resolve()
-    previews = []
-    for state, durations in ROW_DURATIONS.items():
-        frames = load_frames(frames_root, state, len(durations))
-        output = output_dir / f"{state}.gif"
-        save_preview(frames, durations, output)
-        previews.append({"state": state, "path": str(output), "frames": len(frames)})
-
-    result = {"ok": True, "output_dir": str(output_dir), "previews": previews}
-    print(json.dumps(result, indent=2))
-
-
-if __name__ == "__main__":
-    main()
+#!/usr/bin/env python3
+"""Render lightweight animated QA previews from extracted Codex pet frames."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from PIL import Image
+
+ROW_DURATIONS = {
+    "idle": [280, 110, 110, 140, 140, 320],
+    "running-right": [120, 120, 120, 120, 120, 120, 120, 220],
+    "running-left": [120, 120, 120, 120, 120, 120, 120, 220],
+    "waving": [140, 140, 140, 280],
+    "jumping": [140, 140, 140, 140, 280],
+    "failed": [140, 140, 140, 140, 140, 140, 140, 240],
+    "waiting": [150, 150, 150, 150, 150, 260],
+    "running": [120, 120, 120, 120, 120, 220],
+    "review": [150, 150, 150, 150, 150, 280],
+}
+IMAGE_SUFFIXES = {".png", ".webp", ".jpg", ".jpeg"}
+
+
+def frame_files(state_dir: Path) -> list[Path]:
+    if not state_dir.is_dir():
+        return []
+    return sorted(path for path in state_dir.iterdir() if path.suffix.lower() in IMAGE_SUFFIXES)
+
+
+def load_frames(frames_root: Path, state: str, expected_count: int) -> list[Image.Image]:
+    files = frame_files(frames_root / state)
+    if len(files) != expected_count:
+        raise SystemExit(
+            f"{state} preview needs {expected_count} frames, found {len(files)} under {frames_root / state}"
+        )
+    frames = []
+    for path in files:
+        with Image.open(path) as opened:
+            frames.append(opened.convert("RGBA"))
+    return frames
+
+
+def save_preview(frames: list[Image.Image], durations: list[int], output: Path) -> None:
+    output.parent.mkdir(parents=True, exist_ok=True)
+    frames[0].save(
+        output,
+        save_all=True,
+        append_images=frames[1:],
+        duration=durations,
+        loop=0,
+        disposal=2,
+        optimize=False,
+    )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--frames-root", required=True)
+    parser.add_argument("--output-dir", required=True)
+    args = parser.parse_args()
+
+    frames_root = Path(args.frames_root).expanduser().resolve()
+    output_dir = Path(args.output_dir).expanduser().resolve()
+    previews = []
+    for state, durations in ROW_DURATIONS.items():
+        frames = load_frames(frames_root, state, len(durations))
+        output = output_dir / f"{state}.gif"
+        save_preview(frames, durations, output)
+        previews.append({"state": state, "path": str(output), "frames": len(frames)})
+
+    result = {"ok": True, "output_dir": str(output_dir), "previews": previews}
+    print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()

package/dist/vendor/hatch-pet/scripts/validate_atlas.py

@@ -1,157 +1,157 @@
-#!/usr/bin/env python3
-"""Validate a Codex pet spritesheet atlas."""
-
-from __future__ import annotations
-
-import argparse
-import json
-from collections import defaultdict
-from pathlib import Path
-
-from PIL import Image
-
-COLUMNS = 8
-ROWS = 9
-CELL_WIDTH = 192
-CELL_HEIGHT = 208
-ATLAS_WIDTH = COLUMNS * CELL_WIDTH
-ATLAS_HEIGHT = ROWS * CELL_HEIGHT
-ROW_BY_INDEX = {
-    0: ("idle", 6),
-    1: ("running-right", 8),
-    2: ("running-left", 8),
-    3: ("waving", 4),
-    4: ("jumping", 5),
-    5: ("failed", 8),
-    6: ("waiting", 6),
-    7: ("running", 6),
-    8: ("review", 6),
-}
-
-
-def alpha_nonzero_count(image: Image.Image) -> int:
-    alpha = image.getchannel("A")
-    return sum(alpha.histogram()[1:])
-
-
-def transparent_rgb_residue_count(image: Image.Image) -> int:
-    rgba = image.convert("RGBA")
-    data = rgba.tobytes()
-    count = 0
-    for index in range(0, len(data), 4):
-        red, green, blue, alpha = data[index : index + 4]
-        if alpha == 0 and (red or green or blue):
-            count += 1
-    return count
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("atlas")
-    parser.add_argument("--json-out")
-    parser.add_argument("--min-used-pixels", type=int, default=50)
-    parser.add_argument("--near-opaque-threshold", type=float, default=0.95)
-    parser.add_argument("--allow-opaque", action="store_true")
-    parser.add_argument("--allow-near-opaque-used-cells", action="store_true")
-    args = parser.parse_args()
-
-    atlas_path = Path(args.atlas).expanduser().resolve()
-    errors: list[str] = []
-    warnings: list[str] = []
-    near_opaque_used_cells: dict[str, list[int]] = defaultdict(list)
-    cells: list[dict[str, object]] = []
-
-    try:
-        with Image.open(atlas_path) as opened:
-            source_mode = opened.mode
-            source_format = opened.format
-            image = opened.convert("RGBA")
-    except Exception as exc:  # noqa: BLE001
-        result = {"ok": False, "errors": [f"could not open atlas: {exc}"], "warnings": []}
-        print(json.dumps(result, indent=2))
-        raise SystemExit(1)
-
-    if image.size != (ATLAS_WIDTH, ATLAS_HEIGHT):
-        errors.append(f"expected {ATLAS_WIDTH}x{ATLAS_HEIGHT}, got {image.width}x{image.height}")
-
-    if source_format not in {"PNG", "WEBP"}:
-        errors.append(f"expected PNG or WebP, got {source_format}")
-
-    if "A" not in source_mode and not args.allow_opaque:
-        errors.append("atlas does not have an alpha channel")
-
-    for row_index in range(ROWS):
-        state, frame_count = ROW_BY_INDEX[row_index]
-        for column_index in range(COLUMNS):
-            left = column_index * CELL_WIDTH
-            top = row_index * CELL_HEIGHT
-            cell = image.crop((left, top, left + CELL_WIDTH, top + CELL_HEIGHT))
-            nontransparent = alpha_nonzero_count(cell)
-            used = column_index < frame_count
-            cell_info = {
-                "state": state,
-                "row": row_index,
-                "column": column_index,
-                "used": used,
-                "nontransparent_pixels": nontransparent,
-            }
-            cells.append(cell_info)
-            if used and nontransparent < args.min_used_pixels:
-                errors.append(
-                    f"{state} row {row_index} column {column_index} is empty or too sparse ({nontransparent} pixels)"
-                )
-            if used and nontransparent > CELL_WIDTH * CELL_HEIGHT * args.near_opaque_threshold:
-                near_opaque_used_cells[f"{state} row {row_index}"].append(column_index)
-            if not used and nontransparent != 0:
-                errors.append(
-                    f"{state} row {row_index} unused column {column_index} is not transparent ({nontransparent} pixels)"
-                )
-
-    for row_label, columns in near_opaque_used_cells.items():
-        message = (
-            f"{row_label} has {len(columns)} nearly opaque used cells; "
-            "this usually means the sprite has a non-transparent background"
-        )
-        if args.allow_near_opaque_used_cells:
-            warnings.append(message)
-        else:
-            errors.append(message)
-
-    alpha_count = alpha_nonzero_count(image)
-    if alpha_count == ATLAS_WIDTH * ATLAS_HEIGHT:
-        message = "atlas is fully opaque; custom pets require a transparent sprite background"
-        if args.allow_opaque:
-            warnings.append(message)
-        else:
-            errors.append(message)
-
-    transparent_rgb_residue = transparent_rgb_residue_count(image)
-    if transparent_rgb_residue:
-        errors.append(
-            f"atlas has {transparent_rgb_residue} fully transparent pixels with non-zero RGB residue"
-        )
-
-    result = {
-        "ok": not errors,
-        "file": str(atlas_path),
-        "format": source_format,
-        "mode": source_mode,
-        "width": image.width,
-        "height": image.height,
-        "transparent_rgb_residue_pixels": transparent_rgb_residue,
-        "errors": errors,
-        "warnings": warnings,
-        "cells": cells,
-    }
-
-    if args.json_out:
-        Path(args.json_out).expanduser().resolve().write_text(
-            json.dumps(result, indent=2) + "\n", encoding="utf-8"
-        )
-
-    print(json.dumps({k: v for k, v in result.items() if k != "cells"}, indent=2))
-    raise SystemExit(0 if result["ok"] else 1)
-
-
-if __name__ == "__main__":
-    main()
+#!/usr/bin/env python3
+"""Validate a Codex pet spritesheet atlas."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from collections import defaultdict
+from pathlib import Path
+
+from PIL import Image
+
+COLUMNS = 8
+ROWS = 9
+CELL_WIDTH = 192
+CELL_HEIGHT = 208
+ATLAS_WIDTH = COLUMNS * CELL_WIDTH
+ATLAS_HEIGHT = ROWS * CELL_HEIGHT
+ROW_BY_INDEX = {
+    0: ("idle", 6),
+    1: ("running-right", 8),
+    2: ("running-left", 8),
+    3: ("waving", 4),
+    4: ("jumping", 5),
+    5: ("failed", 8),
+    6: ("waiting", 6),
+    7: ("running", 6),
+    8: ("review", 6),
+}
+
+
+def alpha_nonzero_count(image: Image.Image) -> int:
+    alpha = image.getchannel("A")
+    return sum(alpha.histogram()[1:])
+
+
+def transparent_rgb_residue_count(image: Image.Image) -> int:
+    rgba = image.convert("RGBA")
+    data = rgba.tobytes()
+    count = 0
+    for index in range(0, len(data), 4):
+        red, green, blue, alpha = data[index : index + 4]
+        if alpha == 0 and (red or green or blue):
+            count += 1
+    return count
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("atlas")
+    parser.add_argument("--json-out")
+    parser.add_argument("--min-used-pixels", type=int, default=50)
+    parser.add_argument("--near-opaque-threshold", type=float, default=0.95)
+    parser.add_argument("--allow-opaque", action="store_true")
+    parser.add_argument("--allow-near-opaque-used-cells", action="store_true")
+    args = parser.parse_args()
+
+    atlas_path = Path(args.atlas).expanduser().resolve()
+    errors: list[str] = []
+    warnings: list[str] = []
+    near_opaque_used_cells: dict[str, list[int]] = defaultdict(list)
+    cells: list[dict[str, object]] = []
+
+    try:
+        with Image.open(atlas_path) as opened:
+            source_mode = opened.mode
+            source_format = opened.format
+            image = opened.convert("RGBA")
+    except Exception as exc:  # noqa: BLE001
+        result = {"ok": False, "errors": [f"could not open atlas: {exc}"], "warnings": []}
+        print(json.dumps(result, indent=2))
+        raise SystemExit(1)
+
+    if image.size != (ATLAS_WIDTH, ATLAS_HEIGHT):
+        errors.append(f"expected {ATLAS_WIDTH}x{ATLAS_HEIGHT}, got {image.width}x{image.height}")
+
+    if source_format not in {"PNG", "WEBP"}:
+        errors.append(f"expected PNG or WebP, got {source_format}")
+
+    if "A" not in source_mode and not args.allow_opaque:
+        errors.append("atlas does not have an alpha channel")
+
+    for row_index in range(ROWS):
+        state, frame_count = ROW_BY_INDEX[row_index]
+        for column_index in range(COLUMNS):
+            left = column_index * CELL_WIDTH
+            top = row_index * CELL_HEIGHT
+            cell = image.crop((left, top, left + CELL_WIDTH, top + CELL_HEIGHT))
+            nontransparent = alpha_nonzero_count(cell)
+            used = column_index < frame_count
+            cell_info = {
+                "state": state,
+                "row": row_index,
+                "column": column_index,
+                "used": used,
+                "nontransparent_pixels": nontransparent,
+            }
+            cells.append(cell_info)
+            if used and nontransparent < args.min_used_pixels:
+                errors.append(
+                    f"{state} row {row_index} column {column_index} is empty or too sparse ({nontransparent} pixels)"
+                )
+            if used and nontransparent > CELL_WIDTH * CELL_HEIGHT * args.near_opaque_threshold:
+                near_opaque_used_cells[f"{state} row {row_index}"].append(column_index)
+            if not used and nontransparent != 0:
+                errors.append(
+                    f"{state} row {row_index} unused column {column_index} is not transparent ({nontransparent} pixels)"
+                )
+
+    for row_label, columns in near_opaque_used_cells.items():
+        message = (
+            f"{row_label} has {len(columns)} nearly opaque used cells; "
+            "this usually means the sprite has a non-transparent background"
+        )
+        if args.allow_near_opaque_used_cells:
+            warnings.append(message)
+        else:
+            errors.append(message)
+
+    alpha_count = alpha_nonzero_count(image)
+    if alpha_count == ATLAS_WIDTH * ATLAS_HEIGHT:
+        message = "atlas is fully opaque; custom pets require a transparent sprite background"
+        if args.allow_opaque:
+            warnings.append(message)
+        else:
+            errors.append(message)
+
+    transparent_rgb_residue = transparent_rgb_residue_count(image)
+    if transparent_rgb_residue:
+        errors.append(
+            f"atlas has {transparent_rgb_residue} fully transparent pixels with non-zero RGB residue"
+        )
+
+    result = {
+        "ok": not errors,
+        "file": str(atlas_path),
+        "format": source_format,
+        "mode": source_mode,
+        "width": image.width,
+        "height": image.height,
+        "transparent_rgb_residue_pixels": transparent_rgb_residue,
+        "errors": errors,
+        "warnings": warnings,
+        "cells": cells,
+    }
+
+    if args.json_out:
+        Path(args.json_out).expanduser().resolve().write_text(
+            json.dumps(result, indent=2) + "\n", encoding="utf-8"
+        )
+
+    print(json.dumps({k: v for k, v in result.items() if k != "cells"}, indent=2))
+    raise SystemExit(0 if result["ok"] else 1)
+
+
+if __name__ == "__main__":
+    main()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qlogicagent",
-  "version": "2.18.11",
+  "version": "2.19.1",
   "description": "XiaozhiClaw Agent CLI — subprocess architecture (JSON-RPC over stdio)",
   "type": "module",
   "main": "dist/index.js",
@@ -28,6 +28,10 @@
       "types": "./dist/types/protocol/wire/index.d.ts",
       "default": "./dist/protocol.js"
     },
+    "./agent-contract": {
+      "types": "./dist/types/protocol/agent-contract.d.ts",
+      "default": "./dist/agent-contract.js"
+    },
     "./permissions": {
       "types": "./dist/types/permissions.d.ts",
       "default": "./dist/permissions.js"
@@ -69,6 +73,9 @@
       "protocol": [
         "./dist/types/protocol/wire/index.d.ts"
       ],
+      "agent-contract": [
+        "./dist/types/protocol/agent-contract.d.ts"
+      ],
       "agent": [
         "./dist/types/agent/agent.d.ts"
       ],
@@ -123,6 +130,7 @@
     "check:windows-hide": "node scripts/check-windows-hide.mjs src",
     "check:test-suite-governance": "node scripts/check-test-suite-governance.mjs",
     "check:architecture-boundaries": "node scripts/check-architecture-boundaries.mjs",
+    "check:agent-contract": "node scripts/check-agent-contract-hash.mjs",
     "check:route-a-teardown": "node scripts/check-route-a-teardown.mjs",
     "check:transcript-tool-persistence": "node scripts/check-transcript-tool-persistence.mjs",
     "check:provider-core-boundary": "node scripts/check-provider-core-boundary.mjs",