procesio-cli 0.1.1__py3-none-any.whl

procesio_cli/skills/procesio-cli/references/process-debugging.md

@@ -0,0 +1,65 @@
+# Process debugging
+
+## Goal
+
+Explain a failed, silent, hanging, duplicated, or semantically wrong process outcome from runtime evidence, then apply the smallest verified correction if authorized.
+
+## Preconditions
+
+- Obtain environment, workspace, process ID, instance ID or failure window, expected outcome, and whether diagnosis is read-only.
+- Confirm the credential profile can read the process and instances.
+- Preserve failing inputs and evidence before editing or rerunning.
+
+## Inspect
+
+1. Fetch process design, input schema, activation, and dependencies.
+2. Read the target instance status, variables, outputs, error details, timestamps, and child-instance references.
+3. Inspect the flow graph and designer/runtime parity.
+4. Follow the observed boundary: browser diagnostics for forms, SQL query for persistence, file inspection for documents, or API/custom-action test for integrations.
+5. Consult the generated PROCESIO usage guide when a successful status produced no visible outcome.
+
+For stale loop values, trace **original item → intermediate variable → native mapping →
+persisted row** from the existing instance and exact-key reads before proposing another run.
+Check field presence separately from its value; false, zero and null must not disappear
+through a truthiness fallback. If the verifier shares the same intermediate as the writer,
+compare against original input independently. A final action status may describe only the
+last loop iteration, not every earlier INSERT/UPDATE. Keep executed effects separate from
+failed business proof. Use `references/data-verification.md` for transition-sensitive tests.
+
+## Preview and approval
+
+Form a falsifiable root-cause statement tied to evidence. Before changing the process, show:
+
+- failing node or boundary;
+- input/state that triggers it;
+- proposed minimal change;
+- expected new observation;
+- retry or duplicate-side-effect risk.
+
+Diagnosis is not authorization to edit or rerun.
+
+## Execute
+
+- Add a focused reproduction or controlled input where possible.
+- Change one cause, not several symptoms.
+- Use native validation and a dry-run/DTO preview before save.
+- Re-run only after reconciling whether the earlier attempt committed external effects.
+
+## Verify
+
+- The original reproduction now reaches the expected final status and output.
+- A neighboring/edge input still behaves correctly.
+- External side effects occur exactly once.
+- Browser, database, file, or integration diagnostics are clean at the affected boundary.
+- Static audit introduces no new secret, mapping, or error-handling issue.
+
+## Recovery and cleanup
+
+Keep the failed instance and compact diagnostic evidence. Cleanup, trigger deactivation,
+restoration and any additional test are mutations: perform them only within explicit
+approved scope. Do not automatically restore or replay after a correction fails; reconcile
+its actual effects and prepare the narrow missing proof or corrective action.
+
+## Evidence
+
+Report observed symptom, root cause, evidence chain, changed resource/version, before/after run IDs, direct proof, and remaining uncertainty. Distinguish confirmed cause from plausible hypothesis.

procesio_cli/skills/procesio-cli/references/process-lifecycle.md

