agent-runtime-kit 0.1.0__tar.gz

agent_runtime_kit-0.1.0/.gitignore

@@ -0,0 +1,16 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+.DS_Store
+
+# Virtual environments
+.venv

agent_runtime_kit-0.1.0/.planning/PROJECT.md

@@ -0,0 +1,140 @@
+# agent-runtime-kit
+
+## What This Is
+
+`agent-runtime-kit` is a Python package that gives developers one clean API for running agentic
+coding tasks through Claude Agent SDK, OpenAI Codex SDK, and Google
+Antigravity SDK. It extracts the useful vendor-runtime ideas from Mestre while
+remaining independently useful to the community: install it, choose a runtime,
+run a task, stream/inspect events, and get a typed result back.
+
+The package is not a new orchestrator or model router. It is the reusable
+runtime layer that makes vendor agent SDKs feel consistent without hiding the
+capabilities and constraints that make each SDK different.
+
+## Core Value
+
+Developers can run the same agentic task through Claude, Codex, or Antigravity
+using one small, typed Python API while preserving the vendor-specific
+capabilities needed for real work.
+
+## Requirements
+
+### Validated
+
+(None yet - ship to validate)
+
+### Active
+
+- [ ] Publish the package as `agent-runtime-kit` on PyPI.
+- [ ] Support Python 3.10+ so the package is broadly usable and aligns with
+      current vendor SDK lower bounds.
+- [ ] Provide a clean public API that does not expose Mestre internals.
+- [ ] Keep a low-friction Mestre adoption path through compatibility adapters
+      or migration helpers.
+- [ ] Provide a shared runtime contract for agentic work: task input, runtime
+      capability metadata, event emission, cancellation, session/resume handles,
+      tool-call audit records, structured output, artifacts, cost/usage
+      metadata, and typed results.
+- [ ] Implement runnable adapters for Claude Agent SDK, OpenAI Codex SDK, and
+      Google Antigravity SDK in the first public release.
+- [ ] Make vendor dependencies optional, with extras such as `claude`, `codex`,
+      `antigravity`, and `all`.
+- [ ] Surface vendor capability differences explicitly instead of pretending
+      all SDKs support the same features.
+- [ ] Include examples that run the same task through all three runtimes.
+- [ ] Include unit tests with fake SDK surfaces and at least smoke-test paths
+      that prove adapter construction and invocation behavior.
+- [ ] Document authentication, permissions, working-directory behavior,
+      structured output behavior, MCP support, session behavior, and known
+      vendor limitations.
+
+### Out of Scope
+
+- Full Mestre orchestration, routing, fallback, benchmarking, optimization, and
+  self-improvement loops - the package should be useful without becoming
+  Mestre.
+- Generic chat/completions abstraction - this package targets agentic SDKs that
+  own tool loops and local/runtime context.
+- Scraping or reusing unsupported local account credentials - use each vendor's
+  supported authentication path.
+- A hosted service, UI, queue, control plane, or remote execution platform.
+- Non-Python SDKs for the initial release.
+- Hiding vendor differences behind lowest-common-denominator behavior.
+
+## Context
+
+The project starts from Mestre's live vendor-lane implementation in
+`~/Github/mestre`, especially:
+
+- `mestre/vendor_lane/agent_protocol.py` - existing typed contract for
+  `AgentTask`, `AgentResult`, capabilities, session resume state, MCP config,
+  event sinks, and tool-call audits.
+- `mestre/vendor_lane/events.py` - canonical task/tool/output/vendor-turn event
+  vocabulary.
+- `mestre/vendor_lane/backends/claude_sdk.py` - Claude Agent SDK adapter logic.
+- `mestre/vendor_lane/backends/codex_sdk.py` - Codex SDK adapter logic.
+- `mestre/vendor_lane/backends/antigravity_sdk.py` - Antigravity SDK adapter
+  logic.
+- `mestre/execution/agent/registry.py` - runtime registry pattern.
+- `mestre/llm/policy.py` - boundary to avoid over-extracting full routing
+  policy into this package.
+
+Official vendor docs checked during initialization:
+
+- Claude Agent SDK: https://docs.anthropic.com/en/docs/claude-code/sdk
+- Codex SDK: https://developers.openai.com/codex/sdk
+- Google Antigravity SDK:
+  https://github.com/google-antigravity/antigravity-sdk-python
+
+The current PyPI name check found `agent-runtime-kit` available on
+2026-06-10. This availability must be rechecked immediately before publishing.
+
+## Constraints
+
+- **Language**: Python package first - Mestre and all three target vendor SDK
+  integrations are Python-facing for this work.
+- **Python version**: Python 3.10+ - broad community compatibility matters more
+  than matching Mestre's current Python 3.14-only project constraint.
+- **Package name**: Use `agent-runtime-kit` unless a later publishing check
+  shows the name is no longer available.
+- **Vendor support**: Claude, Codex, and Antigravity must all be runnable in
+  v1; partial provider stubs are not enough for a useful community release.
+- **Dependency model**: Vendor SDKs should be optional extras so users can
+  install only the runtimes they need.
+- **Architecture**: Extract the runtime/adapters layer from Mestre, not the full
+  orchestration and routing system.
+- **API design**: Prefer a clean public API, but keep compatibility adapters or
+  migration helpers so Mestre can adopt the package without excessive churn.
+- **Authentication**: Stay within supported vendor SDK authentication
+  mechanisms; do not build brittle local credential scraping into the core.
+
+## Key Decisions
+
+| Decision | Rationale | Outcome |
+|----------|-----------|---------|
+| Publish as `agent-runtime-kit` | The name was available on PyPI during initialization and accurately describes a runtime/adapters library. | Pending |
+| Target Python 3.10+ | Vendor SDK docs support Python 3.10+, and community adoption is more important than mirroring Mestre's Python 3.14 baseline. | Pending |
+| Make all three runtimes runnable in v1 | Community usefulness depends on a real multi-vendor proof, not a single polished adapter plus placeholders. | Pending |
+| Use a clean public API with Mestre migration support | The package should stand on its own while still making future Mestre adoption practical. | Pending |
+| Extract runtime/adapters, not full orchestration | Mestre's routing, fallback, benchmarking, and self-improvement loops would make the package too broad for a first release. | Pending |
+
+## Evolution
+
+This document evolves at phase transitions and milestone boundaries.
+
+**After each phase transition** (via `$gsd-transition`):
+1. Requirements invalidated? -> Move to Out of Scope with reason
+2. Requirements validated? -> Move to Validated with phase reference
+3. New requirements emerged? -> Add to Active
+4. Decisions to log? -> Add to Key Decisions
+5. "What This Is" still accurate? -> Update if drifted
+
+**After each milestone** (via `$gsd-complete-milestone`):
+1. Full review of all sections
+2. Core Value check - still the right priority?
+3. Audit Out of Scope - reasons still valid?
+4. Update Context with current state
+
+---
+*Last updated: 2026-06-10 after initialization*

