Ejecuta cualquier Skill en Manus
con un clic

Ejecuta cualquier Skill en Manus con un clic

$pwd:

temporal-test-crate

Name: Temporal Test Crate
Author: Pipelex

// Run and diagnose the LibraryCrate integration tests for Temporal. Tests that PipeSequence controllers execute on Temporal workers via LibraryCrate propagation, including concurrent isolation tests for conflicting concepts and pipes. Use when the user says 'test temporal crate', 'run crate tests', 'isolation tests', or wants to verify LibraryCrate on Temporal works.

Ejecutar en Manus

$ git log --oneline --stat

stars:678

forks:53

updated:4 de mayo de 2026, 10:07

SKILL.md

readonly

related-skills.json

mismo repositorio

temporal-e2e-validate.md

from "Pipelex/pipelex"

Full end-to-end validation of Temporal distributed execution (Phases 2-5 + v1 routing + v2 queue options / worker-runtime profiles). Two modes: (1) pytest against a real Temporal server for detailed assertions on all test cases, and (2) true 3-process setup (server + separate worker process + submitter) that validates the actual deployment topology including cross-process serialization, LibraryCrate propagation, deferred hydration, concurrent isolation, image payload storage, and cross-worker graph tracing with GraphSpec assembly. Step 8 validates v1 per-activity routing. Step 9 validates v2 per-queue submitter options (timeouts, retry, rate-limit), per-handle option overrides, named worker-runtime profiles selected via `--profile`, and the strict `--task-queue` CLI typo check with "did you mean?" suggestion. Mode 1 also folds in the error-handling suite (activity error boundary, workflow error-report full chain, local parity arm); Mode 2 Tiers 13-16 validate that a worker-side failure — from an LLM, extract,

2026-05-20678

update-graph-ui.md

from "Pipelex/pipelex"

Bump the pinned `@pipelex/mthds-ui` (and `elkjs`) version that the generated ReactFlow HTML loads from jsDelivr. Re-fetches the bundle, recomputes SRI hashes, and updates the Python constants in `standalone_assets.py`. Use when user says "update graph ui", "bump mthds-ui", "update graph viewer", "new version of mthds-ui", or any variation of updating the CDN-pinned graph viewer assets.

2026-05-13678

release.md

from "Pipelex/pipelex"

Automates the Pipelex release workflow: bumps the version in pyproject.toml, finalizes the CHANGELOG.md Unreleased section, runs quality checks, creates a release/vX.Y.Z branch, commits, pushes, and opens a PR to main. Use when user says "release", "cut a release", "bump version", "prepare a release", "make a release", "ship it", "create release branch", or any variation of shipping a new version of pipelex. The user can optionally provide changelog content inline when invoking the skill (e.g. "/release Added new extract backend"), which will be used as the changelog entry for this version.

2026-03-19678

add-model.md

from "Pipelex/pipelex"

Add a new AI model to the Pipelex inference system. Guides through all required steps: backend TOML configuration (OpenAI, Azure, Anthropic, Google, etc.), kit sync, test profile collections, and fixture regeneration. Use when the user says "add a model", "add GPT-X", "add Claude X", "new model", "register a model", "add Gemini X", "support model X", "add model to backend", or any variation of introducing a new AI model to the inference configuration. Also use when the user mentions a model name that doesn't exist in the backend configs yet and wants to add it.

2026-03-19678

test-model.md

from "Pipelex/pipelex"

Test an AI model on a specific backend using the Pipelex inference test infrastructure. Handles test profile creation, fixture regeneration, and running the right test class for the model type (LLM, image gen, extract, search). Use when the user says "test model X", "test gpt-5.4 on openai", "test model on gateway", "run inference test for model", "try model X on backend Y", "verify model X works", or any variation of running inference tests against a specific model on a specific backend. Also use when the user mentions testing a model after adding it, or wants to verify a model works end-to-end with real API calls.

2026-03-19678

package.json

"author": "Pipelex"

"repository": "Pipelex/pipelex"

Abrir repositorio de GitHub Ver repositorios del creador

$ install --global

$ download --local

Ejecutar en Manus

$ useful --forSOC

Analistas de garantía de calidad de software y probadoresOcupaciones informáticas y matemáticas15-1253L4