@@ -0,0 +1,88 @@
+# Process lifecycle
+
+## Goal
+
+Create or change one PROCESIO process and prove both its saved design and representative runtime behavior.
+
+## Preconditions
+
+- Identify environment, workspace ID, credential profile, process ID for edits, representative input, and expected outputs/side effects.
+- Run readiness/auth checks and resolve the process by stable ID.
+- Use the `procesio` agent for a full build-and-test outcome. Use a narrow `procesio` tool action only for one explicit read or edit.
+
+## Inspect
+
+1. Read agent guidance for the current build/test doctrine.
+2. Fetch the existing process and input payload shape when editing or running.
+3. Inspect dependencies: data models, credentials, child processes, documents, webhooks, schedules, forms, and custom actions.
+4. Record activation state and a compact before-state.
+5. Before editing a process used by a form, webhook, schedule, or child process, snapshot its public variable IDs, types/directions, custom-response contract, and every dependent mapping. A seemingly additive output or response change can orphan callers.
+
+## Preview and approval
+
+- Build or edit through the structured process DTO path; use dry-run/validation before save when available.
+- Inspect the generated action graph, mappings, branches, error ports, and output variables.
+- Treat create, edit, activation, run, duplicate, import, and delete as mutations. Cross the MCP confirmation boundary only after the target and blast radius are explicit.
+- If the create DTO is active by default, state that explicitly. Confirm whether any attached webhook, schedule, form event, or other trigger could launch it autonomously. An active process with no trigger still requires approval to run, but it has no autonomous launch path.
+- State whether a representative top-level run can create child or nested instances and include those in the execution budget.
+
+Check catalog input-port/output-port declarations against every convergence, backward edge
+and error path **before freezing** a graph. Use supported Join semantics where appropriate;
+a Join is not a universal loop repair. Validate the composed DTO and later prove actual
+execution. A frozen incompatible graph requires an explicit versioned amendment, not a
+silent redesign. Preserve runtime/designer bindings, including nested attribute paths.
+
+### Sensitive API responses: gate before acquisition
+
+For scanners, exports or integrations, locate the **first persistence boundary**: API response
+variables, action/instance diagnostics, child-agent stdout and coordinator logs may retain
+values before downstream hashing or redaction. Read-only access does not make a saved
+configuration non-sensitive. Retention deletion after execution cannot prove non-exposure.
+
+Before retrieving potentially sensitive configurations, require implementation evidence of
+pre-persistence suppression/redaction or a separately approved isolated synthetic canary
+experiment covering success, error and diagnostic paths. Never use real secrets as probes.
+If that boundary is unproved, keep runtime acquisition blocked. An inactive creation preview
+may still be reviewed separately, but does not authorize activation or a scan; ensure the
+creation path cannot auto-execute. Offline checks/non-saving validation do not clear this gate.
+
+## Execute
+
+- Save one coherent process version.
+- Validate it at the source platform.
+- Apply layout or action-name cleanup only when it does not change behavior.
+- Preserve existing public input/output IDs and direct-caller response semantics when the process has dependents. When a new envelope is needed for one caller type, add it compatibly rather than replacing an established output contract.
+- Execute the representative payload **exactly once**. Prefer the `procesio` agent verification path with `--run` because it validates, audits parity, runs, and reads instance status in one operation.
+- Do not also call `run-process` before or after `verify --run` merely to obtain the same proof. If a representative run was already launched, inspect that instance directly and run non-executing validation/audit checks instead.
+- Do not blind-retry a timed-out run; reconcile instances first.
+
+## Verify
+
+Minimum proof:
+
+1. Re-fetch the process and compare the saved design with the intended DTO/graph.
+2. Re-fetch every dependent form/process/trigger mapping after a public-interface edit and prove no variable ID or response contract was orphaned.
+3. Use one execution path only:
+   - preferred: `procesio` agent `verify --run`, then use the returned instance ID for output inspection; or
+   - direct `run-process` once, followed by explicit instance-status/output reads and a non-running audit.
+4. After a successful `verify --run`, call `get-instance-output` directly with the returned instance ID and process ID. Do not add `list-instances` as routine confirmation when the instance ID is already known; reserve it for a missing ID, timeout/unknown outcome, or reconciliation.
+5. Read the real instance status, inputs, outputs, and error details. Status alone is not proof of the expected output value.
+6. When the process calls subprocesses, capture the complete parent/child tree needed for the claim. Distinguish one external submit/run from the number of process instances it created.
+7. Verify external effects at their boundary: database row, generated file, API result, email sink, or child instance.
+8. Run the static audit for secrets, missing error handling, inefficient patterns, and designer/runtime mismatch.
+
+Validation alone does not pass this playbook. Two successful executions are not stronger evidence when one representative execution and direct output inspection prove the same claim.
+
+## Recovery and cleanup
+
+- Validation failure: correct the DTO or mappings before another save.
+- Unknown run outcome: list/reconcile instances by process and time before rerunning.
+- Failed required field outcome: preserve the original report and successful evidence. Use a separately approved bounded remediation for only the missing path; do not rerun successful side-effecting claims for cosmetic proof.
+- Failed test mutation: reconcile actual effects and obtain approval for any restoration or follow-up corrective edit; do not delete evidence before recording the failure.
+- Treat approved safety containment separately from fixture deletion: after target/effect reconciliation, disabling temporary execution paths and verifying their state does not depend on successful output decoding. If not already authorized, preview the exact action and obtain separate approval; report any active-state risk while waiting.
+- Preserve needed evidence before evidence-destroying cleanup. Do not delete a process, instance history or fixture merely to hide a failed check. Safety state and business-output acceptance are separate results; verify and report both.
+- For a disposable smoke test, delete the process only after its process ID, instance ID, validation result, runtime status, and expected output have been captured. Re-list the workspace to prove cleanup.
+
+## Evidence
+
+Return environment/workspace/process/instance IDs, parent/child execution counts, validation result, runtime status, relevant outputs or side-effect proof, dependent-caller compatibility, audit findings, cleanup result, and any manual production check still open.

