kijito-tools 0.2.5 → 0.2.7

package/README.md

@@ -23,6 +23,17 @@ opt-in per pane, and the skills are convenience wrappers, not requirements.
 | `kijito-start` skill | The active, thorough version of session catch-up: load memory, read the current-state pointer and recent lessons, arm the inbox, and resume active work — or, for a new persona, set up identity and the pointer. | Yes |
 | `kijito-qa-memory` skill | Memory curation that requires writing the new memories (not only fixing existing ones), then uses a fresh subagent to confirm a cold start can reconstruct the work. | Yes |
 
+### The status line
+
+![The status line: persona, unread mail, model, context use](docs/statusline.svg)
+
+`statusline-context.sh` shows, left to right: the pane's persona (from the project's `.kijito_persona`
+marker, so several agent panes can be told apart), the persona's unread-mail count when
+[kijito-inbox-monitor](https://github.com/KijitoAI/kijito-inbox-monitor) 0.5.7 or later is running and
+has recorded one in the last 10 minutes (shown only when it is above zero), the model, and the context
+window in use. The picture is rendered from the script's real output by
+`scripts/render-statusline-svg.py`, and a test fails if the two disagree.
+
 The two skills are conveniences, not the only way in: an agent can run the same catch-up and
 curation by hand from a few prompts. They are packaged as skills because that makes them simple to
 drop into `~/.claude/skills/` and invoke the same way everywhere.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kijito-tools",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "Installer for kijito-tools: copies the context-tracking, session catch-up, and self-clear scripts plus the Kijito skills into ~/.claude.",
   "license": "Apache-2.0",
   "type": "commonjs",

package/providers/codex/release-manifest.json

@@ -14,7 +14,7 @@
   },
   "artifacts": {
     "wakeCoreSha256": "f6ca4f88841b371409dfb4946e3b427e83150bd511f38068b364de1090c5cd35",
-    "workflowSha256": "ec6a65c095e7011c3100c2a804e23c1dee1a63cfba0fb79f1b872aee91dd3b2d",
+    "workflowSha256": "4fcbb75ffc5b309a54fcc1492db983bce5f15353694b098859d048ed59197fb6",
     "planSha256": "d9d666b86ac06414f6e6a13a3e3e2115983a1dad44fcfded7eccc51b191fb451",
     "wakeHelperSha256": "838f6b4462ba037a23a14b6fdb8dc34ee8b8f4a7df258b428832bc092fac3ea4",
     "wsUdsSha256": "4da13eef89b572fb735e756cb06846a021919dec7f91c6d07989377944cc776c",

package/providers/monitor/CHANGELOG.md

@@ -3,6 +3,23 @@
 All notable changes to kijito-inbox-monitor are documented in this file.
 The format is based on Keep a Changelog, and this project follows Semantic Versioning.
 
+## [0.5.8] - 2026-09-26
+
+### Fixed
+- **Runs on native Windows** (reported from Windows 11, CPython 3.14). Four problems, each of which stopped
+  the producer or corrupted delivery there:
+  - Startup crashed with `AttributeError: module 'os' has no attribute 'geteuid'`. The private-file guard's
+    owner and 0600 checks are POSIX-only now; on Windows it still refuses anything that is not a regular
+    file.
+  - A new events file never became durable. Windows cannot open a directory to fsync it, so every sync
+    reported failure and the cursor was held forever, re-delivering the same mail. The directory fsync is
+    skipped on Windows (NTFS journals directory metadata).
+  - Every directory level printed a "writable by other local users" warning, because Windows reports
+    directories as mode 0777. That warning is POSIX-only now.
+  - On a cp1252 console or Git Bash pipe, `--help` crashed with `UnicodeEncodeError`, and so did any event
+    whose message body had a character outside cp1252 (an emoji, CJK) - mid-delivery. stdout is now
+    written as UTF-8, which JSON Lines requires anyway, and the help text is ASCII.
+
 ## [0.5.7] - 2026-09-25
 
 ### Added

package/providers/monitor/UPSTREAM

@@ -1,13 +1,13 @@
 # The upstream release providers/monitor is a byte-exact copy of (row M314).
 # Written by scripts/import-monitor.sh; verified by tests/vendored_monitor_test.sh. Never hand-edit.
 repo=KijitoAI/kijito-inbox-monitor
-sha=9ac160aa98d8205a9eabe05378d9fd7ac25d8273
-tree=65ee5cf22640992369c09d6d6f1707116093908b
-tag=v0.5.7
+sha=e3c69db68451e3e55b5b3da9c98546706fff7bff
+tree=70a8b4dfc04c7832aec37cb9124178e75f7248c9
+tag=v0.5.8
 file=100644 8d88ccb0fd09b9144505f985b4f882db278fac1f .github/workflows/publish-npm.yml
 file=100644 19ce3471a2cffa689be9d261049c1e74e3e7a25e .github/workflows/publish-pypi.yml
 file=100644 4534290a5dd36d18d07a782b784b6b0ad5ee38fc .gitignore
-file=100644 483f8aaa29ab3500ff421315bca2d894b3c40fc6 CHANGELOG.md
+file=100644 b5cd0382bcfa90cd71fa39577a41a47707ac2bac CHANGELOG.md
 file=100644 d645695673349e3947e8e5ae42332d0ac3164cd7 LICENSE
 file=100644 f6b0e5634f3fd4156c1c000efb31578bfb068cf3 NOTICE
 file=100644 73d2bf5a5d5d6cb622db014285cd9ada4c705724 README.md
@@ -15,12 +15,12 @@ file=100644 72f0c148f1e721ac1bb4a38e5cae690355774314 RELEASING.md
 file=100755 fca1203267cb726736b0c8f239e2d74c40a7a895 arm-hive-monitor.sh
 file=100755 bbe3f07de13dab8a8a7a4798481156ae4a46ab8f bin/cli.js
 file=100644 fffa8bd23749a321285bd942a3f4f4a98936129c com.kijito.inbox-monitor.plist.template
-file=100644 fc953e43bcd3069a1dc426ddefc751d8f01cf599 docs/DESIGN.md
+file=100644 b0c07b55c75e6061e6c82d5e23c2b7ddad5131cf docs/DESIGN.md
 file=100644 4f5e53a8633e60e6c57c451e28546f8af8783fe8 kijito-inbox-monitor@.service.template
-file=100644 db09ae46bf223a01ea0c2903cc886e6e09b21d43 kijito_inbox_monitor.py
-file=100644 9cea8637ea9c61323ac2298da3d521454eabd85a package.json
-file=100644 d0af8757fa4d3c3f4591f64a0e3d67d1637a9210 pyproject.toml
+file=100644 692aadd5fe603556e0ba0e9358c1487022b2bc05 kijito_inbox_monitor.py
+file=100644 53538cfa0dd2a25f68d54b2a62fb072d599cec83 package.json
+file=100644 44b676233aecdc02dc462a4144dd29120ff05d73 pyproject.toml
 file=100755 b34a5c775385ecfaefd4b374c1fc1aa082a85d14 scripts/migrate-systemd-unit.sh
 file=100755 22acef6d6875395a81c701eb535030d0a78b0df1 scripts/mutation-check.py
 file=100755 acba6196213736922fc4f7135749386d85d172a6 scripts/prepublish-gate.sh
-file=100644 8d881e5f8562d4ce6b1b22fc97bf9f1ade1d52fb test_kijito_monitor.py
+file=100644 affc54d7cf969631c3f2d9160995e933cde17a60 test_kijito_monitor.py

package/providers/monitor/docs/DESIGN.md

@@ -28,7 +28,9 @@ no pip installs) that polls the Kijito inbox and emits one event per new message
 running, as NDJSON on stdout and/or exec-a-command-per-event. It is the client-side liveness watcher: it
 keeps a running agent's inbox live by waking it between tool calls. It is not a server, and not a
 notification service. POSIX target (Linux/macOS); Windows runs interval-only (no SIGUSR1 seam, no flock,
-per §10/§7.3).
+per §10/§7.3). On Windows the private-file guard checks only "regular file" (there is no POSIX owner or
+mode; access is the profile's inherited ACL), a directory fsync is skipped (Windows cannot open a directory
+to fsync it; NTFS journals the metadata), and stdout is written as UTF-8 whatever the console code page.
 
 ## 2. The problem
 