agent_runtime_kit-0.1.0/.planning/REQUIREMENTS.md

@@ -0,0 +1,196 @@
+# Requirements: agent-runtime-kit
+
+**Defined:** 2026-06-10
+**Core Value:** Developers can run the same agentic task through Claude, Codex,
+or Antigravity using one small, typed Python API while preserving the
+vendor-specific capabilities needed for real work.
+
+## v1 Requirements
+
+Requirements for the first public release of `agent-runtime-kit`. Each maps to
+roadmap phases.
+
+### Packaging
+
+- [ ] **PKG-01**: Developer can install the core package from PyPI as
+  `agent-runtime-kit` without installing any vendor SDK.
+- [ ] **PKG-02**: Developer can install vendor-specific extras for `claude`,
+  `codex`, `antigravity`, and `all`.
+- [ ] **PKG-03**: Package metadata declares Python 3.10+ support.
+- [ ] **PKG-04**: Core package import succeeds when no vendor extras are
+  installed.
+- [ ] **PKG-05**: Package publishing checklist includes a fresh PyPI name
+  availability check for `agent-runtime-kit`.
+
+### Core Runtime API
+
+- [ ] **CORE-01**: Developer can create a typed `AgentTask` with goal, optional
+  system prompt, working directory, permissions, session/resume data, metadata,
+  MCP server config, and output schema.
+- [ ] **CORE-02**: Developer receives a typed `AgentResult` with output,
+  finish reason, error, session id, artifacts, tool-call audits, usage/cost
+  metadata, and parsed structured output when available.
+- [ ] **CORE-03**: Developer can implement or use an async `AgentRuntime`
+  protocol with `run(task)` and `cancel(task_id)`.
+- [ ] **CORE-04**: Developer can inspect each runtime's declared capabilities
+  before dispatching a task.
+- [ ] **CORE-05**: Runtime rejects unsupported task inputs with clear typed
+  errors instead of silently dropping fields.
+- [ ] **CORE-06**: Developer can register and resolve runtimes through a small
+  runtime registry.
+- [ ] **CORE-07**: Runtime availability checks distinguish missing package,
+  missing credentials, unsupported model/runtime, and other setup failures.
+
+### Events and Observability
+
+- [ ] **EVNT-01**: Developer can attach an async event sink to receive
+  `agent.task.started` events.
+- [ ] **EVNT-02**: Developer can receive `agent.task.completed` and
+  `agent.task.failed` events with normalized task/result metadata.
+- [ ] **EVNT-03**: Developer can receive normalized output-delta events for
+  streamed text where a vendor exposes streaming.
+- [ ] **EVNT-04**: Developer can receive normalized tool-requested and
+  tool-completed audit events where a vendor exposes tool activity.
+- [ ] **EVNT-05**: Event payloads truncate or summarize sensitive/high-volume
+  data by default.
+
+### Provider Adapters
+
+- [ ] **ADPT-01**: Developer can run a task through Claude Agent SDK using the
+  shared runtime API.
+- [ ] **ADPT-02**: Claude adapter supports working directory, permission mode,
+  MCP config, allowed/disallowed tools, session resume, structured output, and
+  clear missing-SDK/auth diagnostics where supported by the installed SDK.
+- [ ] **ADPT-03**: Developer can run a task through OpenAI Codex SDK using the
+  shared runtime API.
+- [ ] **ADPT-04**: Codex adapter supports local app-server/thread lifecycle,
+  working directory, approval/sandbox mapping, session resume, structured
+  output, and model availability diagnostics.
+- [ ] **ADPT-05**: Developer can run a task through Google Antigravity SDK using
+  the shared runtime API.
+- [ ] **ADPT-06**: Antigravity adapter supports API-key diagnostics,
+  working-directory/workspace mapping, permission/capability mapping, MCP
+  config, structured output, session id, and tool/event translation where
+  supported by the installed SDK.
+- [ ] **ADPT-07**: All adapters preserve vendor-specific metadata needed for
+  debugging without making that metadata the primary public API.
+
+### Testing and Quality
+
+- [ ] **TEST-01**: Core tests pass without Claude, Codex, or Antigravity SDKs
+  installed.
+- [ ] **TEST-02**: Fake SDK tests cover successful invocation, vendor errors,
+  missing dependency, unsupported task input, timeout, session id, structured
+  output, and event translation for each adapter.
+- [ ] **TEST-03**: Type-check or static-analysis workflow validates the public
+  API surface.
+- [ ] **TEST-04**: Ruff lint/format workflow passes for the package.
+- [ ] **TEST-05**: Optional live smoke tests are documented and skipped unless
+  explicit credentials/runtime flags are present.
+- [ ] **TEST-06**: Compatibility tests verify the public API can represent the
+  fields Mestre currently needs from its vendor-lane runtime contract.
+
+### Documentation and Examples
+
+- [ ] **DOCS-01**: README explains what the package is, what it is not, and how
+  it differs from vendor SDKs and full agent frameworks.
+- [ ] **DOCS-02**: Quickstart shows installing the package and running one task
+  through one runtime.
+- [ ] **DOCS-03**: Example shows the same task running through Claude, Codex,
+  and Antigravity with the shared API.
+- [ ] **DOCS-04**: Provider setup docs cover auth, required extras, local
+  runtime requirements, and known limitations for each vendor.
+- [ ] **DOCS-05**: Capability matrix documents MCP, working directory, session
+  resume, structured output, permissions, streaming, and tool-audit support for
+  each runtime.
+- [ ] **DOCS-06**: Migration notes describe how Mestre can adopt
+  `agent-runtime-kit` without moving its routing, fallback, benchmarking, or
+  self-improvement layers into the package.
+
+## v2 Requirements
+
+Deferred to future release. Tracked but not in current roadmap.
+
+### Integrations
+
+- **INTG-01**: Package provides optional OpenTelemetry helper functions for
+  converting events into spans or span events.
+- **INTG-02**: Package provides a first-class Mestre compatibility module if
+  the initial migration notes are not enough.
+- **INTG-03**: Package maintains a generated provider compatibility/version
+  matrix.
+
+### Additional Runtime Scope
+
+- **RUNT-01**: Package evaluates whether direct chat/completions adapters
+  belong in a separate package or future major version.
+- **RUNT-02**: Package evaluates support for additional agent SDKs after the
+  first three providers are stable.
+- **RUNT-03**: Package evaluates a synchronous convenience wrapper over the
+  async core.
+
+## Out of Scope
+
+Explicitly excluded. Documented to prevent scope creep.
+
+| Feature | Reason |
+|---------|--------|
+| Full model routing and fallback | Belongs in applications such as Mestre; too broad for a focused runtime SDK. |
+| Benchmarking and self-optimization loops | Product-specific and not required for a useful public package. |
+| Hosted service, queue, UI, or control plane | The first release is a local Python library. |
+| Unsupported local credential scraping | Security-sensitive and outside supported vendor auth paths. |
+| Non-Python SDKs | Python package first; revisit after v1 adoption. |
+| Lowest-common-denominator provider abstraction | The package must preserve important vendor capability differences. |
+| Mandatory live provider tests in default CI | Would require credentials, cost money, and create flaky contributor workflows. |
+
+## Traceability
+
+Which phases cover which requirements. Updated during roadmap creation.
+
+| Requirement | Phase | Status |
+|-------------|-------|--------|
+| PKG-01 | Phase 5 | Ready (publish pending) |
+| PKG-02 | Phase 2 | Complete |
+| PKG-03 | Phase 1 | Complete |
+| PKG-04 | Phase 1 | Complete |
+| PKG-05 | Phase 5 | Complete |
+| CORE-01 | Phase 1 | Complete |
+| CORE-02 | Phase 1 | Complete |
+| CORE-03 | Phase 1 | Complete |
+| CORE-04 | Phase 1 | Complete |
+| CORE-05 | Phase 1 | Complete |
+| CORE-06 | Phase 1 | Complete |
+| CORE-07 | Phase 1 | Complete |
+| EVNT-01 | Phase 2 | Complete |
+| EVNT-02 | Phase 2 | Complete |
+| EVNT-03 | Phase 2 | Complete |
+| EVNT-04 | Phase 2 | Complete |
+| EVNT-05 | Phase 2 | Complete |
+| ADPT-01 | Phase 3 | Complete |
+| ADPT-02 | Phase 3 | Complete |
+| ADPT-03 | Phase 3 | Complete |
+| ADPT-04 | Phase 3 | Complete |
+| ADPT-05 | Phase 4 | Complete |
+| ADPT-06 | Phase 4 | Complete |
+| ADPT-07 | Phase 4 | Complete |
+| TEST-01 | Phase 2 | Complete |
+| TEST-02 | Phase 2 | Complete |
+| TEST-03 | Phase 1 | Complete |
+| TEST-04 | Phase 1 | Complete |
+| TEST-05 | Phase 5 | Complete |
+| TEST-06 | Phase 4 | Complete |
+| DOCS-01 | Phase 5 | Complete |
+| DOCS-02 | Phase 3 | Complete |
+| DOCS-03 | Phase 4 | Complete |
+| DOCS-04 | Phase 5 | Complete |
+| DOCS-05 | Phase 5 | Complete |
+| DOCS-06 | Phase 5 | Complete |
+
+**Coverage:**
+- v1 requirements: 36 total
+- Mapped to phases: 36
+- Unmapped: 0
+
+---
+*Requirements defined: 2026-06-10*
+*Last updated: 2026-06-10 after roadmap traceability mapping*