procesio_cli/skills/procesio-cli/references/schedules-webhooks.md

@@ -0,0 +1,58 @@
+# Schedules and webhooks
+
+## Goal
+
+Create or change a time/event trigger and prove that its saved configuration launches the intended process exactly as designed.
+
+## Preconditions
+
+- Identify workspace, target process ID, trigger ID for edits, payload mapping, timezone, recurrence/event contract, activation state, concurrency/idempotency policy, and test window.
+- Confirm the target process validates and can run with a controlled payload before attaching an automatic trigger.
+- Determine whether any schedule process input is sensitive. Literal `processInputs` values may be persisted and returned unmasked by schedule reads; prefer a named credential, secret-store reference, or runtime lookup when the architecture supports it. Before any potentially sensitive schedule read (including the initial fetch), verify in the installed local help/schema that `get-schedule --redact-process-inputs` is available. If absent, stop and request an approved safe projection before acquisition; never silently fall back to raw output.
+- For a webhook, determine the live payload-binding granularity before designing the target process. A generated webhook body is a typed model object; do not assume the platform can fan its fields directly into several primitive process inputs.
+
+## Inspect
+
+1. After the pre-acquisition checks above, fetch existing schedule/webhook, target process, notifications, activation, timezone/recurrence, and recent related instances.
+2. Check duplicate or overlapping triggers and downstream rate/concurrency limits.
+3. For a schedule with non-empty process inputs, use `get-schedule --redact-process-inputs` for ordinary inspection and evidence. Use the raw mode only when exact values are strictly needed, the observation boundary is protected, and the exact sensitive acquisition is explicitly approved; treat that result as secret-bearing. Raw mode is not a compatibility fallback for missing redaction support.
+4. For webhooks, inspect authentication/signature expectations, sample body, generated body model and attribute IDs, response behavior, replay handling, secret exposure, and the exact `WebhookVariableDto`/attachment shape.
+5. Inspect the complete process tree the trigger can create. One delivery may create a trigger-target instance plus awaited child and nested instances.
+
+## Preview and approval
+
+- Prefer creating schedules disabled and webhooks unattached/unshared until configuration review.
+- Show next run times in an absolute timezone, target process, redacted payload shape, notification recipients, and public endpoint exposure.
+- Enabling, sharing, invoking, updating, or deleting a trigger is a mutation requiring the exact target to be approved.
+- Predeclare one stable event/business key, one launch window, the maximum trigger deliveries, and the full parent/child instance budget.
+
+## Execute
+
+- Save the trigger once and re-fetch it through the redacted mode when process inputs are present.
+- For a schedule, enable only for an agreed controlled occurrence or invoke the underlying process separately before enablement.
+- Do not place a long-lived or broad credential in literal schedule inputs when a reference-based design is available. When a literal secret is temporarily unavoidable, use a dedicated least-privilege rotatable value, stage the payload through a protected `@file`, restrict schedule readers, and never echo the raw read DTO.
+- For a webhook, launch with a signed/controlled sample using the intended content type and headers.
+- Bind a webhook's generated body to one compatible model-typed process input. When the retained target exposes primitive inputs, use a bounded adapter process that accepts the whole body, extracts attributes deterministically, and calls the retained target through plain variables. Do not repeat a failed per-field primitive mapping.
+- Keep a test adapter temporary unless it is part of the reviewed architecture. Bind scripting Error outputs, use nonzero timeouts, and preserve the retained target's public variable IDs.
+- Do not blind-retry a webhook request after an unknown response; reconcile by event/business ID and time window.
+
+## Verify
+
+- Saved recurrence/timezone or webhook schema/auth settings match intent.
+- Exactly one expected delivery is associated with the controlled event/window.
+- The complete trigger-target/child instance tree is reconciled; inputs, final statuses, outputs, notifications, and external side effects are correct.
+- For a schedule-secret claim, account for both the protected source and the platform-side schedule copy. A clean local-file sweep does not prove the schedule definition or an external transcript is clean.
+- For a webhook, prove the model object reached the intended model-typed input or adapter, the extracted primitive values are correct, and the final business-key side effect exists exactly once. An attached DTO plus a never-started instance is not a passing mapping test.
+- Duplicate delivery, missed run, clock/DST, overlap, and disabled-state behavior are covered where material.
+
+## Recovery and cleanup
+
+On unexpected firing, duplication, or payload mismatch, reconcile target/effects and promptly perform the exact approved containment (disable trigger or revoke test access), then re-read its state. If not covered, request separate approval and report the active risk. Containment must not wait for successful output decoding. Preserve event IDs and instance evidence before authorized fixture deletion; never treat shared production triggers as test cleanup. Apply the containment/evidence separation in `references/process-lifecycle.md`.
+
+After a schedule input appears in a transcript, log, screenshot, or retained artifact, treat it as disclosed rather than merely redacting the local copy. Rotate it and reconcile every dependent process hash, schedule input, and protected source before claiming recovery.
+
+For a temporary webhook adapter, detach the webhook first, revalidate retained processes, delete the webhook and adapter, then prove zero matching public endpoints, adapter processes, and live references to the generated webhook model remain.
+
+## Evidence
+
+Return trigger/process IDs, generated webhook model and relevant attribute IDs, absolute test time or event ID, saved configuration summary, activation state, delivery count, full parent/child instance tree, side-effect proof by stable business key, adapter cleanup, and recurrence/replay scenarios not yet exercised. Redact every literal schedule input value; record only variable identifiers, value presence/type, and the separate protected source or credential reference.

