Przejdź do treści
Biblioteka skilli
AI i agenci · Analiza

procept-lite

/procept-lite

Zamienia logi agentów z LangSmith, Logfire lub OpenTelemetry w mapę błędów z kosztem i opóźnieniem oraz jednostronicową kartę wyników.

Repozytorium
procept-lite ↗
Licencja
MIT
Ostatnia zmiana repozytorium
10.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
15
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 10.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Zamienia logi agentów z LangSmith, Logfire lub OpenTelemetry w mapę błędów z kosztem i opóźnieniem oraz jednostronicową kartę wyników.

Wyzwalacze z opisu

build the CIGwhy is my agent failing
Oryginalny opis (EN)

Turn exported agent logs (LangSmith, LangChain, Pydantic Logfire, OpenTelemetry, GCP, AWS, Azure) into cig.html, a failure network over errors, cost, latency and score, plus scorecard.html, a one-page scorecard, in one action, with every stage checked against the real data by a smart model. Use for agent traces, "build the CIG", "why is my agent failing", grading agent runs good/ambiguous/bad, cost and latency of agents, scorecard.

Jak działa

  1. How it works
  2. Rules
  3. The loop
  4. The NEXT steps
  5. Finish (NEXT: done)
  6. Questions are allowed only when
  7. References
Sekcje z nagłówków SKILL.md, w oryginale · 80 linii, 1 382 słów
Podgląd SKILL.md
---
name: procept-lite
description: Turn exported agent logs (LangSmith, LangChain, Pydantic Logfire, OpenTelemetry, GCP, AWS, Azure) into cig.html, a failure network over errors, cost, latency and score, plus scorecard.html, a one-page scorecard, in one action, with every stage checked against the real data by a smart model. Use for agent traces, "build the CIG", "why is my agent failing", grading agent runs good/ambiguous/bad, cost and latency of agents, scorecard.
---

# procept-lite

Scripts run as `python3 ${CLAUDE_PLUGIN_ROOT}/scripts/plite.py <cmd> --out <OUT>` (`<OUT>` defaults to `./procept-out`; reuse it). Below, `plite.py` means that command.

## How it works
- The scripts, templates and prompts in this plugin are **starters**: read them, copy what you need, edit it for this dataset. The architecture and the file contracts stay: raw export, `mapping.json`, `normalized/runs.jsonl`, grading shards, `scores.csv`, `cig/`, a temporary study, then `cig.html` and `scorecard.html`. If a starter must change for this data, copy the plugin folder into `<OUT>/work/` and run every command from the copy, so all steps agree.
- Code computes numbers and validates. Models judge reality and write words. Each stage is checked against the real data by a smart model and signed off before the next stage may use it.
- **Model floor** for every judgement step (mapping rescue, verification, grading, study, problem write-up): Sonnet 5.5 (`claude-sonnet-5-5`) or GPT 5.6 Terra, or better. Never Haiku. If you are a smaller model, delegate each judgement step to one of those: Workflow tool or Agent tool with `model: "sonnet"`, in the background and in parallel (a GPT host uses GPT 5.6 Terra).
- The unit is the RUN (one agent call); a conversation holds several runs. Never aggregate before scoring.
- The user gets exactly two files, `cig.html` and `scorecard.html`. The study is temporary and is deleted.

## Rules
- Everything is local. Never send data anywhere. Never echo secrets, tokens or emails from the data. Graders never see vendor scores or evaluator labels.
- Correct and small beats big and noisy. A smaller verified sample, with the rest classified unusable, is better than noise in the eval set. Never pad it.
- Customer-facing files never contain repair, drop, fix, mistake or error-admission wording, statistics jargon, internal paths, check records, placeholders or blank cells. If something would look wrong, fix it at the source; never annotate it.
- Show what the data shows, flattering or not. Code computes every number; never adjust one by hand.
- If you find a mistake of your own, fix it, verify again and do not mention it again. If something is unfixable or unverifiable, say so in ONE plain line.
- Never ask the user to fix data by hand. Never stop on a missing field: unmap it (that dimension is left out) or classify the affected runs unusable.

## The loop
Plan in at most two sentences, then proceed without waiting. Example: "I will map your export into runs, check every stage against the real data, grade up to 300 runs and build cig.html and scorecard.html. It all runs locally on static files and changes nothing in your systems."