name	temporal-test-crate
description	Run and diagnose the LibraryCrate integration tests for Temporal. Tests that PipeSequence controllers execute on Temporal workers via LibraryCrate propagation, including concurrent isolation tests for conflicting concepts and pipes. Use when the user says 'test temporal crate', 'run crate tests', 'isolation tests', or wants to verify LibraryCrate on Temporal works.

Temporal LibraryCrate Integration Tests

Run the integration tests that verify LibraryCrate propagation and per-workflow isolation through Temporal workflows.

How to narrate the test run

Before running the tests, print a brief schematic explanation for the user so they understand what they're about to see. Use this narration:

What we're testing

These tests verify that LibraryCrate — the serializable snapshot of pipes, concepts, and dynamic classes — propagates correctly from the client to Temporal workers, and that concurrent workflows remain isolated from each other.

The components and how they interact:

Client (test fixture)                    Temporal Worker
─────────────────────                    ───────────────

1. Load .mthds bundle
2. Build LibraryCrate (pipes,
   concepts, fingerprint)
3. Build PipeJob with crate attached
4. Submit workflow ──────────────────►   5. WfPipeRouter.run() receives PipeJob
                                         6. load_from_crate() → registers pipes
                                            into a scoped Library (ContextVar)
                                         7. Dynamic concept classes generated
                                            into a scoped ClassRegistry (ContextVar)
                                         8. WorkingMemory hydrated (deferred)
                                         9. PipeSequence executes child pipes
                                            via get_required_pipe() from the
                                            scoped library
                                         10. PipeOutput returned to client

The 5 test suites (19 tests total):

Suite	What it proves	Key risk if broken
TestWfLibraryCrate (5 tests)	Crate structure is valid, PipeSequence runs end-to-end via Temporal, both `library_dirs` and `mthds_content` loading paths work. Includes a negative test (`test_missing_crate_fails_pipe_resolution`) that verifies a PipeJob without a crate correctly fails.	Pipes can't resolve on worker
TestWfDeferredHydration (2 tests)	Dynamic concept classes (e.g. `Greeting`) are generated on the worker from crate data, WorkingMemory is hydrated after class registration, StructuredContent fields are accessible.	`KajsonDecoderError: Class not found`
TestWfConcurrentConceptIsolation (4 tests)	Two workflows define conflicting `Result` concepts (different fields) and run simultaneously on one worker. Per-workflow ClassRegistry scoping keeps them isolated. Repeated 5x to catch races.	Silent data corruption — wrong fields
TestWfConcurrentPipeIsolation (4 tests)	Two workflows define conflicting `shared_step` pipes (different prompts) and run simultaneously. Per-workflow Library scoping ensures each resolves its own pipe. Repeated 5x.	Wrong pipe executed silently
TestWfMultiConceptIsolation (4 tests)	Worst case: two workflows each define `Profile` AND `Summary` with incompatible structures. 6 concurrent workflows stress-test ContextVar scoping.	Multiple classes cross-contaminate

After running the tests, report results with a summary table showing pass/fail per suite.

Run the tests

Step 1: Dry run (default)

Always start with dry mode — fast, no API calls:

.venv/bin/pytest -x -v -s tests/integration/pipelex/temporal/library_crate/ -m temporal

To run only the isolation tests:

.venv/bin/pytest -x -v -s tests/integration/pipelex/temporal/library_crate/ -m temporal -k "Concurrent or Multi"

Step 2: Live run (optional)

After a successful dry run, ask the user if they want to run in live mode. Live mode makes real LLM API calls and exercises realistic concurrency timing — it's the closest thing to production behavior:

.venv/bin/pytest -x -v -s tests/integration/pipelex/temporal/library_crate/ -m temporal --pipe-run-mode live

When reporting live-mode results, show:

Pass/fail per test with the test name
For passing tests, confirm that structured outputs had the expected fields (e.g. "Alpha Result had score + label", "Beta Result had value + confidence + is_valid")
For concurrent tests, confirm that both workflows returned correct results simultaneously
Total wall-clock time (live mode is slower due to real API calls)

Expected warnings in test output

test_missing_crate_fails_pipe_resolution is a negative test — it intentionally submits a PipeJob without a LibraryCrate and asserts that WorkflowFailureError is raised. During this test, Temporal logs a WARNING Failed activation on workflow with a full traceback ending in RuntimeError: No current library set. This is expected behavior, not a failure. The test passes (PASSED) because the expected error was correctly raised.

Prerequisites