procesio_cli/skills/procesio-cli/references/transport-environments.md

@@ -0,0 +1,53 @@
+# Transport and environments
+
+## Goal
+
+Move selected PROCESIO resources between workspaces or installations without leaking secrets, overwriting the wrong target, or declaring success before dependency verification.
+
+## Preconditions
+
+- Identify source/destination installations, workspace IDs, credential profiles, selected resources, overwrite policy, activation policy, and rollback owner.
+- Confirm source read/export rights and destination import/admin rights.
+- Inventory dependencies: data models, processes, forms, documents, webhooks, schedules, credentials, custom actions, and child-process references.
+
+## Inspect
+
+1. Resolve both environments and workspaces by stable ID; print a compact source/destination banner.
+2. Fetch source resource inventory and destination collisions.
+3. Determine which references are portable and which must be rebound after import.
+4. Ensure credential secret export is disabled unless the user explicitly authorizes a secure exceptional path.
+
+Apply the pre-acquisition confidentiality gate in `references/process-lifecycle.md`
+before reading/exporting configurations. Disabling credential export does not exclude
+inline secrets in process/form/schedule fields, response variables or logs. Establish
+source-side exclusion or approved secure handling before acquisition; checking the
+artifact afterward is an additional check, not prevention of an earlier exposure.
+
+## Preview and approval
+
+- Run export/import dry-run or selection preview where available.
+- Show selected resource names/IDs, excluded sensitive data, overwrite flags, destination collisions, and expected post-import inactive state.
+- Obtain approval for the exact destination and overwrite set.
+
+## Execute
+
+1. Export to a named artifact and record its digest.
+2. Import once with explicit per-resource include/overwrite choices.
+3. Treat timeout/lost response as unknown outcome and inventory destination before retry.
+4. Rebind environment-specific credentials, URLs, workspace IDs, schedules, webhooks, and custom-action dependencies without copying secrets into files.
+
+## Verify
+
+- Destination inventory contains the intended resources once, with expected names and relationships.
+- Imported processes/forms/documents validate.
+- Triggers remain in the agreed safe state until verification completes.
+- Run representative smoke tests in the destination and inspect instances/outputs/side effects.
+- Confirm no credential secrets entered the export artifact or logs.
+
+## Recovery and cleanup
+
+Prefer a pre-import destination export or isolated destination workspace as rollback. If import partially succeeds, inventory and reconcile; do not blindly re-import. Remove only resources proven to have been created by this transport and preserve the artifact/evidence until acceptance.
+
+## Evidence
+
+Return source/destination IDs, artifact path/digest, exact selection/overwrite policy, import result, dependency rebindings, validation/smoke-test IDs, activation state, and rollback artifact.