`plite.py run --src <paths...> --out <OUT> [--sample 300]` (paths: files, folders, zips; the user may ask for a bigger sample). It does the next code step it can and ends with ONE line `NEXT: <step> | <instruction>` (also in `<OUT>/status.json`). Do that step with a floor-model agent (below), then run the same command again, until `NEXT: done`. `plite.py status --out <OUT>` shows each sign-off as verified, stale, failed or missing.

A sign-off is a JSON record, written with `plite.py check record --out <OUT> --file rec.json`:
`{"stage": "ingest|merge|cig|study|scorecard", "model": "<your own exact model id>", "verdict": "pass|fail", "checked": 40, "mismatches": 0, "notes": "one or two plain sentences", "evidence": [{"id": "<run id or item>", "finding": "what you saw; 5 or more, all different"}], "unusable": [{"run_id": "...", "reason": "..."}] (ingest only), "overridden": 0 (merge only)}`.
The code refuses a record that is below the floor, too small, or has too many mismatches. Any later change to what it covers makes it stale, so record last. Sampling, evidence, pass and fail per stage: `references/stage-signoffs.md`.

## The NEXT steps
Workflows are plain scripts in `${CLAUDE_PLUGIN_ROOT}/workflow/`, run with the Workflow tool (`model: sonnet` inside). Every one takes `out` and `root: "${CLAUDE_PLUGIN_ROOT}"`. With no Workflow tool, follow the fallback recipe named for each step.

**mapping_rescue** (no `mapping.json`; `run` scaffolded `<OUT>/mapping_rescue/`)
- Do: `mapping.js` with `{out, src: [<the paths>], root}`; it also covers `ingest_verify`. Fallback: `references/ingest-checks.md`, section 5.
- Check: ALWAYS, even if the draft looks right. The agent reads the scaffold and the raw rows themselves and decides every field's role from values, not column names.
- Writes: `<OUT>/mapping.json` (shape of `templates/mapping.example.json`) with `"_rescue": {"model", "rows_reviewed", "notes"}`.
- If it fails: `run` refuses without a valid mapping and says why; fix the mapping and run again.

**ingest_verify** (mapping applied, `normalized/runs.jsonl` built, not signed off)
- Do: the same workflow; add `only: "verify"` when `mapping.json` already exists.
- Check: at least 30 normalized runs (all if fewer), spread across the file, against their raw rows: roles, swaps, units, identity, tools, leaks, mixed sources, real no-answers (`references/ingest-checks.md`).
- Records: stage `ingest`, with `unusable` listing every run that cannot be trusted. Those are never graded or counted.
- If it fails: fix the mapping, normalize again, check a fresh sample; two repair rounds at most. What still cannot be verified becomes unusable. If almost nothing is usable, say so in one plain line and stop.

**grade** (`grade-prepare` wrote shards and `<OUT>/grading/workflow_args.json`)
- Do: read `<OUT>/grading/cost_estimate.json`, state the estimate in one line, proceed. `grade.js` with the contents of `workflow_args.json` as args. Fallback: `references/grading-brief.md`.
- Check: blind readers grade every run from its own evidence (`references/grading-brief.md`). Persona labels are provisional goal labels; the study re-derives the final personas.
- Records: nothing; `merge_verify` signs off. If it fails: `grade-merge` names invalid or missing shards; re-run only those (`grade-merge --resume` writes the args).

**merge_verify** (`grade-merge` wrote `scores.csv`)
- Do: `verify.js` with `{out, stage: "merge", root}`. Fallback: `references/stage-signoffs.md`, last section.
- Check: at least 40 graded runs (all if fewer) plus every risky row (quote not found, audit disagreement, low confidence), against the run's own tool results and answer.
- Records: stage `merge`. Each wrong score goes to `<OUT>/grading/overrides.csv`, then `grade-merge` applies it; `overridden` counts them.
- If it fails (more than 15 percent wrong): the grading itself is off. Fix `<OUT>/grading/brief.md`, re-run the affected shards, merge, verify a fresh sample.

**cig_verify** (`cig/` built)
- Do: `verify.js` with `{out, stage: "cig", root}`.
- Check: tools, edges and run rows recounted independently from the runs and scores; node names are real tools; no unusable run inside; summary, flow graph and CSVs agree.
- Records: stage `cig`. If it fails: fix the cause (the mapping, or a starter), run `plite.py run`, verify again.