# Verify venv and temporalio
.venv/bin/python -c "import temporalio; print(f'temporalio {temporalio.__version__}')"
# Verify test bundles exist
ls tests/integration/pipelex/temporal/library_crate/*.mthds

Interpreting failures

Error	Cause	Action
`PipeNotFoundError` on worker	LibraryCrate not loaded or not propagated	Check `WfPipeRouter.run()` loads crate; check `library_crate` is set on PipeJob
`KajsonDecoderError: Class 'X' not found`	Dynamic concept classes not registered on worker	Check deferred hydration path in `WfPipeRouter.run()`
`RuntimeError: Failed decoding arguments`	Temporal can't deserialize PipeJob	Check Kajson data converter; may be a serialization issue with LibraryCrate
`WorkflowFailureError` wrapping `TemporalError`	Pipe execution failed on worker	Read the inner error — it's the real cause
Fixture setup error in `pipe_job_from_*`	Library loading failed before Temporal dispatch	Check bundle file exists and is valid MTHDS
`AssertionError: StructuredContent missing field`	ClassRegistry scoping failed — wrong class used	Per-workflow ContextVar is leaking; check `set_current_library` / `teardown_current_library`
`AssertionError` in repeated/high-concurrency tests	Intermittent ContextVar race condition	Scoping mechanism has a race under load

Interactive debugging

For tmux-based 3-terminal debugging (server + worker + submitter), use the /temporal-e2e-validate skill (Mode 2) instead.

Test files

File	Purpose
`tests/integration/pipelex/temporal/library_crate/test_wf_library_crate.py`	Single-workflow crate propagation (native Text concepts)
`tests/integration/pipelex/temporal/library_crate/test_wf_deferred_hydration.py`	Deferred hydration with dynamic concept (Greeting)
`tests/integration/pipelex/temporal/library_crate/test_wf_concurrent_concept_isolation.py`	Two workflows with conflicting 'Result' concepts
`tests/integration/pipelex/temporal/library_crate/test_wf_concurrent_pipe_isolation.py`	Two workflows with conflicting 'shared_step' pipes
`tests/integration/pipelex/temporal/library_crate/test_wf_multi_concept_isolation.py`	Worst-case multi-class conflicts (Profile + Summary)
`tests/integration/pipelex/temporal/library_crate/conftest.py`	PipeJob fixtures with LibraryCrate for all scenarios
`tests/integration/pipelex/temporal/test_data.py`	Test constants for all scenarios

Bundle files

Bundle	Domain	Concepts	Pipes
`native_text_sequence.mthds`	`native_text_test`	(native Text only)	native_text_sequence, step_one, step_two
`dynamic_concept_sequence.mthds`	`dynamic_concept_test`	Greeting(message, language)	dynamic_greeting_sequence, generate_greeting, summarize_greeting
`conflict_concept_alpha.mthds`	`conflict_alpha`	Result(score, label)	alpha_pipeline, alpha_generate, alpha_summarize
`conflict_concept_beta.mthds`	`conflict_beta`	Result(value, confidence, is_valid)	beta_pipeline, beta_generate, beta_summarize
`conflict_pipe_alpha.mthds`	`pipe_conflict_alpha`	(native Text only)	pipe_alpha_pipeline, shared_step, alpha_finalize
`conflict_pipe_beta.mthds`	`pipe_conflict_beta`	(native Text only)	pipe_beta_pipeline, shared_step, beta_finalize
`multi_concept_alpha.mthds`	`multi_alpha`	Profile(name, age), Summary(headline, body)	multi_alpha_pipeline, generate_profile, generate_summary, finalize
`multi_concept_beta.mthds`	`multi_beta`	Profile(title, department, level), Summary(content)	multi_beta_pipeline, generate_profile, generate_summary, finalize

temporal-test-crate

Más de este repositorio

Temporal LibraryCrate Integration Tests

How to narrate the test run

What we're testing

Run the tests

Step 1: Dry run (default)

Step 2: Live run (optional)

Expected warnings in test output

Prerequisites

Interpreting failures

Interactive debugging

Test files

Bundle files

Temporal LibraryCrate Integration Tests

How to narrate the test run

What we're testing

Run the tests

Step 1: Dry run (default)

Step 2: Live run (optional)

Expected warnings in test output

Prerequisites

Interpreting failures

Interactive debugging

Test files

Bundle files

Más de este repositorio