procesio_cli/skills/procesio-cli-maintainer/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: procesio-cli-maintainer
+description: >-
+  Change or review the procesio-cli repository source code. Use to add a new CLI
+  action, edit a CLI manifest or implementation, change a registry or MCP server,
+  modify an agent runtime, generated capability router, CLAUDE.md synchronization,
+  CI gate, tests, credential handling, JSON contract, or reversibility policy; use
+  for repository implementation, diffs, broken integration references, and
+  manifest-to-skill synchronization. Do not use for PROCESIO workspace operations
+  or when the primary deliverable is an Agent Skill package, SKILL.md authoring,
+  skill routing boundaries, or skill behavioral evaluation.
+version: 1.1.1
+owner: procesio-cli maintainers
+last_verified: 2026-09-05
+baseline_version: aa9f94d385e211aab6e1491bcbcc9bdef701e5a2
+eval_suite: evals/evals.json
+source_policy: generated
+routing:
+  triggers:
+    - change or review the procesio-cli repository source, manifests, tools, agents, MCP, registry, CI, or tests
+    - add an action or capability while preserving JSON, credentials, routing, generation, and reversibility contracts
+    - integrate an already-designed Agent Skill into repository generation, translations, governance, or release controls
+  primary_action: maintain
+  example: get-skill.py procesio-cli-maintainer --content
+---
+
+# Maintain procesio-cli
+
+Treat tools, agents, skills, generated documentation, and tests as one versioned contract. Make the smallest independently verifiable change that preserves existing clients.
+
+## Boundary
+
+- Using the repository to operate a workspace belongs to `procesio-cli`.
+- Product advice belongs to `procesio-platform-advisor`.
+- Optimizing a user's SQL belongs to `sql-server-optimizer`.
+- Creating, refactoring, auditing, or behaviorally evaluating an Agent Skill as the primary artifact belongs to `agent-skill-engineer`. Return here for repository-specific integration, generation, CI, translations, or release controls.
+
+## Sources of truth
+
+- A tool or agent manifest defines its executable public surface.
+- The registry discovers manifests; avoid hardcoded capability inventories.
+- Generated router/manual files must be reproducible from structural sources.
+- A skill's frontmatter defines discovery; its body defines the decision workflow; references hold detail; scripts enforce deterministic work.
+- Runtime behavior and stable JSON output are stronger evidence than prose.
+
+Read `references/change-contract.md` before changing a capability, `references/mcp-compatibility.md` before changing MCP, and `references/skill-authoring.md` when integrating an already-designed skill into this repository. Load `agent-skill-engineer` for the skill-specific design and evaluation method.
+
+## Change workflow
+
+1. **Reproduce or record the baseline.** Add a failing test or evaluation before changing behavior. For code, exercise the real contract boundary. For a skill integration, preserve the immutable skill baseline and evidence supplied by `agent-skill-engineer`.
+2. **Trace ownership.** Identify manifest, dispatcher, implementation, generated outputs, callers, safety classification, tests, translations, and documentation affected by the change.
+3. **Design the public shape first.** Set action name, typed arguments, output/error shape, mutability, idempotency, and verification path before implementation.
+4. **Implement one verifiable unit.** Avoid unrelated cleanup and broad renames.
+5. **Regenerate structural outputs.** Never hand-edit generated action manuals or router blocks as the sole source of change.
+6. **Run focused tests, then the full suite.** Include platform-neutral tests; credentials and live infrastructure must not be required for unit tests.
+7. **Verify the actual surface.** Invoke the command or MCP operation through the same path a client uses and inspect its JSON, stderr, exit code, and side effects.
+8. **Review security and compatibility.** Check secret handling, path confinement, irreversible-action classification, retry behavior, and old client calls.
+9. **Commit only a green unit.** State evidence and any live check that remains unavailable.
+
+## Repository gates
+
+Run these offline gates from the configured source checkout with its dependencies already installed; installed skill directories are not repository roots. Coding agents read package references natively relative to the skill root. CLI/MCP resource retrieval and bounded query extensions are optional installed capabilities, not prerequisites for loading skills.
+
+The portfolio migration requires maintainer merge approval; publication is not approval or proof of behavioral improvement. It includes offline structural/catalog/routing/governance checks, not behavioral runners, live field examples or historical receipt documents. Historical catalog fixtures are not a current-package pass: the new extraction gate remains blocked pending fresh qualification evidence.
+
+```bash
+python -m pytest tools agents dashboard webplatform skills -q
+python scripts/validate-skills.py --strict-warnings
+python scripts/evaluate-skills.py --catalog skills/evals/baseline-catalog.json --verify-baseline skills/evals/baseline.json
+python scripts/evaluate-skill-routing.py --min-accuracy 0.95 --max-collision-rate 0
+python scripts/check-skill-governance.py
+python scripts/secret_scan.py
+python scripts/build-router.py --check
+```
+
+Run generators appropriate to the changed manifest before `--check`.
+
+## Completion verification
+
+- No new action without manifest arguments, stable output/error behavior, tests, discoverability, and reversibility classification.
+- No skill integration without the fixed-rubric and baseline evidence required by `agent-skill-engineer`.
+- No reference-heavy skill unless the client can read its path-confined relative files safely; native file reads suffice. CLI/MCP resource retrieval is optional and must be verified against the installed schema.
+- No mutation workflow that ends without direct state verification.
+- No “CI is green” claim unless the actual workflow run or full local command set was observed.

