imbue-mngr-codex-usage 0.1.1__tar.gz

imbue_mngr_codex_usage-0.1.1/.gitignore

@@ -0,0 +1,364 @@
+# Byte-compiled / optimized / DLL files
+**/__pycache__/
+**/*.py[codz]
+**/*$py.class
+
+# macOS Finder metadata
+**/.DS_Store
+
+# C extensions
+**/*.so
+
+# Distribution / packaging
+**/.Python
+**/build/
+**/develop-eggs/
+**/dist/
+**/downloads/
+**/eggs/
+**/.eggs/
+**/lib/
+**/lib64/
+**/parts/
+**/sdist/
+**/var/
+**/wheels/
+**/share/python-wheels/
+**/*.egg-info/
+**/.installed.cfg
+**/*.egg
+**/MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+**/*.manifest
+**/*.spec
+
+# Installer logs
+**/pip-log.txt
+**/pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+**/htmlcov/
+**/.tox/
+**/.nox/
+**/.coverage
+**/.coverage.*
+**/.cache
+**/nosetests.xml
+**/coverage.xml
+**/*.cover
+**/*.py.cover
+**/.hypothesis/
+**/.pytest_cache/
+**/cover/
+
+# Translations
+**/*.mo
+**/*.pot
+
+# Django stuff:
+**/*.log
+**/local_settings.py
+**/db.sqlite3
+**/db.sqlite3-journal
+
+# Flask stuff:
+**/instance/
+**/.webassets-cache
+
+# Scrapy stuff:
+**/.scrapy
+
+# Sphinx documentation
+**/docs/_build/
+
+# PyBuilder
+**/.pybuilder/
+**/target/
+
+# Jupyter Notebook
+**/.ipynb_checkpoints
+
+# IPython
+**/profile_default/
+**/ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+**/.pdm-python
+**/.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+**/.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+**/__pypackages__/
+
+# Celery stuff
+**/celerybeat-schedule
+**/celerybeat.pid
+
+# SageMath parsed files
+**/*.sage.py
+
+# Environments
+**/.env
+**/.envrc
+**/.venv
+**/.venv-*
+**/env/
+**/venv/
+**/ENV/
+**/env.bak/
+**/venv.bak/
+
+# Spyder project settings
+**/.spyderproject
+**/.spyproject
+
+# Rope project settings
+**/.ropeproject
+
+# mkdocs documentation
+**/site
+
+# mypy
+**/.mypy_cache/
+**/.dmypy.json
+**/dmypy.json
+
+# Pyre type checker
+**/.pyre/
+
+# pytype static type analyzer
+**/.pytype/
+
+# Cython debug symbols
+**/cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+**/.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+**/.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer,
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+**/.ruff_cache/
+
+# PyPI configuration file
+**/.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+**/.cursorignore
+**/.cursorindexingignore
+
+# Marimo
+**/marimo/_static/
+**/marimo/_lsp/
+**/__marimo__/
+
+# task folders for local custom claude workflow (at any depth, incl. the
+# root-level `dev` project's `dev/_tasks/`, which `*/*/_tasks/` missed)
+**/_tasks/
+**/.sesskey
+
+# Node.js
+**/node_modules/
+
+# Frontend build artifacts
+**/frontend-dist/
+
+# Claude Code local settings (session-specific permissions)
+**/.claude/settings.local.json
+
+# Local Claude settings backup files
+**/.claude/*.bak
+
+# Claude worktress
+**/.claude/worktrees
+
+# Agent definitions deployed by mngr_subagent_proxy at session start
+**/.claude/agents/
+
+# Local mngr settings (not committed)
+**/.mngr/settings.local.toml
+
+# Local working / scratch markdown (not committed)
+**/*.local.md
+
+# Local working / scratch shell scripts (not committed)
+# (covers user notification scripts like scripts/notify_user.local.sh, too)
+**/*.local.sh
+
+# Local-only throwaway scripts (e.g. one-off test harnesses).
+**/scripts/*.local.sh
+
+# Local working / scratch Python + text (not committed; e.g. one-off validation
+# harnesses or probe scripts). Mirrors the *.local.md / *.local.sh convention.
+**/*.local.py
+**/*.local.txt
+
+# Test output files (slow tests, coverage summaries)
+**/.test_output/
+
+# TMR output directories (reports + test outputs)
+**/tmr_*/
+**/tmr-report/
+
+# Active session marker file (used to detect interrupted sessions)
+**/.claude/active
+
+# we stick the image build artifacts here
+**/.mngr/dev/build/
+**/.mngr/dev/secrets/
+
+# Offload caches and local files
+**/.offload/**
+**/test-results
+
+# Minds deploy-time build artifacts.
+# Ignore contents so we can un-ignore the committed `template/` subtree: git
+# won't descend into a fully-ignored directory, so negations must live below
+# the contents pattern rather than below the directory pattern.
+**/.minds/*
+# The template directory is committed: it defines the expected keys for each
+# <service>.sh file, with empty values. `scripts/push_modal_secrets.py` uses
+# it to check that per-env .sh files declare every template key.
+!/.minds/template/
+!/.minds/template/**
+# Vault ACL policies for the minds tiers. The HCL is non-sensitive and is
+# the source of truth for the policies pushed to Vault via
+# `vault policy write <name> .minds/policies/<name>.hcl`.
+!/.minds/policies/
+!/.minds/policies/**
+
+# Autofix session artifacts
+**/.autofix/
+**/.reviewer/logs/
+**/.reviewer/outputs/
+**/.reviewer/settings.local.json
+**/.reviewer/.stop_hook_consecutive_blocks
+**/.reviewer/conversation-issues.jsonl
+**/.reviews/
+
+# Stuck agent tracking (stop hook escape valve)
+**/.claude/blocked_stop_commits
+
+# Scheduled tasks lock file
+**/.claude/scheduled_tasks.lock
+
+# Demo recordings (asciinema .cast, .txt, and scripts)
+**/.demos/
+
+# for git worktrees from other repos
+**/.external_worktrees/
+
+# ignore coverage files generated within subprojects
+**/cov.xml
+
+# ignore demos
+**/recordings
+apps/minds_workspace_server/package-lock.json
+**/*.local.md
+
+# Generated by the _generate-dockerignore justfile recipe before each
+# test-offload* run. The recipe strips this self-reference so offload's
+# copy_untracked_files ships the generated file into the build context.
+/.dockerignore
+
+# Transient offload image-cache marker written by test-offload runs; not
+# checked in (unlike the committed .offload-*-cache-key files which pin CI
+# image versions).
+/.offload-image-cache
+
+# Generated by _generate-release-dockerfile from Dockerfile + .release.extras.
+/libs/mngr/imbue/mngr/resources/Dockerfile.release
+**/.reviewer/autofix/issues/
+.reviewer/logs/
+
+# Tailwind Play CDN JS for the minds desktop client. Fetched once via
+# `just minds-tailwind` (plain curl, no build) and shipped with the
+# distributable. Not checked in because it's a ~300KB blob we can always
+# re-fetch.
+/apps/minds/imbue/minds/desktop_client/static/tailwind.js
+
+# macOS Finder metadata
+**/.DS_Store
+**/.env.swp
+# Vim swap files for any file (`.foo.swp`, `.foo.swo`, etc.) -- generated
+# while a file is open in vim. Never checked in.
+**/.*.sw[a-p]
+
+# `minds env deploy` writes a recover-target file at the monorepo root
+# on failed deploys; `minds env recover` deletes it after rolling back.
+# Never checked in. Per-env naming
+# (``.minds-deploy-recover-target-<env-name>.json``) means each in-flight
+# deploy has its own file, so concurrent deploys against different envs
+# don't trip over each other.
+**/.minds-deploy-*.json
+# Per-env deploy lock files (kernel-level ``flock`` targets). Created
+# by ``hold_deploy_lock`` in ``apps/minds/imbue/minds/envs/recover.py``
+# and held for the entire duration of ``minds env deploy`` /
+# ``minds env recover`` so two concurrent invocations against the same
+# env serialize. The file itself is empty and cheap to leave around.
+**/.minds-deploy-lock-*.lock
+**/.antigravitycli/
+
+# Playwright MCP scratch artifacts (mock screenshots, page snapshots)
+**/.playwright-mcp/
+
+# tmr (task-runner) orchestration scratch report
+**/tmr-report/