agent_runtime_kit-0.1.0/.planning/ROADMAP.md

@@ -0,0 +1,124 @@
+# Roadmap: agent-runtime-kit
+
+## Overview
+
+The v1.0 milestone turns the repository into a publishable Python package
+named `agent-runtime-kit`. The build path starts with a small
+installable core and public runtime contract, adds the fake-SDK harness needed
+to keep vendor drift under control, then delivers Claude/Codex adapters,
+Antigravity plus cross-runtime proof, and finally release-ready docs,
+packaging, and smoke-test guidance.
+
+## Phases
+
+**Phase Numbering:**
+- Integer phases (1, 2, 3): Planned milestone work
+- Decimal phases (2.1, 2.2): Urgent insertions (marked with INSERTED)
+
+Decimal phases appear between their surrounding integers in numeric order.
+
+- [x] **Phase 1: Core Runtime Skeleton** - Installable core package with public task/result/runtime contracts.
+- [x] **Phase 2: Events and Test Harness** - Optional extras skeleton, event system, and fake SDK contract tests.
+- [x] **Phase 3: Claude and Codex Runtimes** - First two real vendor adapters through the shared API.
+- [x] **Phase 4: Antigravity and Cross-Runtime Proof** - Third adapter plus same-task multi-runtime proof and Mestre compatibility checks.
+- [x] **Phase 5: Public Release Readiness** - Documentation, capability matrix, live-smoke guidance, and PyPI publish checklist.
+
+## Phase Details
+
+### Phase 1: Core Runtime Skeleton
+**Goal**: A developer can install/import the core package locally and run a fake runtime through the public async API without any vendor SDK installed.
+**Mode:** mvp
+**Depends on**: Nothing (first phase)
+**Requirements**: [PKG-03, PKG-04, CORE-01, CORE-02, CORE-03, CORE-04, CORE-05, CORE-06, CORE-07, TEST-03, TEST-04]
+**Success Criteria** (what must be TRUE):
+  1. Developer can import `agent_runtime_kit` in an environment with no vendor SDKs installed.
+  2. Developer can create an `AgentTask`, execute a fake runtime, and receive an `AgentResult`.
+  3. Runtime capability checks and unsupported-feature errors are typed and covered by tests.
+  4. Ruff and static-analysis commands validate the initial public API.
+**Plans**: 3 plans
+
+Plans:
+- [ ] 01-01: Package scaffolding and Python 3.10+ metadata
+- [ ] 01-02: Public task/result/runtime/capability/error models
+- [ ] 01-03: Registry, availability diagnostics, lint, and type/static checks
+
+### Phase 2: Events and Test Harness
+**Goal**: A developer can observe normalized fake-runtime events and the package has the fake SDK harness required to test real adapters without live credentials.
+**Mode:** mvp
+**Depends on**: Phase 1
+**Requirements**: [PKG-02, EVNT-01, EVNT-02, EVNT-03, EVNT-04, EVNT-05, TEST-01, TEST-02]
+**Success Criteria** (what must be TRUE):
+  1. Core tests pass without Claude, Codex, or Antigravity SDKs installed.
+  2. Developer can attach an event sink and receive started, completed, failed, output, tool, and vendor-turn events from a fake runtime.
+  3. Event payload defaults summarize or truncate high-volume fields.
+  4. Fake SDK fixtures can simulate success, failure, missing dependency, unsupported input, timeout, session id, structured output, and tool events.
+**Plans**: 3 plans
+
+Plans:
+- [ ] 02-01: Optional extras skeleton and dependency isolation tests
+- [ ] 02-02: Event vocabulary, event sink, and redaction/truncation defaults
+- [ ] 02-03: Fake SDK harness and adapter contract test utilities
+
+### Phase 3: Claude and Codex Runtimes
+**Goal**: A developer can run real Claude and Codex agent tasks through the shared runtime API with clear diagnostics and provider-specific capability handling.
+**Mode:** mvp
+**Depends on**: Phase 2
+**Requirements**: [ADPT-01, ADPT-02, ADPT-03, ADPT-04, DOCS-02]
+**Success Criteria** (what must be TRUE):
+  1. Developer can install the Claude extra and run a Claude Agent SDK task through `agent-runtime-kit`.
+  2. Developer can install the Codex extra and run a Codex SDK task through `agent-runtime-kit`.
+  3. Claude and Codex adapters fail clearly for missing SDKs, missing setup, unsupported fields, and unsupported models.
+  4. The quickstart demonstrates one runtime end to end through the public API.
+**Plans**: 3 plans
+
+Plans:
+- [ ] 03-01: Claude Agent SDK adapter and tests
+- [ ] 03-02: Codex SDK adapter and tests
+- [ ] 03-03: One-runtime quickstart and provider diagnostics docs
+
+### Phase 4: Antigravity and Cross-Runtime Proof
+**Goal**: A developer can run the same task through Claude, Codex, and Antigravity, and the public API can represent Mestre's current runtime needs.
+**Mode:** mvp
+**Depends on**: Phase 3
+**Requirements**: [ADPT-05, ADPT-06, ADPT-07, TEST-06, DOCS-03]
+**Success Criteria** (what must be TRUE):
+  1. Developer can install the Antigravity extra and run an Antigravity SDK task through `agent-runtime-kit`.
+  2. Antigravity adapter maps auth, workspace, permissions, MCP, structured output, sessions, and tool/event behavior where supported.
+  3. Same-task example runs through all three runtime kinds with one public API shape.
+  4. Compatibility tests prove the public API can represent the fields Mestre currently uses from its vendor-lane contract.
+**Plans**: 3 plans
+
+Plans:
+- [ ] 04-01: Google Antigravity SDK adapter and tests
+- [ ] 04-02: Same-task three-runtime example
+- [ ] 04-03: Mestre compatibility field audit and tests
+
+### Phase 5: Public Release Readiness
+**Goal**: The package is ready for a first public PyPI release with documentation, capability matrix, optional live smoke tests, and a final publish checklist.
+**Mode:** mvp
+**Depends on**: Phase 4
+**Requirements**: [PKG-01, PKG-05, TEST-05, DOCS-01, DOCS-04, DOCS-05, DOCS-06]
+**Success Criteria** (what must be TRUE):
+  1. README and provider docs explain what the package is, what it is not, and how to configure each runtime.
+  2. Capability matrix documents MCP, working directory, sessions, structured output, permissions, streaming, and tool-audit behavior for each runtime.
+  3. Optional live smoke tests are documented and skipped unless explicit credentials/runtime flags are present.
+  4. PyPI publish checklist includes a fresh `agent-runtime-kit` name check and the package can be built for release.
+**Plans**: 3 plans
+
+Plans:
+- [ ] 05-01: README, provider setup docs, and capability matrix
+- [ ] 05-02: Optional live smoke test harness and documentation
+- [ ] 05-03: Build, publish checklist, and Mestre migration notes
+
+## Progress
+
+**Execution Order:**
+Phases execute in numeric order: 1 -> 2 -> 3 -> 4 -> 5
+
+| Phase | Plans Complete | Status | Completed |
+|-------|----------------|--------|-----------|
+| 1. Core Runtime Skeleton | 3/3 | Complete | 2026-06-10 |
+| 2. Events and Test Harness | 3/3 | Complete | 2026-06-10 |
+| 3. Claude and Codex Runtimes | 3/3 | Complete | 2026-06-10 |
+| 4. Antigravity and Cross-Runtime Proof | 3/3 | Complete | 2026-06-10 |
+| 5. Public Release Readiness | 3/3 | Complete | 2026-06-10 |