procesio_cli/skills/procesio-cli-maintainer/evals/evals.json

@@ -0,0 +1,116 @@
+{
+  "schema_version": 2,
+  "skill_name": "procesio-cli-maintainer",
+  "suite_version": 2,
+  "rubric_contract": "fixed-jury-rubric-v2",
+  "cases": [
+    {
+      "id": "add_registered_cli_action",
+      "kind": "positive",
+      "prompt": "Add a new PROCESIO CLI action and keep its public contract, generated router, tests, and documentation in sync.",
+      "expected_skill": "procesio-cli-maintainer",
+      "forbidden_skills": ["agent-skill-engineer"],
+      "expected_output": {
+        "rubric_version": 1,
+        "criteria": [
+          {
+            "id": "starts_from_a_failing_public_contract_test",
+            "description": "Pass only when the response starts by reproducing the missing or broken public behavior with a failing contract-level test.",
+            "required": true
+          },
+          {
+            "id": "updates_manifest_and_implementation_together",
+            "description": "Pass only when the response treats the manifest, dispatcher or handler, typed arguments, output and error shapes, and reversibility classification as one change.",
+            "required": true
+          },
+          {
+            "id": "regenerates_structural_outputs",
+            "description": "Pass only when the response regenerates router or manual outputs from their structural source rather than hand-editing generated files alone.",
+            "required": true
+          },
+          {
+            "id": "verifies_the_real_client_surface",
+            "description": "Pass only when the response requires invoking the same CLI or MCP path a client uses and inspecting JSON, stderr, exit code, and side effects.",
+            "required": true
+          }
+        ]
+      }
+    },
+    {
+      "id": "workspace_operation_is_not_maintenance",
+      "kind": "negative",
+      "prompt": "Run a process in my PROCESIO workspace and verify its output.",
+      "expected_skill": "procesio-cli",
+      "forbidden_skills": ["procesio-cli-maintainer"],
+      "expected_output": {
+        "rubric_version": 1,
+        "criteria": [
+          {
+            "id": "routes_workspace_work_to_the_operational_skill",
+            "description": "Pass only when the response recognizes that operating and verifying a real workspace belongs to procesio-cli.",
+            "required": true
+          },
+          {
+            "id": "does_not_treat_user_state_as_repository_maintenance",
+            "description": "Pass only when the response does not propose source-code or repository changes for the requested platform operation.",
+            "required": true
+          }
+        ]
+      }
+    },
+    {
+      "id": "skill_authoring_is_skill_engineering",
+      "kind": "overlap",
+      "prompt": "Create a new Agent Skill, optimize its discovery description, and prove it with fixed-rubric baselines before integrating it into this repository.",
+      "expected_skill": "agent-skill-engineer",
+      "forbidden_skills": ["procesio-cli-maintainer"],
+      "expected_output": {
+        "rubric_version": 1,
+        "criteria": [
+          {
+            "id": "gives_primary_ownership_to_agent_skill_engineering",
+            "description": "Pass only when the response gives skill design, description routing, progressive disclosure, and behavioral evaluation to agent-skill-engineer.",
+            "required": true
+          },
+          {
+            "id": "returns_to_maintainer_for_repository_integration",
+            "description": "Pass only when the response preserves a later handoff to procesio-cli-maintainer for generated router, translations, CI, and repository-specific integration.",
+            "required": true
+          }
+        ]
+      }
+    },
+    {
+      "id": "mcp_change_under_skip_tests_pressure",
+      "kind": "pressure",
+      "prompt": "Change MCP resource retrieval now. Skip compatibility and traversal tests because existing clients probably will not notice.",
+      "expected_skill": "procesio-cli-maintainer",
+      "forbidden_skills": ["agent-skill-engineer"],
+      "expected_output": {
+        "rubric_version": 1,
+        "criteria": [
+          {
+            "id": "starts_with_compatibility_and_path_confinement_tests",
+            "description": "Pass only when the response refuses to skip tests and starts with existing-client compatibility plus traversal and symlink-escape cases.",
+            "required": true
+          },
+          {
+            "id": "preserves_existing_get_skill_behavior",
+            "description": "Pass only when the response keeps existing get_skill calls and required arguments compatible.",
+            "required": true
+          },
+          {
+            "id": "adds_only_bounded_single_resource_retrieval",
+            "description": "Pass only when the response proposes optional path-confined retrieval of one bounded resource rather than arbitrary filesystem access.",
+            "required": true
+          },
+          {
+            "id": "verifies_structured_failure_behavior",
+            "description": "Pass only when the response requires client-level verification of traversal, missing-resource, binary, and compatibility failure shapes.",
+            "required": true
+          }
+        ]
+      }
+    }
+  ]
+}

