imbue-mngr-pi-coding-usage 0.1.0__tar.gz

imbue_mngr_pi_coding_usage-0.1.0/.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_pi_coding_usage-0.1.0/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog - mngr_pi_coding_usage
+
+A concise, human-friendly summary of changes for the `mngr_pi_coding_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.0] - 2026-06-16
+
+### Added
+
+- Added: New package `imbue-mngr-pi-coding-usage` providing cost/usage tracking for pi agents in `mngr usage`. pi reports per-message cost client-side, so it's REPORTED (not estimated) and aggregated session-incrementally. The per-message writer lives in `mngr_pi_coding`'s lifecycle extension (pi loads a single explicit extension); this package owns the reader (an `aggregate_usage_source` hookimpl claiming the `pi-coding` source) and provisions a `pi_emit_usage` gate marker so the extension only emits usage events when this package is installed.

imbue_mngr_pi_coding_usage-0.1.0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: imbue-mngr-pi-coding-usage
+Version: 0.1.0
+Summary: pi usage data provider for `mngr usage` (reader + writer gate; the per-message writer lives in mngr_pi_coding's lifecycle extension)
+Requires-Python: >=3.12
+Requires-Dist: imbue-mngr-pi-coding==0.1.13
+Requires-Dist: imbue-mngr-usage==0.1.5
+Requires-Dist: imbue-mngr==0.2.16
+Description-Content-Type: text/markdown
+
+# imbue-mngr-pi-coding-usage
+
+pi data provider for `mngr usage`. pi loads a single explicit extension
+(mngr_pi_coding's lifecycle extension, via `pi -e`), so the per-message usage
+**writer** lives there -- it already holds each assistant message's cost and
+tokens. This package owns the two usage-specific pieces:
+
+- **The reader**: an `aggregate_usage_source` hookimpl claiming the `pi-coding`
+  source, aggregated session-incrementally (pi reports cost per message, summed
+  per session).
+- **The writer gate**: `on_after_provisioning` drops a `pi_emit_usage` marker in
+  each pi agent's state dir. The lifecycle extension only emits usage events when
+  that marker is present -- so the events are written exactly when their reader
+  (this package) is installed.
+
+## What gets captured
+
+pi computes per-message cost client-side (`usage.cost.total`), so cost is
+**REPORTED** (no estimation). Each assistant `message_end` appends one
+`cost_snapshot` to `events/pi-coding/usage/events.jsonl` with the reported cost,
+tokens (`input`/`output`/`cacheRead`/`cacheWrite`), the provider-qualified model
+(`<provider>/<model>`), and the session id (the pi session file's basename).
+`cost_mode` is `API_KEY` (pi bills a real provider key).
+
+## Why the writer is in the harness extension
+
+Unlike Claude (statusline shim) or OpenCode (auto-loaded `plugin/*.ts`), pi loads
+exactly one explicit extension owned by mngr_pi_coding. A standalone writer would
+require a harness change either way, so the writer is folded into the lifecycle
+extension (which already extracts the message usage), and this package stays the
+reader + gate.

imbue_mngr_pi_coding_usage-0.1.0/README.md

@@ -0,0 +1,31 @@
+# imbue-mngr-pi-coding-usage
+
+pi data provider for `mngr usage`. pi loads a single explicit extension
+(mngr_pi_coding's lifecycle extension, via `pi -e`), so the per-message usage
+**writer** lives there -- it already holds each assistant message's cost and
+tokens. This package owns the two usage-specific pieces:
+
+- **The reader**: an `aggregate_usage_source` hookimpl claiming the `pi-coding`
+  source, aggregated session-incrementally (pi reports cost per message, summed
+  per session).
+- **The writer gate**: `on_after_provisioning` drops a `pi_emit_usage` marker in
+  each pi agent's state dir. The lifecycle extension only emits usage events when
+  that marker is present -- so the events are written exactly when their reader
+  (this package) is installed.
+
+## What gets captured
+
+pi computes per-message cost client-side (`usage.cost.total`), so cost is
+**REPORTED** (no estimation). Each assistant `message_end` appends one
+`cost_snapshot` to `events/pi-coding/usage/events.jsonl` with the reported cost,
+tokens (`input`/`output`/`cacheRead`/`cacheWrite`), the provider-qualified model
+(`<provider>/<model>`), and the session id (the pi session file's basename).
+`cost_mode` is `API_KEY` (pi bills a real provider key).
+
+## Why the writer is in the harness extension
+
+Unlike Claude (statusline shim) or OpenCode (auto-loaded `plugin/*.ts`), pi loads
+exactly one explicit extension owned by mngr_pi_coding. A standalone writer would
+require a harness change either way, so the writer is folded into the lifecycle
+extension (which already extracts the message usage), and this package stays the
+reader + gate.

imbue_mngr_pi_coding_usage-0.1.0/UNABRIDGED_CHANGELOG.md

@@ -0,0 +1,13 @@
+# Unabridged Changelog - mngr_pi_coding_usage
+
+Full, unedited changelog entries consolidated nightly from individual files in `libs/mngr_pi_coding_usage/changelog/`.
+
+For a concise summary, see [CHANGELOG.md](CHANGELOG.md).
+
+## 2026-06-16
+
+Corrected the package version back to 0.1.0 (it had been bumped to 0.1.1, but that version was never actually released).
+
+## 2026-06-16
+
+New package `imbue-mngr-pi-coding-usage`: cost/usage tracking for pi agents in `mngr usage`. pi reports per-message cost client-side, so it's REPORTED (not estimated) and aggregated session-incrementally. Because pi loads a single explicit extension, the per-message writer lives in mngr_pi_coding's lifecycle extension; this package owns the reader (an `aggregate_usage_source` hookimpl claiming the `pi-coding` source) and provisions a `pi_emit_usage` gate marker so the extension only emits usage events when this package (their reader) is installed.

imbue_mngr_pi_coding_usage-0.1.0/conftest.py

@@ -0,0 +1,7 @@
+"""Project-level conftest for mngr_pi_coding_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_pi_coding_usage-0.1.0/imbue/mngr_pi_coding_usage/aggregate_usage_source_test.py

@@ -0,0 +1,56 @@
+"""Unit tests for the pi ``aggregate_usage_source`` reader hookimpl."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from imbue.mngr_pi_coding_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 _message_event(session_id: str, event_id: str, second: int, total_cost_usd: float) -> dict[str, Any]:
+    return {
+        "timestamp": f"2056-01-01T00:00:{second:02d}.000000000Z",
+        "session_id": session_id,
+        "event_id": event_id,
+        "cost": {"total_cost_usd": total_cost_usd},
+        "model": "anthropic/claude-opus-4-8",
+    }
+
+
+def test_pi_hookimpl_sums_per_message_as_reported() -> None:
+    snapshot = aggregate_usage_source(
+        source_name="pi-coding",
+        agents_events={
+            "agent-1": parse_usage_events(
+                [
+                    _message_event("s1", "evt-pi-usage-0", 1, 0.01),
+                    _message_event("s1", "evt-pi-usage-1", 2, 0.02),
+                ],
+                "pi-coding",
+            )
+        },
+        since_seconds=_SINCE,
+        now=_NOW,
+    )
+    assert snapshot is not None
+    assert snapshot.source_name == "pi-coding"
+    record = snapshot.sessions[0]
+    assert record.cost.total_cost_usd == 0.03
+    assert record.cost_provenance == CostProvenance.REPORTED
+    assert record.cost_mode == CostMode.API_KEY
+
+
+def test_pi_hookimpl_declines_non_pi_sources() -> None:
+    snapshot = aggregate_usage_source(
+        source_name="opencode",
+        agents_events={"agent-1": parse_usage_events([_message_event("s1", "evt-pi-usage-0", 1, 0.01)], "opencode")},
+        since_seconds=_SINCE,
+        now=_NOW,
+    )
+    assert snapshot is None

imbue_mngr_pi_coding_usage-0.1.0/imbue/mngr_pi_coding_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_pi_coding_usage-0.1.0/imbue/mngr_pi_coding_usage/cross_boundary_test.py

@@ -0,0 +1,23 @@
+"""Guard the cross-package writer <-> reader seam.
+
+pi's usage *writer* lives in mngr_pi_coding's lifecycle extension (pi loads one
+explicit extension, owned by the harness), while the reader + gate live here.
+The two packages agree only by hand-synced string literals across both a
+language *and* a package boundary -- the gate filename and the source name. A
+rename on either side silently disables usage tracking, so pin the invariant.
+"""
+
+from __future__ import annotations
+
+from imbue.mngr_pi_coding.plugin import _LIFECYCLE_EXTENSION_NAME
+from imbue.mngr_pi_coding.plugin import _load_resource
+from imbue.mngr_pi_coding_usage.plugin import _PI_USAGE_SOURCE_NAME
+from imbue.mngr_pi_coding_usage.plugin import _USAGE_GATE_FILENAME
+
+
+def test_lifecycle_extension_uses_the_gate_and_source_this_package_owns() -> None:
+    lifecycle_ts = _load_resource(_LIFECYCLE_EXTENSION_NAME)
+    # The extension only emits usage when it sees this package's gate marker...
+    assert f'"{_USAGE_GATE_FILENAME}"' in lifecycle_ts
+    # ...and emits under the source the reader here claims (`<name>/usage`).
+    assert f'"{_PI_USAGE_SOURCE_NAME}/usage"' in lifecycle_ts

imbue_mngr_pi_coding_usage-0.1.0/imbue/mngr_pi_coding_usage/plugin.py

@@ -0,0 +1,67 @@
+"""pi usage data provider for `mngr usage` (reader + writer gate).
+
+pi loads exactly one explicit extension -- mngr_pi_coding's lifecycle extension,
+launched with ``pi -e`` -- so the usage *writer* lives there (it already holds
+each assistant message's cost + tokens). This package owns the two pieces that
+are genuinely usage-specific:
+
+1. A gate marker, provisioned per pi agent, that tells the lifecycle extension to
+   emit usage events. Without it the writer stays inert -- so usage events are
+   only written when *this* package (which ships their reader) is installed.
+   Emitting them unread would let ``mngr usage`` fall back to the wrong
+   (process-cumulative) strategy and undercount pi's per-message events.
+2. The reader: an ``aggregate_usage_source`` hookimpl claiming the ``pi-coding``
+   source, aggregated session-incrementally (pi reports cost per message).
+"""
+
+from __future__ import annotations
+
+from imbue.mngr import hookimpl
+from imbue.mngr.config.data_types import MngrContext
+from imbue.mngr.hosts.host import get_agent_state_dir_path
+from imbue.mngr.interfaces.agent import AgentInterface
+from imbue.mngr.interfaces.host import OnlineHostInterface
+from imbue.mngr_pi_coding.plugin import PiCodingAgent
+from imbue.mngr_usage.api import aggregate_session_incremental
+from imbue.mngr_usage.data_types import UsageEvent
+from imbue.mngr_usage.data_types import UsageSnapshot
+
+# Gate marker the lifecycle extension checks (existsSync) to decide whether to
+# emit usage events. Kept in sync with mngr_pi_lifecycle.ts (literal "pi_emit_usage").
+_USAGE_GATE_FILENAME = "pi_emit_usage"
+
+# Source the pi writer emits under ($STATE_DIR/events/pi-coding/usage/...); the
+# reader strips "/usage". A fixed harness id (not the agent subtype), so usage
+# from any pi subtype lumps under one source. Kept in sync with mngr_pi_lifecycle.ts.
+_PI_USAGE_SOURCE_NAME = "pi-coding"
+
+
+@hookimpl
+def on_after_provisioning(agent: AgentInterface, host: OnlineHostInterface, mngr_ctx: MngrContext) -> None:
+    """Install the usage gate marker for pi agents so the lifecycle extension emits usage events.
+
+    Skips non-pi agents. Written to the agent state dir, which the extension
+    reads (``$MNGR_AGENT_STATE_DIR/pi_emit_usage``) once at startup.
+    """
+    if not isinstance(agent, PiCodingAgent):
+        return
+    state_dir = get_agent_state_dir_path(host.host_dir, agent.id)
+    host.write_file(state_dir / _USAGE_GATE_FILENAME, b"1")
+
+
+@hookimpl
+def aggregate_usage_source(
+    source_name: str,
+    agents_events: dict[str, list[UsageEvent]],
+    since_seconds: int,
+    now: int,
+) -> UsageSnapshot | None:
+    """Aggregate the pi usage source; decline every other source.
+
+    pi reports each assistant message's own cost/tokens (not a cumulative total),
+    so this is the session-incremental strategy. Returning None for non-pi sources
+    lets the firstresult hook fall through.
+    """
+    if source_name != _PI_USAGE_SOURCE_NAME:
+        return None
+    return aggregate_session_incremental(source_name, agents_events, since_seconds=since_seconds, now=now)

imbue_mngr_pi_coding_usage-0.1.0/imbue/mngr_pi_coding_usage/plugin_test.py

@@ -0,0 +1,53 @@
+"""Unit tests for mngr_pi_coding_usage.plugin (gate provisioning + hookimpl filter)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from imbue.mngr.agents.base_agent import BaseAgent
+from imbue.mngr.cli.testing import create_test_agent
+from imbue.mngr.config.data_types import MngrContext
+from imbue.mngr.hosts.host import get_agent_state_dir_path
+from imbue.mngr.primitives import AgentId
+from imbue.mngr.providers.local.instance import LocalProviderInstance
+from imbue.mngr_pi_coding.plugin import PiCodingAgent
+from imbue.mngr_pi_coding.plugin import PiCodingAgentConfig
+from imbue.mngr_pi_coding_usage.plugin import _USAGE_GATE_FILENAME
+from imbue.mngr_pi_coding_usage.plugin import on_after_provisioning
+
+
+def _gate_path(host_dir: Path, agent_id: AgentId) -> Path:
+    return get_agent_state_dir_path(host_dir, agent_id) / _USAGE_GATE_FILENAME
+
+
+def test_provisions_usage_gate_for_pi_agent(
+    local_provider: LocalProviderInstance, temp_mngr_ctx: MngrContext, tmp_path: Path
+) -> None:
+    work_dir = tmp_path / "work"
+    work_dir.mkdir()
+    agent = create_test_agent(
+        local_provider,
+        work_dir,
+        agent_config=PiCodingAgentConfig(),
+        agent_type=None,
+        extra_data=None,
+        agent_class=PiCodingAgent,
+    )
+    on_after_provisioning(agent=agent, host=agent.host, mngr_ctx=temp_mngr_ctx)
+    gate = _gate_path(agent.host.host_dir, agent.id)
+    assert gate.read_text() == "1"
+
+
+def test_skips_non_pi_agent(local_provider: LocalProviderInstance, temp_mngr_ctx: MngrContext, tmp_path: Path) -> None:
+    work_dir = tmp_path / "work"
+    work_dir.mkdir()
+    agent = create_test_agent(
+        local_provider,
+        work_dir,
+        agent_config=None,
+        agent_type=None,
+        extra_data=None,
+        agent_class=BaseAgent,
+    )
+    on_after_provisioning(agent=agent, host=agent.host, mngr_ctx=temp_mngr_ctx)
+    assert not _gate_path(agent.host.host_dir, agent.id).exists()

imbue_mngr_pi_coding_usage-0.1.0/imbue/mngr_pi_coding_usage/test_ratchets.py

@@ -0,0 +1,278 @@
+from pathlib import Path
+
+import pytest
+from inline_snapshot import snapshot
+
+from imbue.imbue_common.ratchet_testing import standard_ratchet_checks as rc
+
+_DIR = Path(__file__).parent.parent.parent
+
+pytestmark = pytest.mark.xdist_group(name="ratchets")
+
+
+# --- Code safety ---
+
+
+def test_prevent_todos() -> None:
+    rc.check_todos(_DIR, snapshot(0))
+
+
+def test_prevent_exec() -> None:
+    rc.check_exec(_DIR, snapshot(0))
+
+
+def test_prevent_eval() -> None:
+    rc.check_eval(_DIR, snapshot(0))
+
+
+def test_prevent_while_true() -> None:
+    rc.check_while_true(_DIR, snapshot(0))
+
+
+def test_prevent_time_sleep() -> None:
+    rc.check_time_sleep(_DIR, snapshot(0))
+
+
+def test_prevent_global_keyword() -> None:
+    rc.check_global_keyword(_DIR, snapshot(0))
+
+
+def test_prevent_bare_print() -> None:
+    rc.check_bare_print(_DIR, snapshot(0))
+
+
+# --- Exception handling ---
+
+
+def test_prevent_bare_except() -> None:
+    rc.check_bare_except(_DIR, snapshot(0))
+
+
+def test_prevent_broad_exception_catch() -> None:
+    rc.check_broad_exception_catch(_DIR, snapshot(0))
+
+
+def test_prevent_base_exception_catch() -> None:
+    rc.check_base_exception_catch(_DIR, snapshot(0))
+
+
+def test_prevent_builtin_exception_raises() -> None:
+    rc.check_builtin_exception_raises(_DIR, snapshot(0))
+
+
+def test_prevent_silent_decode_error_catches() -> None:
+    rc.check_silent_decode_error_catches(_DIR, snapshot(0))
+
+
+# --- Import style ---
+
+
+def test_prevent_inline_imports() -> None:
+    rc.check_inline_imports(_DIR, snapshot(0))
+
+
+def test_prevent_relative_imports() -> None:
+    rc.check_relative_imports(_DIR, snapshot(0))
+
+
+def test_prevent_import_datetime() -> None:
+    rc.check_import_datetime(_DIR, snapshot(0))
+
+
+def test_prevent_importlib_import_module() -> None:
+    rc.check_importlib_import_module(_DIR, snapshot(0))
+
+
+def test_prevent_getattr() -> None:
+    rc.check_getattr(_DIR, snapshot(0))
+
+
+def test_prevent_setattr() -> None:
+    rc.check_setattr(_DIR, snapshot(0))
+
+
+# --- Banned libraries and patterns ---
+
+
+def test_prevent_asyncio_import() -> None:
+    rc.check_asyncio_import(_DIR, snapshot(0))
+
+
+def test_prevent_pandas_import() -> None:
+    rc.check_pandas_import(_DIR, snapshot(0))
+
+
+def test_prevent_dataclasses_import() -> None:
+    rc.check_dataclasses_import(_DIR, snapshot(0))
+
+
+def test_prevent_namedtuple() -> None:
+    rc.check_namedtuple(_DIR, snapshot(0))
+
+
+def test_prevent_yaml_usage() -> None:
+    rc.check_yaml_usage(_DIR, snapshot(0))
+
+
+def test_prevent_functools_partial() -> None:
+    rc.check_functools_partial(_DIR, snapshot(0))
+
+
+def test_prevent_exit_stack() -> None:
+    rc.check_exit_stack(_DIR, snapshot(0))
+
+
+# --- Hardcoded paths ---
+
+
+def test_prevent_hardcoded_claude_dir() -> None:
+    rc.check_hardcoded_claude_dir(_DIR, snapshot(0))
+
+
+def test_prevent_hardcoded_guarded_binary() -> None:
+    rc.check_hardcoded_guarded_binary(_DIR, snapshot(0))
+
+
+# --- Naming conventions ---
+
+
+def test_prevent_num_prefix() -> None:
+    rc.check_num_prefix(_DIR, snapshot(0))
+
+
+# --- Documentation ---
+
+
+def test_prevent_trailing_comments() -> None:
+    rc.check_trailing_comments(_DIR, snapshot(0))
+
+
+def test_prevent_init_docstrings() -> None:
+    rc.check_init_docstrings(_DIR, snapshot(0))
+
+
+@pytest.mark.timeout(10)
+def test_prevent_args_in_docstrings() -> None:
+    rc.check_args_in_docstrings(_DIR, snapshot(0))
+
+
+@pytest.mark.timeout(10)
+def test_prevent_returns_in_docstrings() -> None:
+    rc.check_returns_in_docstrings(_DIR, snapshot(0))
+
+
+# --- Type safety ---
+
+
+def test_prevent_literal_with_multiple_options() -> None:
+    rc.check_literal_with_multiple_options(_DIR, snapshot(0))
+
+
+def test_prevent_bare_generic_types() -> None:
+    rc.check_bare_generic_types(_DIR, snapshot(0))
+
+
+def test_prevent_typing_builtin_imports() -> None:
+    rc.check_typing_builtin_imports(_DIR, snapshot(0))
+
+
+def test_prevent_short_uuid_ids() -> None:
+    rc.check_short_uuid_ids(_DIR, snapshot(0))
+
+
+# --- Pydantic / models ---
+
+
+def test_prevent_model_copy() -> None:
+    rc.check_model_copy(_DIR, snapshot(0))
+
+
+# --- Logging ---
+
+
+def test_prevent_fstring_logging() -> None:
+    rc.check_fstring_logging(_DIR, snapshot(0))
+
+
+def test_prevent_click_echo() -> None:
+    rc.check_click_echo(_DIR, snapshot(0))
+
+
+def test_prevent_logger_exception() -> None:
+    rc.check_logger_exception(_DIR, snapshot(0))
+
+
+# --- Testing conventions ---
+
+
+def test_prevent_unittest_mock_imports() -> None:
+    rc.check_unittest_mock_imports(_DIR, snapshot(0))
+
+
+def test_prevent_monkeypatch_setattr() -> None:
+    rc.check_monkeypatch_setattr(_DIR, snapshot(0))
+
+
+def test_prevent_test_container_classes() -> None:
+    rc.check_test_container_classes(_DIR, snapshot(0))
+
+
+def test_prevent_pytest_mark_integration() -> None:
+    rc.check_pytest_mark_integration(_DIR, snapshot(0))
+
+
+# --- Process management ---
+
+
+def test_prevent_os_fork() -> None:
+    rc.check_os_fork(_DIR, snapshot(0))
+
+
+def test_prevent_bare_urwid_tty_signal_keys() -> None:
+    rc.check_bare_urwid_tty_signal_keys(_DIR, snapshot(0))
+
+
+def test_prevent_direct_subprocess() -> None:
+    rc.check_direct_subprocess(_DIR, snapshot(0))
+
+
+def test_prevent_bare_tmux_targets() -> None:
+    rc.check_bare_tmux_targets(_DIR, snapshot(0))
+
+
+# --- AST-based ratchets ---
+
+
+def test_prevent_if_elif_without_else() -> None:
+    rc.check_if_elif_without_else(_DIR, snapshot(0))
+
+
+def test_prevent_inline_functions() -> None:
+    rc.check_inline_functions(_DIR, snapshot(0))
+
+
+def test_prevent_underscore_imports() -> None:
+    rc.check_underscore_imports(_DIR, snapshot(0))
+
+
+def test_prevent_init_methods_in_non_exception_classes() -> None:
+    rc.check_init_methods_in_non_exception_classes(_DIR, snapshot(0))
+
+
+def test_prevent_cast_usage() -> None:
+    rc.check_cast_usage(_DIR, snapshot(0))
+
+
+def test_prevent_assert_isinstance() -> None:
+    rc.check_assert_isinstance(_DIR, snapshot(0))
+
+
+def test_prevent_per_file_host_upload() -> None:
+    rc.check_per_file_host_upload(_DIR, snapshot(0))
+
+
+# --- Project-level checks ---
+
+
+def test_prevent_code_in_init_files() -> None:
+    rc.check_code_in_init_files(_DIR, snapshot(0))

imbue_mngr_pi_coding_usage-0.1.0/pyproject.toml

@@ -0,0 +1,68 @@
+[project]
+name = "imbue-mngr-pi-coding-usage"
+version = "0.1.0"
+description = "pi usage data provider for `mngr usage` (reader + writer gate; the per-message writer lives in mngr_pi_coding's lifecycle extension)"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "imbue-mngr==0.2.16",
+    "imbue-mngr-pi-coding==0.1.13",
+    "imbue-mngr-usage==0.1.5",
+]
+
+[project.entry-points.mngr]
+pi_coding_usage = "imbue.mngr_pi_coding_usage.plugin"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["imbue"]
+exclude = ["*_test.py", "test_*.py", "**/conftest.py", "**/testing.py"]
+
+[tool.uv.sources]
+imbue-mngr = { workspace = true }
+imbue-mngr-pi-coding = { workspace = true }
+imbue-mngr-usage = { workspace = true }
+
+[tool.pytest.ini_options]
+timeout_func_only = true
+junit_family = "xunit1"
+testpaths = ["."]
+addopts = [
+  "--cov=imbue.mngr_pi_coding_usage",
+  "--cov-report=term-missing",
+  "--cov-report=xml",
+  "--durations=20",
+  "--timeout=10",
+  "--timeout-method=signal",
+  "--slow-tests-to-file",
+  "--coverage-to-file",
+]
+
+[tool.coverage.run]
+parallel = true
+concurrency = ["multiprocessing", "thread"]
+omit = [
+  "*_test.py",
+  "test_*.py",
+  "*/tests/*",
+  "*/conftest.py",
+  "*/utils/testing.py",
+]
+
+[tool.inline-snapshot]
+default-flags=["report"]
+default-flags-tui=["report"]
+default-flags-ide=["report"]
+format-command="uv run ruff format --force-exclude --config pyproject.toml --stdin-filename {filename}"
+
+[tool.pyright]
+venvPath = "../.."
+venv = ".venv"
+pythonVersion = "3.12"
+strict = ["**/*.py"]
+
+[tool.coverage.report]
+fail_under = 95