agent_runtime_kit-0.1.0/.planning/STATE.md

@@ -0,0 +1,100 @@
+---
+gsd_state_version: '1.0'
+status: complete
+progress:
+  total_phases: 5
+  completed_phases: 5
+  total_plans: 15
+  completed_plans: 15
+  percent: 100
+---
+
+# Project State
+
+## Project Reference
+
+See: .planning/PROJECT.md (updated 2026-06-10)
+
+**Core value:** Developers can run the same agentic task through Claude, Codex,
+or Antigravity using one small, typed Python API while preserving the
+vendor-specific capabilities needed for real work.
+**Current focus:** Roadmap delivered as stacked PRs
+
+## Current Position
+
+Phase: 5 of 5 (Public Release Readiness)
+Plan: 3 of 3 in current phase
+Status: All phases complete; stacked PR publication pending
+Last activity: 2026-06-10 - Phase 5 completed release readiness and build verification.
+
+Progress: [##########] 100%
+
+## Performance Metrics
+
+**Velocity:**
+- Total plans completed: 15
+- Average duration: n/a
+- Total execution time: 0.0 hours
+
+**By Phase:**
+
+| Phase | Plans | Total | Avg/Plan |
+|-------|-------|-------|----------|
+| 1. Core Runtime Skeleton | 3 | 3 | n/a |
+| 2. Events and Test Harness | 3 | 3 | n/a |
+| 3. Claude and Codex Runtimes | 3 | 3 | n/a |
+| 4. Antigravity and Cross-Runtime Proof | 3 | 3 | n/a |
+| 5. Public Release Readiness | 3 | 3 | n/a |
+
+**Recent Trend:**
+- Last 5 plans: 04-02, 04-03, 05-01, 05-02, 05-03
+- Trend: n/a
+
+*Updated after each plan completion*
+
+## Accumulated Context
+
+### Decisions
+
+Decisions are logged in PROJECT.md Key Decisions table.
+Recent decisions affecting current work:
+
+- Initialization: Publish package as `agent-runtime-kit`.
+- Initialization: Target Python 3.10+.
+- Initialization: Make Claude, Codex, and Antigravity runnable in v1.
+- Initialization: Keep public API clean while preserving a low-friction Mestre adoption path.
+- Initialization: Extract runtime/adapters, not Mestre's full orchestration stack.
+- Phase 1: Core package stays dependency-free; vendor SDK imports are deferred
+  to optional adapter modules.
+- Phase 2: Event payloads use a normalized dictionary shape and sanitize
+  sensitive/high-volume attributes before emission.
+- Phase 3: Claude and Codex adapters use lazy imports and fake-injected tests
+  so default CI remains credential-free.
+- Phase 4: Antigravity MCP stdio server env values are rejected because the
+  SDK config surface does not expose env.
+- Phase 5: Actual PyPI publication remains pending after review/merge; release
+  checklist includes a fresh name check.
+
+### Pending Todos
+
+- Publish stacked PRs.
+- Recheck PyPI name immediately before actual publication.
+
+### Blockers/Concerns
+
+- PyPI name availability for `agent-runtime-kit` must be rechecked immediately before publishing.
+- Vendor SDK surfaces are moving; rerun live smoke tests before release if credentials are available.
+
+## Deferred Items
+
+Items acknowledged and carried forward from previous milestone close:
+
+| Category | Item | Status | Deferred At |
+|----------|------|--------|-------------|
+| *(none)* | | | |
+
+## Session Continuity
+
+Last session: 2026-06-10 23:00
+Stopped at: Initial roadmap drafted
+Resume file: None

agent_runtime_kit-0.1.0/.planning/config.json

@@ -0,0 +1,68 @@
+{
+  "model_profile": "quality",
+  "commit_docs": true,
+  "parallelization": true,
+  "search_gitignored": false,
+  "brave_search": false,
+  "firecrawl": false,
+  "exa_search": false,
+  "tavily_search": false,
+  "ref_search": false,
+  "perplexity": false,
+  "jina": false,
+  "git": {
+    "branching_strategy": "none",
+    "create_tag": true,
+    "phase_branch_template": "gsd/phase-{phase}-{slug}",
+    "milestone_branch_template": "gsd/{milestone}-{slug}",
+    "quick_branch_template": null
+  },
+  "workflow": {
+    "research": true,
+    "plan_check": true,
+    "verifier": true,
+    "nyquist_validation": false,
+    "auto_advance": true,
+    "node_repair": true,
+    "node_repair_budget": 2,
+    "ui_phase": true,
+    "ui_safety_gate": true,
+    "ai_integration_phase": true,
+    "tdd_mode": false,
+    "human_verify_mode": "end-of-phase",
+    "text_mode": false,
+    "research_before_questions": false,
+    "discuss_mode": "discuss",
+    "skip_discuss": false,
+    "code_review": true,
+    "code_review_depth": "deep",
+    "code_review_command": null,
+    "pattern_mapper": true,
+    "plan_bounce": false,
+    "plan_bounce_script": null,
+    "plan_bounce_passes": 2,
+    "auto_prune_state": false,
+    "post_planning_gaps": true,
+    "security_enforcement": true,
+    "security_asvs_level": 1,
+    "security_block_on": "high",
+    "use_worktrees": true
+  },
+  "ship": {
+    "pr_body_sections": []
+  },
+  "hooks": {
+    "context_warnings": true
+  },
+  "project_code": null,
+  "phase_naming": "sequential",
+  "agent_skills": {},
+  "claude_md_path": "./CLAUDE.md",
+  "plan_review": {
+    "source_grounding": true,
+    "source_grounding_authority": "grep"
+  },
+  "mode": "yolo",
+  "granularity": "coarse",
+  "resolve_model_ids": "omit"
+}