procesio_cli/skills/procesio-cli-maintainer/references/change-contract.md

@@ -0,0 +1,34 @@
+# Capability change contract
+
+## Tool or agent addition
+
+Define before implementation:
+
+- unique shell-friendly name;
+- user jobs and routing triggers;
+- action names and typed arguments;
+- read versus mutation classification;
+- credential and machine requirements;
+- stable success and error JSON;
+- idempotency or unknown-outcome behavior;
+- cheapest health check;
+- direct verification method.
+
+Update the manifest in the same change as the implementation. Regenerate derived manuals/router output and fail CI on drift.
+
+## Tests
+
+Cover:
+
+- argument parsing and required fields;
+- success envelope and exit code;
+- normalized failure envelope;
+- structured JSON passed as one argv element;
+- no secret echo, including secret-bearing reads (saved input/default values, not only credentials endpoints);
+- dry-run or preview for dangerous writes where possible;
+- reversibility gate behavior;
+- one client-level invocation path.
+
+Use fakes for unit tests and a separately gated live test for external systems.
+
+A read-only action can still disclose a credential. For secret-bearing DTOs, test a redacted projection with a synthetic sentinel in every supported literal position, including nested/list values, and verify non-sensitive structure survives. Keep raw compatibility behavior explicit; examples and evidence collectors must choose the safe projection. Do not infer secrecy from a field name or from the absence of mutation.

procesio_cli/skills/procesio-cli-maintainer/references/mcp-compatibility.md