package/providers/monitor/kijito_inbox_monitor.py

@@ -33,7 +33,7 @@ try:
 except ImportError:  # pragma: no cover - Windows
     fcntl = None
 
-__version__ = "0.5.7"
+__version__ = "0.5.8"
 SOURCE = "kijito-inbox"
 # A named User-Agent is REQUIRED: api.kijito.ai is fronted by a WAF that 403s the default Python-urllib UA.
 USER_AGENT = "kijito-inbox-monitor/%s" % __version__
@@ -1261,6 +1261,12 @@ def _assert_private_fd(fd, path):
     st = os.fstat(fd)
     if not stat.S_ISREG(st.st_mode):
         raise InsecureFile("%s is not a regular file" % path)
+    if not IS_POSIX:
+        # WINDOWS HAS NO POSIX OWNER OR MODE BITS TO CHECK (praetor, Windows 11 native, 2026-09-26: os.geteuid
+        # does not exist there, so this line crashed the producer at startup). Access there is an ACL, and a
+        # file created under the user's profile inherits a user-only ACL; st_mode reports a synthetic
+        # 0666/0444 that says nothing about who can read it. The regular-file check above still holds.
+        return
     if st.st_uid != os.geteuid():
         raise InsecureFile("%s is owned by uid %d, not by us (uid %d)" % (path, st.st_uid, os.geteuid()))
     cur = st.st_mode & 0o777