**study** (`study-init` copied the starters to `<OUT>/study/`; temporary)
- Do: `study.js` with `{out, root}`. Agents edit the starter sections for this data (Exploratory Data Analysis, Reward Signal, Affinity Diagram, Empathy Map, Impact), then one agent writes `<OUT>/scorecard_inputs/user_goal_problem.json`, validated by `plite.py report --validate-problem`. Fallback: `references/stage-signoffs.md`, last section.
- Check: numbers recomputed from `cig/` and `scores.csv`, quotes verbatim, screenshots looked at, the problem's runs read and found to share one real goal.
- Records: stage `study`. If it fails: rebuild the failing section from its starter, rewrite the problem until it validates, verify again.

**scorecard_verify** (`run` built both pages and deleted the study)
- Do: `verify.js` with `{out, stage: "scorecard", root}`.
- Check: every number on the page against `scorecard.json` and `cig/summary.json`; both pages opened in headless Chrome at 1280px and 390px; no forbidden wording; the `cig.html` tabs, panel and blurred names behave as `references/stage-signoffs.md` says.
- Records: stage `scorecard`. If it fails: fix at the source (the data, the problem file, `<OUT>/system5.json`, a copy of the template saved as `<OUT>/scorecard.template.html`), run `plite.py run`, verify again. Never patch the HTML by hand.

## Finish (`NEXT: done`)
Reply in two or three lines: the paths of `<OUT>/cig.html` and `<OUT>/scorecard.html`, and how many runs were graded. Nothing about repairs, exclusions, drops, fixes, sign-offs or models. Add one plain line only if something is unfixable or unverifiable, for example a dimension this export does not carry. No homework.

## Questions are allowed only when
- There is no data yet: ask which platform (LangSmith, Logfire, GCP, AWS, Azure, other OTel) and give `references/exports/<platform>.md`.
- Truly blocked: the input is empty or unreadable, or almost nothing survives verification. Say in one line what is missing and which export would fix it.

## References
`references/stage-signoffs.md` (what each verifier checks, the record, pass and fail), `ingest-checks.md` (mapping rescue, checks, unusable), `grading-brief.md`, `exceptions.md` (odd exports), `data-gaps.md` (what each field is for), `report.md` (the two deliverables), `concepts.md` (plain-words explanation; only if asked), `exports/` (platform walkthroughs).
Pliki w paczce (15)
  • SKILL.md 10 KB
  • references/concepts.md 4 KB
  • references/data-gaps.md 6 KB
  • references/exceptions.md 7 KB
  • references/grading-brief.md 5 KB
  • references/ingest-checks.md 11 KB
  • references/report.md 3 KB
  • references/stage-signoffs.md 17 KB
  • references/exports/aws.md 2 KB
  • references/exports/azure.md 2 KB
  • references/exports/gcp.md 2 KB
  • references/exports/langchain-langsmith.md 2 KB
  • references/exports/opentelemetry-generic.md 2 KB
  • references/exports/other-frameworks.md 1 KB
  • references/exports/pydantic-logfire.md 2 KB

Wersje

W bazie nie ma innych skilli o nazwie procept-lite.

Migawka bazy z 13.11.2026 · wersja paczki aa5158c61ec5 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100langsmith-fetch
    Debuguje agentów LangChain i LangGraph, pobierając ślady wykonania z LangSmith Studio i analizując błędy, wywołania narzędzi, operacje pamięci i wydajność, przy użyciu CLI langsmith-fetch.
  • 100pydantic-ai
    Obejmuje framework agentów Pydantic AI w Python: typowane narzędzia, dostawcy modeli, ewaluacje, MCP, adaptery UI i obserwowalność z Logfire.
  • 100logfire-coding-agents
    Podłącza Claude Code lub Codex do telemetrii Logfire albo kieruje zapytania modelowe agenta przez Pydantic AI Gateway: nagrywanie sesji, polityki przechwytywania, konfiguracja Gateway, tymczasowe proxy, status i usuwanie.
  • 100logfire-infrastructure
    Monitoruje hosty, kontenery Docker, klastry Kubernetes, serwery baz danych, kolejek i cache oraz metryki chmury (AWS, GCP) w Pydantic Logfire bez zmian w kodzie aplikacji.
  • 100langsmith
    Śledzi, ewaluuje i wdraża agentów AI oraz aplikacje LLM w LangSmith: obserwowalność, ewaluacje, inżynieria promptów i wdrożenia produkcyjne.
  • 95agent-observability
    Śledzi rozumowanie agentów AI: ślady, OpenTelemetry, dziennik decyzji, czasy odpowiedzi i koszty tokenów w działaniu.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.