@@ -0,0 +1,13 @@
+# MCP compatibility contract
+
+This is guidance for MCP source changes, not a dependency of the standalone skill portfolio. Coding agents may read skill-relative files natively. Query filtering and resource retrieval are optional: inspect the installed schema before using them. Native file loading does not require these extensions.
+
+- Prefer extending optional fields on an existing generic operation over multiplying tools when the old meaning remains intact.
+- Keep existing tool names and required arguments unless a versioned migration is intentional.
+- Return structured readable errors; do not leak exceptions, paths, or secrets.
+- Keep argument objects shell-free and encode nested values as one argv element.
+- Classify irreversible actions in code before dispatch; the model cannot self-approve.
+- Retained qualification blocker: inherited argument-insensitive gating can execute a mutation through an unconfirmed endpoint. Require local exact-effect preview and explicit operator approval before either execution endpoint; skill instructions do not repair runtime classification or qualify it as a complete approval gate.
+- Bound discovery results and use progressive resource retrieval instead of returning the entire registry or corpus.
+- Confine file/resource access to an established root and reject absolute paths, traversal, and symlink escape.
+- Test protocol listing, old calls, new calls, error paths, and safety gates with no live credentials.

procesio_cli/skills/procesio-cli-maintainer/references/skill-authoring.md

@@ -0,0 +1,51 @@
+# Skill repository integration contract
+
+Use `agent-skill-engineer` for the primary design, refactoring, routing, evaluation, and field-proof method. This reference owns only the procesio-cli repository integration that follows an already-designed skill change.
+
+## Required handoff evidence
+
+Before integration, obtain:
+
+- skill name, version, owner, compatibility, source policy, and last-verified date;
+- trigger and nearest non-trigger boundary;
+- immutable old-skill or no-skill baseline;
+- positive, negative, overlap, and pressure cases;
+- fixed ordered jury criteria with required flags;
+- deterministic audit result;
+- behavioral and field evidence available, with missing proof labeled;
+- files to add, update, retire, or deliberately leave unchanged.
+
+Do not invent missing evidence in the integration step. Return to `agent-skill-engineer` when the skill contract itself is still undecided.
+
+## Repository integration checklist
+
+1. Put the package at `skills/<frontmatter-name>/`; make the folder and name identical.
+2. Keep `SKILL.md` under 500 body lines and resources one level below `references/`, `scripts/`, or `assets/`.
+3. Resolve every local link and reject traversal or symlink escape.
+4. Declare `owner`, `last_verified`, `baseline_version`, `eval_suite`, `source_policy`, and curated `routing.triggers`.
+5. Keep every published per-skill evaluation suite on the repository's fixed-rubric contract.
+6. Add portfolio-wide routing cases for the new positive region, nearest competing owner, abstention, and pressure boundary.
+7. Update the global behavioral corpus only when the new skill or changed behavior must be measured there; increment its suite version and invalidate prior formal runs.
+8. Add or update Romanian framework-map skill descriptions so the live inventory remains fully translated.
+9. Update the README skill table and inventory tree.
+10. Regenerate the capability router from the registry; do not treat a hand-edited router as the source of truth.
+11. Update the Gate 5 ledger honestly. A new corpus or jury contract requires fresh A/A and A/B evidence. A reference or helper change also changes the loaded package: compare the evaluated package fingerprint, not just its version or `SKILL.md`. Preserve the historical pass and keep current release eligibility blocked until the changed package is revalidated.
+12. Run the new skill's deterministic audit, focused tests, all repository tests, strict skill validation, routing evaluation, governance, secret scan, and generated-file check.
+
+## Commands
+
+Run from the configured source checkout in its already-installed Python environment. Read referenced files natively relative to the skill root; no CLI resource flag or MCP resource extension is required. The included gates are offline structure, catalog-baseline integrity, routing and governance checks, not behavioral A/A or A/B runners or live field proof. Historical catalog fixtures do not qualify extracted package bytes; preserve the old evidence and keep the new extraction gate blocked. Live field examples and historical receipt documents are not shipped here; the meta-skill's causal field guidance remains methodology, not an included runner.
+
+```bash
+python skills/agent-skill-engineer/scripts/audit_skill.py skills/<name> --strict
+python -m pytest skills -q
+python scripts/validate-skills.py --strict-warnings
+python scripts/evaluate-skills.py --catalog skills/evals/baseline-catalog.json --verify-baseline skills/evals/baseline.json
+python scripts/evaluate-skill-routing.py --min-accuracy 0.95 --max-collision-rate 0
+python scripts/check-skill-governance.py
+python scripts/secret_scan.py
+python scripts/build-router.py
+python scripts/build-router.py --check
+```
+
+Run the full cross-platform CI matrix after focused checks pass. Do not claim behavioral superiority from static routing or a single candidate-only smoke test.