imbue_mngr_codex_usage-0.1.1/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog - mngr_codex_usage
+
+A concise, human-friendly summary of changes for the `mngr_codex_usage` library. Entries are categorized using the [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) categories: Added, Changed, Deprecated, Removed, Fixed, Security.
+
+For the full, unedited changelog entries, see [UNABRIDGED_CHANGELOG.md](UNABRIDGED_CHANGELOG.md).
+
+## [Unreleased]
+
+## [v0.1.1] - 2026-06-16
+
+### Added
+
+- Added: New package `imbue-mngr-codex-usage` providing cost/usage tracking for Codex agents in `mngr usage`. Codex reports cumulative token usage (no dollar cost), so cost is estimated from the pricing table and aggregated session-cumulatively. The writer (`codex_usage.sh`) reads codex's rollout stream and emits one `cost_snapshot` per `token_count` item; `mngr_codex`'s background-tasks supervisor launches it when present. Codex's 5h/7d rate-limit windows (subscription mode) are mapped so Codex subscription agents get Claude-style windows. The writer tracks a byte-offset cursor (persisted under `plugin/codex/.usage_cursor`) so each poll processes only the new tail of the rollout.

imbue_mngr_codex_usage-0.1.1/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: imbue-mngr-codex-usage
+Version: 0.1.1
+Summary: Codex usage data provider for `mngr usage` (rollout token_count -> cost_snapshot writer + reader)
+Requires-Python: >=3.12
+Requires-Dist: imbue-mngr-codex==0.1.3
+Requires-Dist: imbue-mngr-usage==0.1.5
+Requires-Dist: imbue-mngr==0.2.16
+Description-Content-Type: text/markdown
+
+# imbue-mngr-codex-usage
+
+Codex data provider for `mngr usage`. Codex exposes no statusline or in-process
+plugin, but mngr already tails its rollout JSONL into a raw transcript via
+mngr_codex's background-tasks supervisor. This package adds:
+
+- **The writer** (`codex_usage.sh`): installed into the agent's `commands/` dir,
+  where mngr_codex's `codex_background_tasks.sh` launches it **iff present**. It
+  reads the raw rollout stream and emits one `cost_snapshot` per `token_count`
+  item to `events/codex/usage/events.jsonl`.
+- **The reader**: an `aggregate_usage_source` hookimpl claiming the `codex`
+  source, aggregated **session-cumulatively** (each `token_count` carries the
+  session's cumulative total, so the freshest per session wins).
+
+## What gets captured
+
+Codex reports cumulative token usage (`info.total_token_usage`) but **no dollar
+cost**, so cost is left null and the reader **estimates** it from tokens via the
+pricing table (provenance `ESTIMATED`). `input_tokens` includes cached, so the
+writer emits `input = input_tokens - cached_input_tokens` and
+`cache_read = cached_input_tokens` (OpenAI has no cache-write surcharge). The
+model is `openai/<model>` from the rollout's `turn_context`.
+
+In ChatGPT-plan (subscription) mode, `token_count` also carries 5h/7d rate-limit
+windows, which the writer maps onto the window schema -- so Codex subscription
+agents get Claude-style windows, and the session is classified `SUBSCRIPTION`
+(imputed). Without rate limits it's `API_KEY` (real spend).

imbue_mngr_codex_usage-0.1.1/README.md

@@ -0,0 +1,27 @@
+# imbue-mngr-codex-usage
+
+Codex data provider for `mngr usage`. Codex exposes no statusline or in-process
+plugin, but mngr already tails its rollout JSONL into a raw transcript via
+mngr_codex's background-tasks supervisor. This package adds:
+
+- **The writer** (`codex_usage.sh`): installed into the agent's `commands/` dir,
+  where mngr_codex's `codex_background_tasks.sh` launches it **iff present**. It
+  reads the raw rollout stream and emits one `cost_snapshot` per `token_count`
+  item to `events/codex/usage/events.jsonl`.
+- **The reader**: an `aggregate_usage_source` hookimpl claiming the `codex`
+  source, aggregated **session-cumulatively** (each `token_count` carries the
+  session's cumulative total, so the freshest per session wins).
+
+## What gets captured
+
+Codex reports cumulative token usage (`info.total_token_usage`) but **no dollar
+cost**, so cost is left null and the reader **estimates** it from tokens via the
+pricing table (provenance `ESTIMATED`). `input_tokens` includes cached, so the
+writer emits `input = input_tokens - cached_input_tokens` and
+`cache_read = cached_input_tokens` (OpenAI has no cache-write surcharge). The
+model is `openai/<model>` from the rollout's `turn_context`.
+
+In ChatGPT-plan (subscription) mode, `token_count` also carries 5h/7d rate-limit
+windows, which the writer maps onto the window schema -- so Codex subscription
+agents get Claude-style windows, and the session is classified `SUBSCRIPTION`
+(imputed). Without rate limits it's `API_KEY` (real spend).

imbue_mngr_codex_usage-0.1.1/UNABRIDGED_CHANGELOG.md

@@ -0,0 +1,13 @@
+# Unabridged Changelog - mngr_codex_usage
+
+Full, unedited changelog entries consolidated nightly from individual files in `libs/mngr_codex_usage/changelog/`.
+
+For a concise summary, see [CHANGELOG.md](CHANGELOG.md).
+
+## 2026-06-16
+
+New package `imbue-mngr-codex-usage`: cost/usage tracking for Codex agents in `mngr usage`. Codex reports cumulative token usage (no dollar cost), so cost is estimated from the pricing table and aggregated session-cumulatively. The writer (`codex_usage.sh`) reads codex's rollout stream and emits one `cost_snapshot` per `token_count` item; mngr_codex's background-tasks supervisor launches it when present. It also maps codex's 5h/7d rate-limit windows (subscription mode), so Codex subscription agents get Claude-style windows.
+
+The writer tracks a byte-offset cursor (persisted under `plugin/codex/.usage_cursor`) so each poll processes only the new tail of the rollout (O(new bytes) per tick), important for long Codex sessions. Re-emission after a crash is harmless because the session-cumulative reader keeps the freshest reading per session.
+
+The writer delegates event emission to a standalone `codex_usage_emit.py` (installed alongside `codex_usage.sh` and invoked by it), keeping that logic type-checked, linted, and unit-tested directly. Malformed rollout lines and unreadable cursor state are logged at warning level.

imbue_mngr_codex_usage-0.1.1/conftest.py

@@ -0,0 +1,7 @@
+"""Project-level conftest for mngr_codex_usage."""
+
+from imbue.imbue_common.conftest_hooks import register_conftest_hooks
+from imbue.mngr.utils.logging import suppress_warnings
+
+suppress_warnings()
+register_conftest_hooks(globals())

imbue_mngr_codex_usage-0.1.1/imbue/mngr_codex_usage/aggregate_usage_source_test.py

@@ -0,0 +1,114 @@
+"""Unit tests for the Codex ``aggregate_usage_source`` reader hookimpl."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+
+from imbue.mngr_codex_usage.plugin import aggregate_usage_source
+from imbue.mngr_usage.api import parse_usage_events
+from imbue.mngr_usage.data_types import CostMode
+from imbue.mngr_usage.data_types import CostProvenance
+
+_NOW = 2_800_000_000
+_SINCE = 10**12
+
+
+def _codex_event(
+    session_id: str, event_id: str, second: int, tokens: dict[str, Any], rate_limits: dict[str, Any] | None = None
+) -> dict[str, Any]:
+    event: dict[str, Any] = {
+        "timestamp": f"2056-01-01T00:00:{second:02d}.000000000Z",
+        "session_id": session_id,
+        "event_id": event_id,
+        "cost": None,
+        "tokens": tokens,
+        "model": "openai/gpt-5.2-codex",
+        "cost_mode": "SUBSCRIPTION" if rate_limits is not None else "API_KEY",
+    }
+    if rate_limits is not None:
+        event["rate_limits"] = rate_limits
+    return event
+
+
+def test_codex_hookimpl_takes_freshest_cumulative_and_estimates_cost() -> None:
+    # token_count is cumulative; the freshest reading is the session total, and
+    # cost is estimated from tokens (Codex reports no dollar cost).
+    snapshot = aggregate_usage_source(
+        source_name="codex",
+        agents_events={
+            "agent-1": parse_usage_events(
+                [
+                    _codex_event(
+                        "s1", "line-1-usage", 1, {"input": 100, "output": 0, "cache_read": 0, "cache_creation": None}
+                    ),
+                    _codex_event(
+                        "s1",
+                        "line-2-usage",
+                        2,
+                        {"input": 1_000_000, "output": 0, "cache_read": 0, "cache_creation": None},
+                    ),
+                ],
+                "codex",
+            )
+        },
+        since_seconds=_SINCE,
+        now=_NOW,
+    )
+    assert snapshot is not None
+    record = snapshot.sessions[0]
+    # Freshest = 1,000,000 input * gpt-5.2-codex input price 1.75e-6 = 1.75.
+    assert record.cost.total_cost_usd == pytest.approx(1.75)
+    assert record.cost_provenance == CostProvenance.ESTIMATED
+    assert record.cost_mode == CostMode.API_KEY
+
+
+def test_codex_hookimpl_surfaces_windows_and_subscription_mode() -> None:
+    snapshot = aggregate_usage_source(
+        source_name="codex",
+        agents_events={
+            "agent-1": parse_usage_events(
+                [
+                    _codex_event(
+                        "s1",
+                        "line-1-usage",
+                        1,
+                        {"input": 100, "output": 50, "cache_read": 200, "cache_creation": None},
+                        rate_limits={
+                            "five_hour": {
+                                "used_percentage": 23.0,
+                                "resets_at": 9_999_999_999,
+                                "window_seconds": 18000,
+                            },
+                            "seven_day": {
+                                "used_percentage": 27.0,
+                                "resets_at": 9_999_999_999,
+                                "window_seconds": 604800,
+                            },
+                        },
+                    )
+                ],
+                "codex",
+            )
+        },
+        since_seconds=_SINCE,
+        now=_NOW,
+    )
+    assert snapshot is not None
+    assert snapshot.sessions[0].cost_mode == CostMode.SUBSCRIPTION
+    assert "five_hour" in snapshot.windows and "seven_day" in snapshot.windows
+
+
+def test_codex_hookimpl_declines_non_codex_sources() -> None:
+    snapshot = aggregate_usage_source(
+        source_name="opencode",
+        agents_events={
+            "agent-1": parse_usage_events(
+                [_codex_event("s1", "line-1-usage", 1, {"input": 1, "output": 1})], "opencode"
+            )
+        },
+        since_seconds=_SINCE,
+        now=_NOW,
+    )
+    assert snapshot is None

imbue_mngr_codex_usage-0.1.1/imbue/mngr_codex_usage/conftest.py

@@ -0,0 +1,3 @@
+from imbue.mngr.utils.plugin_testing import register_plugin_test_fixtures
+
+register_plugin_test_fixtures(globals())

imbue_mngr_codex_usage-0.1.1/imbue/mngr_codex_usage/cross_boundary_test.py

@@ -0,0 +1,37 @@
+"""Guard the writer-script <-> reader and supervisor seams.
+
+The Codex usage writer (`codex_usage.sh`, this package) emits under a source the
+reader here claims, and mngr_codex's background-tasks supervisor launches it by
+filename. Both agreements are hand-synced string literals (across the shell <->
+Python boundary, and across packages), so a rename silently disables usage
+tracking. Pin both invariants.
+"""
+
+from __future__ import annotations
+
+import importlib.resources
+
+from imbue.mngr_codex.codex_config import BACKGROUND_TASKS_SCRIPT_NAME
+from imbue.mngr_codex.plugin import _load_codex_resource_script
+from imbue.mngr_codex_usage import resources as _resources
+from imbue.mngr_codex_usage.plugin import _CODEX_USAGE_SOURCE_NAME
+from imbue.mngr_codex_usage.plugin import _USAGE_EMIT_SCRIPT
+from imbue.mngr_codex_usage.plugin import _USAGE_WRITER_SCRIPT
+
+
+def test_writer_script_emits_the_source_the_reader_claims() -> None:
+    # The emitted source literal lives in the python emitter the writer invokes.
+    emit_py = importlib.resources.files(_resources).joinpath(_USAGE_EMIT_SCRIPT).read_text()
+    assert f'"{_CODEX_USAGE_SOURCE_NAME}/usage"' in emit_py
+
+
+def test_writer_script_invokes_the_emitter_it_ships_with() -> None:
+    writer_sh = importlib.resources.files(_resources).joinpath(_USAGE_WRITER_SCRIPT).read_text()
+    assert _USAGE_EMIT_SCRIPT in writer_sh
+
+
+def test_supervisor_launches_the_writer_by_the_name_this_package_installs() -> None:
+    supervisor_sh = _load_codex_resource_script(BACKGROUND_TASKS_SCRIPT_NAME)
+    # mngr_codex's supervisor must reference the exact script filename this
+    # package installs into commands/, or the writer never launches.
+    assert _USAGE_WRITER_SCRIPT in supervisor_sh