agentdebugx 0.2.0__tar.gz → 0.2.2__tar.gz

{agentdebugx-0.2.0 → agentdebugx-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentdebugx
-Version: 0.2.0
+Version: 0.2.2
 Summary: Portable error analysis, tracing, and recovery framework for agentic AI systems. Import as `agentdebug`.
 License: MIT
 License-File: LICENSE
@@ -187,6 +187,10 @@ agentdebug serve --store-sqlite .agentdebug/errors.sqlite
 # DeepDebug — iterative multi-turn analysis (plan -> hypothesize -> verify -> refine)
 agentdebug deep <trajectory.json>
 
+# Render the cascade as a Python-traceback (root cause first, manifested failure last)
+agentdebug deep <trajectory.json> --traceback
+agentdebug analyze <trajectory.json> --traceback   # works without an LLM too
+
 # Error Hub: package + push a trace to a Git remote or HF dataset
 agentdebug hub push <trace_id> \
     --to git:git@github.com:your-org/agentdebug-bundles.git#bundles \

{agentdebugx-0.2.0 → agentdebugx-0.2.2}/README.md

@@ -147,6 +147,10 @@ agentdebug serve --store-sqlite .agentdebug/errors.sqlite
 # DeepDebug — iterative multi-turn analysis (plan -> hypothesize -> verify -> refine)
 agentdebug deep <trajectory.json>
 
+# Render the cascade as a Python-traceback (root cause first, manifested failure last)
+agentdebug deep <trajectory.json> --traceback
+agentdebug analyze <trajectory.json> --traceback   # works without an LLM too
+
 # Error Hub: package + push a trace to a Git remote or HF dataset
 agentdebug hub push <trace_id> \
     --to git:git@github.com:your-org/agentdebug-bundles.git#bundles \

{agentdebugx-0.2.0 → agentdebugx-0.2.2}/docs/14_api_reference.md

@@ -215,6 +215,32 @@ agentdebugx taxonomy export --format yaml|json|md
 agentdebugx doctor
 ```
 
+## 11.1 Current shipped `agentdebug` CLI surface
+
+The public design above is the long-term `agentdebugx` contract. The current
+package already ships a smaller but working `agentdebug` CLI:
+
+```bash
+agentdebug analyze <trajectory.json> [--suggest] [--traceback]
+agentdebug list --store-sqlite .agentdebug/errors.sqlite
+agentdebug show <trace_id> --store-sqlite .agentdebug/errors.sqlite
+agentdebug judge <trajectory.json|trace_id> --attribute [--traceback]
+agentdebug deep <trajectory.json|trace_id> [--traceback]
+agentdebug hub push <trace_id> --to local:/tmp/hub --store-sqlite ...
+agentdebug hub pull <spec> --bundle <bundle_id> --into .agentdebug/hub_pulls
+agentdebug hub list <spec>
+agentdebug integrations skill --target ~/.claude/skills --name agentdebug
+agentdebug integrations openhands-microagent --target .openhands/microagents
+agentdebug serve --store-sqlite .agentdebug/errors.sqlite --port 7777
+agentdebug doctor
+```
+
+`--traceback` renders `AgentTraceback`, a Python-traceback-style cascade view
+implemented by `agentdebug.traceback.format_traceback(report, trajectory)`.
+DeepDebug can provide explicit cascade edges through
+`finding.metadata['cascading_from_event_id']`; heuristic and single-pass judge
+reports fall back to step-index ordering.
+
 ## 12. Configuration file
 
 `~/.agentdebugx/settings.yaml`:

{agentdebugx-0.2.0 → agentdebugx-0.2.2}/docs/15_roadmap.md

@@ -28,6 +28,17 @@ Acceptance:
 
 ## v0.2 — Coverage + UI (4 weeks)
 
+Already shipped in the v0.2/v0.2.1 line:
+
+- Error Hub bundle format + Local/Git/Hugging Face backends.
+- DeepDebug iterative analysis loop.
+- Claude Code Skill generator and OpenHands microagent/EventStream bridge.
+- `AgentTraceback` cascade renderer and CLI `--traceback` support.
+- FastAPI local console with native-trace + error-trace alignment for human
+  review.
+
+Remaining scope from the original v0.2 plan:
+
 - Adapters: CrewAI, OpenHands, smolagents, LlamaIndex, DSPy, Pydantic-AI.
 - Detectors: anomaly family (perplexity, repeated-state, topic-drift).
 - Attribution: `BinarySearchAttributor`, `CounterfactualAttributor`, `EnsembleAttributor`.

{agentdebugx-0.2.0 → agentdebugx-0.2.2}/docs/20_deep_debug.md

@@ -115,6 +115,52 @@ rounds        : plan (4.6s) hypothesize (11.0s)
 The single-pass `LLMJudgeAnalyzer` on the same trace returned only the first
 finding. DeepDebug recovered the full cascade and selected the upstream cause.
 
+## 6.1 AgentTraceback — Python-traceback-style cascade view
+
+Once DeepDebug has populated `finding.metadata['cascading_from_event_id']`,
+`agentdebug.traceback.format_traceback(report, trajectory)` renders the
+cascade in a layout that mirrors Python's `Traceback (most recent call last)`
+— root cause first, manifested failure last, with arrows between hops:
+
+```text
+AgentTraceback (root cause first, manifested failure last):
+    trace_id=trace_…  framework=live-cascade-demo  goal='Find latest paper, summarize, then email …'
+
+      File "root cause", in trajectory
+        Step 3  agent=search  mode=action.parameter_error  confidence=1.00
+          module=action
+          error>  JSON schema validation failed: missing parameter query
+          evidence:
+            - args={}
+          suggested: Validate parameters against tool schemas before execution.
+    ↓ cascaded to
+      File "cascade depth 1", in trajectory
+        Step 4  agent=planner  mode=verification.premature_stop  confidence=1.00
+          output> Final answer: AgentDebug is a popular paper.
+    ↓ cascaded to
+      File "cascade depth 1", in trajectory
+        Step 4  agent=planner  mode=memory.hallucination  confidence=0.95
+          output> Final answer: AgentDebug is a popular paper.
+
+AgentFailure[memory.hallucination]: The search agent failed to provide the
+required 'query' parameter in its tool call, leading to a tool error. The
+planner then hallucinated a generic fact about the paper and prematurely
+terminated the task without completing the summary or email steps.
+```
+
+CLI:
+
+```bash
+agentdebug deep <trajectory.json> --traceback         # render to stdout
+agentdebug analyze <trajectory.json> --traceback      # works for rule analyzer too
+agentdebug judge <traj|trace_id> --attribute --traceback
+```
+
+When DeepDebug isn't available (heuristic analyzer or single-pass judge),
+the renderer falls back to **step-index ordering** — the earliest finding
+becomes the root and later findings cascade from it. This means
+`--traceback` works on any analyzer in the pipeline, not just DeepDebug.
+
 ## 7. Failure modes
 
 - **Cost blowout** — if `max_hypotheses_to_verify` is high and verify is

agentdebugx-0.2.2/docs/22_industry_track_paper_eval_plan.md

@@ -0,0 +1,235 @@
+# 22 - EMNLP Industry Track Paper + Evaluation Plan
+
+This note translates the EMNLP 2026 Industry Track call and recent ACL/EMNLP
+Industry Track patterns into a concrete writing and evaluation plan for the
+AgentDebugX paper.
+
+## 1. What Industry Track Reviewers Reward
+
+Industry-track papers are not judged like pure method papers. The recurring
+shape in strong papers is:
+
+1. Real deployment pain, not a benchmark-only motivation.
+2. A system that can actually be used by practitioners.
+3. Evaluation under practical constraints: cost, latency, scale, privacy,
+   maintainability, human workflow, and failure modes.
+4. Lessons learned that future builders can reuse.
+5. Clear limitations and responsible deployment boundaries.
+
+Examples worth emulating:
+
+- **Experience Report: Implementing Machine Translation in a Regulated
+  Industry** (EMNLP 2025 Industry): emphasizes legal/security constraints,
+  human-in-the-loop validation, and reviewer preferences over more than 11k
+  ranked translations. Source: https://aclanthology.org/2025.emnlp-industry/
+- **STREAQ** (EMNLP 2025 Industry): frames the contribution as an industrial
+  cost-quality routing system and reports both model quality and operational
+  cost reduction. Source: https://aclanthology.org/2025.emnlp-industry.121/
+- **RAVEN** (ACL 2025 Industry): combines industrial data, public benchmarks,
+  deployment pipeline, and online A/B validation. Source:
+  https://aclanthology.org/2025.acl-industry.3/
+- **ARIA** (EMNLP 2025 Industry): uses a realistic deployed domain plus public
+  dynamic-knowledge tasks, and states deployment scope.
+- **AutoPenBench** (EMNLP 2025 Industry): releases an open benchmark, reports
+  autonomous versus human-assisted agent success, and uses intermediate
+  milestones to show where agents struggle. Source:
+  https://aclanthology.org/2025.emnlp-industry.114/
+
+For AgentDebugX, the paper should therefore be framed as:
+
+> A deployment-oriented debugging layer for agentic NLP systems, evaluated on
+> whether it makes failures observable, attributable, shareable, and easier for
+> humans to fix.
+
+The central claim should not be "we beat every attributor." A stronger claim
+for the Industry Track is:
+
+> AgentDebugX provides the missing operating layer between raw agent traces and
+> actionable debugging workflows: aligned native/error traces, taxonomy-backed
+> reports, Error Hub bundles, and cost-aware analysis profiles.
+
+## 2. Appendix Rule
+
+The EMNLP 2026 Industry Track permits appendices after the bibliography. The
+appendix does not count against the 6-page review limit, but the main paper
+must be self-contained and reviewers are not required to review appendices.
+Source: https://2026.emnlp.org/calls/industry_track/
+So:
+
+- Main body: problem, system, screenshot, concise evaluation table, key
+  findings, limitations.
+- Appendix: benchmark matrix, annotation schema, prompts, model settings,
+  study protocol, redaction examples, additional error traces.
+
+Do not hide the core evaluation logic in the appendix. Put enough in the main
+body that a reviewer can assess technical quality without reading extra pages.
+
+## 3. Main-Body Narrative
+
+Recommended six-page spine:
+
+1. **Introduction**: agent systems fail through cascades; raw traces are not
+   enough; teams need who/when/why/fix.
+2. **Deployment Requirements**: low-friction instrumentation, privacy,
+   portable schema, cost-aware analysis, human review.
+3. **System**: recorder + schema + taxonomy + detectors/attributors +
+   Error Hub + UI.
+4. **Use Case Figure**: paired native trace and AgentDebugX error trace.
+5. **Evaluation**: benchmark coverage, diagnostic accuracy, human utility,
+   operational overhead.
+6. **Lessons/Limitations**: where it works, where it does not, safety.
+
+## 4. Evaluation Questions
+
+### Q1. Coverage
+
+Can AgentDebugX ingest different agent classes without bespoke debugging code?
+
+Benchmarks:
+
+- AgentErrorBench: failure-labeled traces over ALFWorld, GAIA, WebShop.
+- MAST and Who&When: multi-agent attribution and failure taxonomy labels.
+- AgentRx: 115 failed trajectories with critical-step labels.
+- WebShop/WebArena: web navigation and tool-use.
+- tau-bench: retail/airline tool-agent-user interaction.
+- SWE-bench Lite/Verified: coding agents with executable tests.
+- OSWorld: multimodal desktop/GUI agents.
+
+Metric: conversion success rate, required adapter LOC, event coverage, artifact
+coverage, and schema loss notes.
+
+### Q2. Diagnostic Accuracy
+
+Can AgentDebugX classify and localize failures?
+
+Labels:
+
+- failure family
+- failure mode
+- root event ID
+- root agent
+- root step
+- cascade edges
+- evidence spans
+- accepted repair
+
+Metrics:
+
+- family macro-F1
+- mode macro-F1
+- responsible-agent accuracy
+- root-step exact match
+- root-step +/- 1 match
+- cascade-edge F1
+- false-positive rate on successful traces
+- calibration: confidence vs correctness
+
+Baselines:
+
+- rule analyzer
+- single-pass LLM judge
+- All-at-Once attribution
+- Step-by-Step attribution when implemented
+- DeepDebug verify/refine loop
+- benchmark-native labels or published baselines where available
+
+### Q3. Human Utility
+
+Does the paired trace view reduce debugging effort?
+
+Study design:
+
+- 12-24 developers.
+- Within-subject comparison: raw framework trace/logs vs AgentDebugX report.
+- 24-48 total debugging sessions.
+- Counterbalance task order and UI order.
+
+Metrics:
+
+- time to first plausible root cause
+- time to accepted repair
+- correctness against adjudicated labels
+- number of trace events inspected
+- confidence and workload rating
+- free-text feedback on missing evidence
+
+Fallback if recruiting slips:
+
+- 3-5 expert agent builders review 30 traces.
+- Ask them to choose between raw trace and AgentDebugX report, rate usefulness,
+  and mark incorrect/misleading diagnoses.
+
+### Q4. Operational Viability
+
+Can teams run this in real workflows?
+
+Metrics:
+
+- analyzer latency by profile: rule, judge, DeepDebug
+- token cost by trace length
+- local storage overhead
+- UI load time for 100, 1k, 10k events
+- scrubber redaction hit rate
+- scrubber false positives on benign strings
+- Error Hub bundle size and push/pull time
+
+## 5. Data Scale
+
+Minimum credible submission target:
+
+- 500 failed trajectories.
+- 100 successful trajectories for false-positive calibration.
+- At least 30 examples per high-level family where source benchmarks permit.
+- Two annotators per newly labeled trace plus adjudication.
+- DeepDebug on a stratified hard subset of 100 traces.
+
+Stronger target:
+
+- 1,000 failed trajectories.
+- 200 successful trajectories.
+- DeepDebug on every trace where rule and single-pass judge disagree.
+- 50-100 private pilot traces, scrubbed and reported only in aggregate.
+
+## 6. API and Infra Needed
+
+Model APIs:
+
+- OpenAI-compatible endpoint as the default abstraction.
+- OpenAI, Gemini, Anthropic-through-proxy/LiteLLM, and local vLLM/Ollama where
+  feasible.
+
+Benchmark APIs:
+
+- WebShop/ALFWorld/GAIA loaders for AgentErrorBench.
+- MAST/Who&When/AgentRx importers preserving existing labels.
+- tau-bench user/tool simulator wrapper.
+- WebArena browser harness with DOM/text/action capture.
+- SWE-bench Docker harness with shell, patch, and test-output capture.
+- OSWorld capture path for screenshot, accessibility tree, click/action, and
+  verifier result.
+
+Storage/export:
+
+- SQLite for local experiments.
+- Error Hub bundles for sharing.
+- Parquet manifest roll-up for large result analysis.
+
+## 7. What Should Go in the Appendix
+
+- Full benchmark matrix.
+- Exact label schema and examples.
+- Prompts for LLM judge, attributor, and DeepDebug.
+- Model settings and token budgets.
+- Human study instructions and consent/safety notes.
+- Redaction examples.
+- Two or three full trace/report examples.
+- Failure cases where AgentDebugX is wrong.
+
+## 8. Immediate TODO Before Submission
+
+1. Convert at least two public benchmark sources into AgentTrajectory.
+2. Produce a first 100-trace labeled set.
+3. Add an evaluation runner that outputs a single CSV/JSONL.
+4. Run rule, judge, All-at-Once, and DeepDebug on the same split.
+5. Add a small human/expert review with raw trace vs paired trace view.
+6. Trim main body to 6 pages while keeping appendix rich.

agentdebugx-0.2.2/docs/23_status_v0_2.md

@@ -0,0 +1,108 @@
+# 23 — Capability + Test Coverage Status (v0.2.2)
+
+A live audit of what's implemented, what's tested, and what's specced but
+not yet built. Pair this with [docs/15_roadmap.md](./15_roadmap.md), which is
+the forward-looking plan; this doc is the rear-view mirror.
+
+## 1. What ships in v0.2.2 (live on PyPI)
+
+| Layer | Module | Status | Tests |
+|---|---|---|---|
+| Trace IR | `agentdebug.models` | ✅ stable | round-trip + enum tests |
+| Storage | `agentdebug.storage` (JSONL + SQLite) | ✅ stable | round-trip + ctx-mgr |
+| Recorder | `agentdebug.recorder` (`AgentDebug`, `TraceSession`) | ✅ stable | record + analyze flow |
+| Rule analyzer | `agentdebug.analyzers.HeuristicAnalyzer` | ✅ stable | match + suggest |
+| Taxonomy | `agentdebug.taxonomy` (19 seed modes) | ✅ stable | get_mode + list |
+| Function instrumentation | `agentdebug.instrumentation.traced_tool` | ✅ stable | happy + raise |
+| Event bus | `agentdebug.events.EventBus` | ✅ stable | fan-out + auto-detach |
+| LLM client | `agentdebug.llm.OpenAICompatClient` | ✅ stable | mocked httpx + env |
+| LLM judge | `agentdebug.judges.LLMJudgeAnalyzer` | ✅ stable | scripted-LLM happy + silent |
+| Attribution | `agentdebug.attribution.HeuristicAttributor` | ✅ stable | first-finding + tiebreak |
+| Attribution | `agentdebug.attribution.AllAtOnceAttributor` | ✅ stable | mocked LLM + fallback |
+| Attribution | `agentdebug.attribution.StepByStepAttributor` | ✅ **new 0.2.2** | scripted-LLM + fallback |
+| Recovery | `agentdebug.recovery.ReflexionSuggestion` | ✅ stable | per-finding + empty |
+| DeepDebug | `agentdebug.deep.DeepDebugAnalyzer` | ✅ stable | full loop + silent LLM |
+| Cascade view | `agentdebug.traceback.format_traceback` | ✅ stable | cascade + step-order + ANSI + empty |
+| Detectors | `agentdebug.detectors.RepeatedToolCall / RepeatedState / StepCountLimit` | ✅ **new 0.2.2** | threshold + window + budget |
+| Hub bundle | `agentdebug.hub.Bundle / pack_bundle / unpack_bundle` | ✅ stable | round-trip |
+| Hub scrubber | `agentdebug.hub.Scrubber` | ✅ stable | 12 redactions + idempotent |
+| Hub backends | `LocalHubBackend`, `GitHubBackend`, `HuggingFaceBackend` | ✅ stable | local-bare-git + local |
+| Adapters | `agentdebug.adapters.raw` (`trace_loop`, `mark_step`) | ✅ stable | end-to-end + ctxvar |
+| Adapters | `agentdebug.adapters.langgraph.LangChainCallbackAdapter` | ✅ stable | gracefully degrades w/o dep |
+| Adapters | `agentdebug.adapters.otel.OTelExportAdapter` | ✅ stable | branch test |
+| Integrations | `agentdebug.integrations.claude_skill` | ✅ stable | skill-bundle write |
+| Integrations | `agentdebug.integrations.openhands` (microagent + bridge) | ⚠️ microagent stable; bridge needs live OpenHands | microagent YAML test |
+| CLI | `agentdebug.cli` (`analyze | judge | deep | list | show | hub | integrations | serve | doctor`) | ✅ stable | 12 subcommand smoke tests |
+| Local UI | `agentdebug.ui` (FastAPI + vanilla JS console) | ✅ stable | endpoint round-trip |
+
+**Test counts:** 60+ unit tests + 1 live-LLM smoke test, `mypy --strict` clean
+across 32 source files.
+
+## 2. Designed in docs, not yet implemented
+
+| Doc | Component | Why deferred | Realistic ship |
+|---|---|---|---|
+| [06_detectors.md](./06_detectors.md) | `trajectory_perplexity` (TrajAD) | needs token-level LM perplexity API or embedding model + baseline calibration | v0.3 |
+| [06_detectors.md](./06_detectors.md) | `topic_drift` (embedding cosine) | needs embedding client; consider reusing `OpenAICompatClient` `/embeddings` | v0.3 |
+| [06_detectors.md](./06_detectors.md) | LTL spec monitors | requires user-supplied spec or LLM-synthesized monitors; gated on RV research | v1.2 |
+| [07_attribution.md](./07_attribution.md) | `BinarySearchAttributor` (ddmin) | requires replayable environment; few frameworks expose it | v0.3 |
+| [07_attribution.md](./07_attribution.md) | `CounterfactualAttributor` | requires re-rolling agent actions; same replay constraint | v0.3 |
+| [07_attribution.md](./07_attribution.md) | `SBFLAttributor` (Tarantula/Ochiai) | needs corpus of passing + failing traces of same task; gated on Hub adoption | v0.4 |
+| [07_attribution.md](./07_attribution.md) | `DeltaDebugAttributor` (Zeller) | same replay constraint | v0.3 |
+| [07_attribution.md](./07_attribution.md) | `EnsembleAttributor` | trivial once 2+ heavy backends ship; awaits BinarySearch/Counterfactual | v0.3 |
+| [08_recovery.md](./08_recovery.md) | `SelfRefineLoop` | small but needs a generator-critic-refiner orchestration | v0.3 |
+| [08_recovery.md](./08_recovery.md) | `CriticRecoverer` | needs a verifier registry (search, code-exec, type-check) | v0.3 |
+| [08_recovery.md](./08_recovery.md) | `AutoManualRules` | needs persistent project manual + injection into next-run prompts | v0.3 |
+| [08_recovery.md](./08_recovery.md) | `LangGraphRewind` | depends on LangGraph checkpointer; ships when we have a real LangGraph user | v0.3 |
+| [08_recovery.md](./08_recovery.md) | `SagaRollback` | needs compensation registry on tool definitions; new schema | v0.3 |
+| [08_recovery.md](./08_recovery.md) | `MCTSBranchExploration` (LATS) | heavy; v2 feature | v2.0 |
+| [09_error_database.md](./09_error_database.md) | DuckDB analytical + Parquet archive | optional; Hub bundles already give per-project corpus | v0.3 |
+| [09_error_database.md](./09_error_database.md) | Vector similarity search | needs embedding model + index choice | v0.3 |
+| [10_taxonomy_induction.md](./10_taxonomy_induction.md) | TnT-LLM + BERTopic pipeline | needs ≥ 1k labeled traces to be useful | v0.4 |
+| [11_multimodal.md](./11_multimodal.md) | Screenshot/DOM capture, VLM judge | gated on multimodal user (Claude Computer Use / OpenAI CUA / OpenHands browser) | v1.1 |
+| [12_ui_dashboard.md](./12_ui_dashboard.md) | TUI (Textual) | low priority; CLI + web UI cover the use cases | v0.4 |
+| [12_ui_dashboard.md](./12_ui_dashboard.md) | VSCode extension | needs TS extension scaffolding | v1.0 |
+| [05_adapters.md](./05_adapters.md) | CrewAI, OpenAI Agents SDK, AutoGen, smolagents, LlamaIndex, DSPy, Pydantic-AI | each is ~150 LOC + conformance test; ship as users land | rolling |
+
+## 3. Implementation gaps surfaced by the audit
+
+The audit found one real bug and a handful of test gaps:
+
+1. **`agentdebug.hub.build_manifest` was used by the CLI but not re-exported** —
+   would have surfaced as `ImportError` for any user calling
+   `agentdebug hub push`. Fixed in 0.2.2 (`hub/__init__.py`) and locked in by a
+   CLI smoke test.
+2. **`cli.py` had 0% coverage** — every subcommand now has a smoke test that
+   exercises the argparse path; the LLM-required commands assert the
+   "missing credentials" exit code without hitting the network.
+3. **`instrumentation.py` (`traced_tool`) had 0% coverage** — happy and
+   exception paths now tested.
+4. **`llm.OpenAICompatClient.complete` had no test** — covered by a custom
+   `httpx.BaseTransport` that returns canned JSON without a network call.
+5. **`recovery.ReflexionSuggestion`** had only an indirect test from DeepDebug
+   examples; now has direct happy + empty tests.
+
+## 4. Coverage matrix (post-0.2.2)
+
+Run `PYTHONPATH=src pytest --cov=agentdebug --cov-report=term`. The two largest
+remaining gaps are deliberate:
+
+- `agentdebug.adapters.langgraph` — exercised only when `langchain_core` is
+  installed. The status-test verifies graceful degradation when it isn't.
+- `agentdebug.hub.backends.HuggingFaceBackend` — gated on `huggingface_hub`.
+  Round-tripping through real HF requires `HF_TOKEN`; covered by the local
+  bare-git test for the analogous push/pull flow.
+
+## 5. Acceptance gates for v0.3 (next minor)
+
+Before v0.3 ships, this doc should record green checkmarks for:
+
+- [ ] One replayable counterfactual attributor (`BinarySearchAttributor` is
+      the cheapest entry).
+- [ ] One tool-grounded recovery strategy (`CriticRecoverer`) wired against
+      a `Verifier` Protocol.
+- [ ] One additional framework adapter that goes through the full conformance
+      suite (CrewAI is the most-requested).
+- [ ] HuggingFace Hub round-trip live test (gated on `HF_TOKEN`).
+- [ ] Bench harness extended with one published-benchmark loader (Who&When
+      is the obvious first target — we already cite its method).

{agentdebugx-0.2.0 → agentdebugx-0.2.2}/docs/README.md

@@ -31,6 +31,8 @@ This `docs/` directory contains the full design specification.
 | 19 | [19_error_hub.md](./19_error_hub.md) | **Error Hub** — bundle format, Local / Git / HF backends, scrubbing |
 | 20 | [20_deep_debug.md](./20_deep_debug.md) | **DeepDebug** — iterative multi-turn analysis (plan → hypothesize → verify → refine) |
 | 21 | [21_integrations.md](./21_integrations.md) | **Claude Code Skill** + **OpenHands** microagent + EventStream bridge |
+| 22 | [22_industry_track_paper_eval_plan.md](./22_industry_track_paper_eval_plan.md) | EMNLP Industry Track writing strategy + benchmark / human-study evaluation plan |
+| 23 | [23_status_v0_2.md](./23_status_v0_2.md) | **Capability + test coverage status (v0.2.2)** — what's implemented, what's tested, what's specced but not built |
 
 Plus three **narrative** docs that pre-dated this engineering spec and are kept for paper-style framing:
 
@@ -45,7 +47,7 @@ Plus three **narrative** docs that pre-dated this engineering spec and are kept
 ## How to read this
 
 - **First-time reader:** start with [00_overview.md](./00_overview.md), then [02_architecture.md](./02_architecture.md), then [14_api_reference.md](./14_api_reference.md).
-- **Researcher / paper author:** read [01_literature_survey.md](./01_literature_survey.md), [03_taxonomy.md](./03_taxonomy.md), [07_attribution.md](./07_attribution.md), [10_taxonomy_induction.md](./10_taxonomy_induction.md).
+- **Researcher / paper author:** read [01_literature_survey.md](./01_literature_survey.md), [03_taxonomy.md](./03_taxonomy.md), [07_attribution.md](./07_attribution.md), [10_taxonomy_induction.md](./10_taxonomy_induction.md), and [22_industry_track_paper_eval_plan.md](./22_industry_track_paper_eval_plan.md).
 - **Framework integrator:** read [04_trace_schema.md](./04_trace_schema.md), [05_adapters.md](./05_adapters.md), [13_class_design.md](./13_class_design.md).
 - **UI / product:** read [12_ui_dashboard.md](./12_ui_dashboard.md), [09_error_database.md](./09_error_database.md).
 - **Runtime / agent UX designer:** read [17_claude_code_design_patterns.md](./17_claude_code_design_patterns.md), then [02_architecture.md](./02_architecture.md), [08_recovery.md](./08_recovery.md), and [14_api_reference.md](./14_api_reference.md).

{agentdebugx-0.2.0 → agentdebugx-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "agentdebugx"
-version = "0.2.0"
+version = "0.2.2"
 description = "Portable error analysis, tracing, and recovery framework for agentic AI systems. Import as `agentdebug`."
 authors = ["ULab @ UIUC <ulab@illinois.edu>"]
 license = "MIT"

{agentdebugx-0.2.0 → agentdebugx-0.2.2}/src/agentdebug/__init__.py

@@ -15,6 +15,16 @@ from agentdebug.attribution import (
     Attributor,
     Blame,
     HeuristicAttributor,
+    StepByStepAttributor,
+)
+from agentdebug.detectors import (
+    Detector,
+    DetectorConfig,
+    RepeatedStateDetector,
+    RepeatedToolCallDetector,
+    StepCountLimitDetector,
+    default_detectors,
+    run_detectors,
 )
 from agentdebug.events import DEFAULT_BUS, BusEvent, EventBus, EventSubscription
 from agentdebug.models import (
@@ -29,6 +39,7 @@ from agentdebug.models import (
 )
 from agentdebug.recorder import AgentDebug, TraceSession
 from agentdebug.recovery import FixProposal, Recoverer, ReflexionSuggestion
+from agentdebug.traceback import CascadeFrame, build_cascade, format_traceback
 from agentdebug.storage import JsonlTraceStore, SQLiteTraceStore
 from agentdebug.taxonomy import SEED_FAILURE_MODES, get_failure_mode
 
@@ -42,6 +53,17 @@ __all__ = [
     'Attributor',
     'Blame',
     'BusEvent',
+    'CascadeFrame',
+    'Detector',
+    'DetectorConfig',
+    'RepeatedStateDetector',
+    'RepeatedToolCallDetector',
+    'StepByStepAttributor',
+    'StepCountLimitDetector',
+    'build_cascade',
+    'default_detectors',
+    'format_traceback',
+    'run_detectors',
     'DEFAULT_BUS',
     'DiagnosticReport',
     'EventBus',
@@ -62,4 +84,4 @@ __all__ = [
     'get_failure_mode',
 ]
 
-__version__ = '0.2.0'
+__version__ = '0.2.2'