@@ -1364,6 +1370,10 @@ def _makedirs_private(path):
     # directory is never validated, and an existing one is exactly where a hostile path would already be.
     # A sticky directory (/tmp, mode 1777) is excluded: the sticky bit is precisely what makes a shared
     # writable directory safe, and warning about it would train the reader to ignore this line.
+    # POSIX only: Windows reports every directory as 0777 (access is an ACL), so the warning would fire on
+    # every level of every path and say nothing true.
+    if not IS_POSIX:
+        return
     seen = path
     while True:
         try:
@@ -1386,7 +1396,13 @@ def _fsync_dir(path):
     os.replace is atomic for a concurrent READER, but atomicity is not durability: after a power loss
     the new file's contents can be on disk while the directory entry still names the old inode - i.e. a
     silently OLDER cursor. Syncing the file alone (which is all we did) does not cover the rename.
+
+    Windows cannot open a directory for fsync at all, so this always failed there and the events sink held
+    its cursor forever on a new file. NTFS journals directory metadata itself, so there is nothing further
+    to do: report success.
     """
+    if not IS_POSIX:
+        return True
     try:
         fd = os.open(path, os.O_RDONLY)
     except OSError:
@@ -3703,7 +3719,7 @@ def build_parser():
     p.add_argument("--wait", type=int, default=50,
                    help="Long-poll hold (s) requested from /api/notify/pending so new mail wakes the watcher "
                         "near-instantly at ~the same request rate (default 50; the server clamps to its own max). "
-                        "0 disables long-poll → plain interval polling at --poll-seconds. If the server doesn't "
+                        "0 disables long-poll -> plain interval polling at --poll-seconds. If the server doesn't "
                         "support long-poll, the client auto-falls back to interval polling (no redeploy needed). "
                         "Clean shutdown during a held poll can take up to --wait seconds (a supervisor's SIGKILL "
                         "mid-hold is safe - state is persisted every cycle).")
@@ -3840,7 +3856,25 @@ def validate_args(args):
                               "not multi-persona/all-personas - each persona has its own cursor")
 
 
+def _utf8_stdout():
+    """Write stdout as UTF-8 whatever the locale says (praetor, Windows 11 native, 2026-09-26).
+
+    A Windows console or a Git Bash pipe reports cp1252, so `--help` (a non-ASCII character) and, far worse,
+    any EVENT carrying a message body outside cp1252 (an emoji, CJK) raised UnicodeEncodeError - a
+    ValueError, which the stdout sink's OSError guard does not catch, so it killed the producer mid-delivery.
+    JSON Lines is UTF-8 by definition, so that is the right encoding for every consumer. No-op where stdout
+    is already UTF-8 or cannot be reconfigured.
+    """
+    enc = (getattr(sys.stdout, "encoding", None) or "").lower().replace("-", "").replace("_", "")
+    if enc != "utf8" and hasattr(sys.stdout, "reconfigure"):
+        try:
+            sys.stdout.reconfigure(encoding="utf-8")
+        except (ValueError, OSError):
+            pass
+
+
 def main(argv=None):
+    _utf8_stdout()
     args = build_parser().parse_args(argv)
     # A pure read of an existing report: no token, no network, no state file, no watch loop. Placed
     # before validate_args so a heartbeat can call it without satisfying the watcher's own config.

package/providers/monitor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kijito-inbox-monitor",
-  "version": "0.5.7",
+  "version": "0.5.8",
   "description": "Pointer to the Python package kijito-inbox-monitor. A zero-dependency watcher that wakes a running agent when new Kijito inbox mail arrives. Install the real tool with pipx/uv/pip.",
   "license": "Apache-2.0",
   "type": "commonjs",

package/providers/monitor/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kijito-inbox-monitor"
-version = "0.5.7"
+version = "0.5.8"
 description = "Zero-dependency watcher that wakes a running agent when new Kijito inbox mail arrives."
 readme = "README.md"
 requires-python = ">=3.9"

package/providers/monitor/test_kijito_monitor.py

@@ -6274,3 +6274,83 @@ class PersistedUnreadCountTest(unittest.TestCase):
 
     def test_zero_loads(self):
         self.assertEqual(self._load({"unread": 0})["unread"], 0)
+
+
+class WindowsNativeTest(unittest.TestCase):
+    """praetor's report (Windows 11 native, CPython 3.14, 2026-09-26): the producer crashed at startup on
+    `os.geteuid` (POSIX-only) in _assert_private_fd, and `--help` crashed on a cp1252 console. The next two
+    walls after that were `_fsync_dir` (Windows cannot open a directory to fsync it, so the events sink held
+    its cursor forever on a new file) and a spurious "writable by other users" warning (Windows reports
+    every directory as 0777). Windows is SIMULATED here: IS_POSIX False and os.geteuid removed."""
+
+    def setUp(self):
+        self._d = tempfile.TemporaryDirectory()
+        self.addCleanup(self._d.cleanup)
+        self._posix, km.IS_POSIX = km.IS_POSIX, False
+        self.addCleanup(setattr, km, "IS_POSIX", self._posix)
+        self._geteuid = getattr(os, "geteuid", None)
+        if self._geteuid is not None:
+            del os.geteuid
+            self.addCleanup(setattr, os, "geteuid", self._geteuid)
+
+    def test_a_regular_file_passes_without_geteuid_and_is_not_chmodded(self):
+        p = os.path.join(self._d.name, "events.jsonl")
+        with open(p, "w"):
+            pass
+        os.chmod(p, 0o644)
+        fd = os.open(p, os.O_RDONLY)
+        try:
+            km._assert_private_fd(fd, p)          # crashed with AttributeError before the fix
+        finally:
+            os.close(fd)
+        self.assertEqual(os.stat(p).st_mode & 0o777, 0o644, "no POSIX mode repair is attempted off POSIX")
+
+    def test_a_non_regular_file_is_still_refused(self):
+        fd = os.open(self._d.name, os.O_RDONLY)
+        try:
+            with self.assertRaises(km.InsecureFile):
+                km._assert_private_fd(fd, self._d.name)
+        finally:
+            os.close(fd)
+
+    def test_fsync_dir_reports_success(self):
+        self.assertTrue(km._fsync_dir(os.path.join(self._d.name, "no-such-dir")))
+
+    def test_no_writable_directory_warning_off_posix(self):
+        d = os.path.join(self._d.name, "open")
+        os.mkdir(d)
+        os.chmod(d, 0o777)
+        buf = _capture_stderr(self)
+        km._makedirs_private(os.path.join(d, "sub"))
+        self.assertNotIn("writable by other local users", buf.getvalue())
+
+    def test_the_events_file_sink_writes_and_syncs(self):
+        # End to end: before the fix a new events file made sync() return False on every poll (the
+        # directory fsync), so the cursor never advanced and mail was re-delivered forever.
+        sink = km.RotatingFileSink(os.path.join(self._d.name, "argus.jsonl"), 0, 3)
+        self.addCleanup(sink.close)
+        self.assertTrue(sink.write('{"event": "new", "content": "caf\\u00e9 \\u2713"}\n'))
+        self.assertTrue(sink.sync())
+
+
+class Utf8StdoutTest(unittest.TestCase):
+    """A cp1252 stdout (a Windows console, a Git Bash pipe) must neither crash `--help` nor an event whose
+    message body is outside cp1252. Real subprocesses, because the defect is the interpreter's own encoding."""
+
+    HERE = os.path.dirname(os.path.abspath(__file__))
+
+    def _run(self, code):
+        env = dict(os.environ, PYTHONIOENCODING="cp1252")
+        env.pop("PYTHONUTF8", None)
+        return subprocess.run([sys.executable, "-c", code], cwd=self.HERE, env=env, capture_output=True, timeout=60)
+
+    def test_help_does_not_crash_on_cp1252(self):
+        r = self._run("import kijito_inbox_monitor as km, sys\ntry:\n    km.main(['--help'])\nexcept SystemExit as e:\n    sys.exit(e.code)")
+        self.assertEqual(r.returncode, 0, r.stderr.decode("utf-8", "replace")[-300:])
+
+    def test_an_event_outside_cp1252_is_delivered_as_utf8(self):
+        r = self._run("import kijito_inbox_monitor as km\nkm._utf8_stdout()\n"
+                      "em = km.Emitter('stdout-jsonl', None, 220, False)\n"
+                      "assert em.lifecycle('armed', persona='\\u6f22\\U0001F600') is True")
+        self.assertEqual(r.returncode, 0, r.stderr.decode("utf-8", "replace")[-300:])
+        self.assertIn("\u6f22\U0001F600", r.stdout.decode("utf-8"))