From 3e9a1bc7a80ede0cce4f8371e0b151658a033005 Mon Sep 17 00:00:00 2001 From: klickd agent Date: Mon, 1 Jun 2026 19:18:13 +0000 Subject: [PATCH] add loader + protocol for the 42 x.klickd v4.1 skill packs Make the public developer story for the 42 candidate skill packs (8 Lite + 34 Pro) complete and verifiable: - @klickd/core: bundle the 42 packs + manifest under x-klickd-skills/ and add listXKlickdSkillPacks / getXKlickdSkillPackBytes / loadXKlickdSkillPack (returns artifact_loaded + sha256_matches_manifest summary). - klickd (PyPI): same bundling + list_/get_/load_xklickd_skill_pack helpers. - scripts/verify_xklickd_skill_packs.py: dependency-free verifier + CLI (verify/list/load) checking 42/8/34, JSON validity, required fields, hashes. - docs/integrations/skill-loader-protocol.md: truth boundary + artifact_loaded contract + Python/Node/CLI examples; linked from getting-started, integrations README, main README, and both package READMEs. Artifacts only: no native-assistant, GA, GDPR/EU AI Act, or benchmark claims. --- README.md | 3 + docs/getting-started.md | 33 ++ docs/integrations/README.md | 1 + docs/integrations/skill-loader-protocol.md | 163 ++++++ packages/@klickd/core/README.md | 28 + packages/@klickd/core/package.json | 1 + .../@klickd/core/scripts/verify-tarball.mjs | 12 + .../src/__tests__/x-klickd-skills.test.ts | 69 +++ packages/@klickd/core/src/index.ts | 13 + packages/@klickd/core/src/x-klickd-skills.ts | 244 ++++++++ .../accounting-operator.klickd | 364 ++++++++++++ .../x-klickd-skills/api-integrator.klickd | 381 ++++++++++++ .../core/x-klickd-skills/artist.klickd | 305 ++++++++++ .../x-klickd-skills/consumer-rights.klickd | 301 ++++++++++ .../x-klickd-skills/contract-review.klickd | 338 +++++++++++ .../customer-support-operator.klickd | 391 ++++++++++++ .../core/x-klickd-skills/data-analyst.klickd | 393 +++++++++++++ .../x-klickd-skills/devops-operator.klickd | 394 +++++++++++++ .../x-klickd-skills/drone-operator.klickd | 336 +++++++++++ .../x-klickd-skills/edge-ai-operator.klickd | 404 +++++++++++++ .../core/x-klickd-skills/eu-ai-act.klickd | 338 +++++++++++ .../core/x-klickd-skills/evidence-desk.klickd | 376 ++++++++++++ .../x-klickd-skills/finance-analyst.klickd | 382 ++++++++++++ .../core/x-klickd-skills/game-design.klickd | 397 +++++++++++++ .../core/x-klickd-skills/game-literacy.klickd | 297 ++++++++++ .../x-klickd-skills/gdpr-readiness.klickd | 344 +++++++++++ .../healthcare-ai-safety-reviewer.klickd | 382 ++++++++++++ .../identity-access-management.klickd | 380 ++++++++++++ .../x-klickd-skills/learning-designer.klickd | 391 ++++++++++++ .../x-klickd-skills/literature-review.klickd | 348 +++++++++++ .../llm-agent-engineering.klickd | 398 +++++++++++++ .../x-klickd-skills/llm-agent-security.klickd | 420 +++++++++++++ .../core/x-klickd-skills/manifest.json | 402 +++++++++++++ .../core/x-klickd-skills/media-planner.klickd | 312 ++++++++++ .../x-klickd-skills/mission-control.klickd | 374 ++++++++++++ .../core/x-klickd-skills/parent-gaming.klickd | 325 ++++++++++ .../x-klickd-skills/policy-analyst.klickd | 364 ++++++++++++ .../x-klickd-skills/privacy-product.klickd | 343 +++++++++++ .../x-klickd-skills/product-manager.klickd | 393 +++++++++++++ .../x-klickd-skills/project-operator.klickd | 356 +++++++++++ .../x-klickd-skills/release-engineer.klickd | 421 +++++++++++++ .../core/x-klickd-skills/rights-guard.klickd | 333 +++++++++++ .../x-klickd-skills/sales-operator.klickd | 382 ++++++++++++ .../core/x-klickd-skills/second-brain.klickd | 360 ++++++++++++ .../security-incident-response.klickd | 386 ++++++++++++ .../x-klickd-skills/social-literacy.klickd | 313 ++++++++++ .../x-klickd-skills/streaming-creator.klickd | 302 ++++++++++ .../sustainability-analyst.klickd | 404 +++++++++++++ .../x-klickd-skills/technical-writer.klickd | 393 +++++++++++++ .../x-klickd-skills/trust-evidence.klickd | 364 ++++++++++++ .../core/x-klickd-skills/ux-researcher.klickd | 393 +++++++++++++ .../video-production-pipeline.klickd | 554 ++++++++++++++++++ .../x-klickd-skills/work-assistant.klickd | 331 +++++++++++ packages/pypi/klickd/README.md | 24 + packages/pypi/klickd/pyproject.toml | 5 +- packages/pypi/klickd/src/klickd/__init__.py | 12 + .../accounting-operator.klickd | 364 ++++++++++++ .../x_klickd_skills/api-integrator.klickd | 381 ++++++++++++ .../src/klickd/x_klickd_skills/artist.klickd | 305 ++++++++++ .../x_klickd_skills/consumer-rights.klickd | 301 ++++++++++ .../x_klickd_skills/contract-review.klickd | 338 +++++++++++ .../customer-support-operator.klickd | 391 ++++++++++++ .../x_klickd_skills/data-analyst.klickd | 393 +++++++++++++ .../x_klickd_skills/devops-operator.klickd | 394 +++++++++++++ .../x_klickd_skills/drone-operator.klickd | 336 +++++++++++ .../x_klickd_skills/edge-ai-operator.klickd | 404 +++++++++++++ .../klickd/x_klickd_skills/eu-ai-act.klickd | 338 +++++++++++ .../x_klickd_skills/evidence-desk.klickd | 376 ++++++++++++ .../x_klickd_skills/finance-analyst.klickd | 382 ++++++++++++ .../klickd/x_klickd_skills/game-design.klickd | 397 +++++++++++++ .../x_klickd_skills/game-literacy.klickd | 297 ++++++++++ .../x_klickd_skills/gdpr-readiness.klickd | 344 +++++++++++ .../healthcare-ai-safety-reviewer.klickd | 382 ++++++++++++ .../identity-access-management.klickd | 380 ++++++++++++ .../x_klickd_skills/learning-designer.klickd | 391 ++++++++++++ .../x_klickd_skills/literature-review.klickd | 348 +++++++++++ .../llm-agent-engineering.klickd | 398 +++++++++++++ .../x_klickd_skills/llm-agent-security.klickd | 420 +++++++++++++ .../src/klickd/x_klickd_skills/manifest.json | 402 +++++++++++++ .../x_klickd_skills/media-planner.klickd | 312 ++++++++++ .../x_klickd_skills/mission-control.klickd | 374 ++++++++++++ .../x_klickd_skills/parent-gaming.klickd | 325 ++++++++++ .../x_klickd_skills/policy-analyst.klickd | 364 ++++++++++++ .../x_klickd_skills/privacy-product.klickd | 343 +++++++++++ .../x_klickd_skills/product-manager.klickd | 393 +++++++++++++ .../x_klickd_skills/project-operator.klickd | 356 +++++++++++ .../x_klickd_skills/release-engineer.klickd | 421 +++++++++++++ .../x_klickd_skills/rights-guard.klickd | 333 +++++++++++ .../x_klickd_skills/sales-operator.klickd | 382 ++++++++++++ .../x_klickd_skills/second-brain.klickd | 360 ++++++++++++ .../security-incident-response.klickd | 386 ++++++++++++ .../x_klickd_skills/social-literacy.klickd | 313 ++++++++++ .../x_klickd_skills/streaming-creator.klickd | 302 ++++++++++ .../sustainability-analyst.klickd | 404 +++++++++++++ .../x_klickd_skills/technical-writer.klickd | 393 +++++++++++++ .../x_klickd_skills/trust-evidence.klickd | 364 ++++++++++++ .../x_klickd_skills/ux-researcher.klickd | 393 +++++++++++++ .../video-production-pipeline.klickd | 554 ++++++++++++++++++ .../x_klickd_skills/work-assistant.klickd | 331 +++++++++++ .../src/klickd/x_klickd_skills_resources.py | 128 ++++ .../pypi/klickd/tests/test_x_klickd_skills.py | 72 +++ scripts/verify_xklickd_skill_packs.py | 223 +++++++ 102 files changed, 32759 insertions(+), 2 deletions(-) create mode 100644 docs/integrations/skill-loader-protocol.md create mode 100644 packages/@klickd/core/src/__tests__/x-klickd-skills.test.ts create mode 100644 packages/@klickd/core/src/x-klickd-skills.ts create mode 100644 packages/@klickd/core/x-klickd-skills/accounting-operator.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/api-integrator.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/artist.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/consumer-rights.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/contract-review.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/customer-support-operator.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/data-analyst.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/devops-operator.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/drone-operator.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/edge-ai-operator.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/eu-ai-act.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/evidence-desk.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/finance-analyst.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/game-design.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/game-literacy.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/gdpr-readiness.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/healthcare-ai-safety-reviewer.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/identity-access-management.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/learning-designer.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/literature-review.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/llm-agent-engineering.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/llm-agent-security.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/manifest.json create mode 100644 packages/@klickd/core/x-klickd-skills/media-planner.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/mission-control.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/parent-gaming.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/policy-analyst.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/privacy-product.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/product-manager.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/project-operator.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/release-engineer.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/rights-guard.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/sales-operator.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/second-brain.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/security-incident-response.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/social-literacy.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/streaming-creator.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/sustainability-analyst.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/technical-writer.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/trust-evidence.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/ux-researcher.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/video-production-pipeline.klickd create mode 100644 packages/@klickd/core/x-klickd-skills/work-assistant.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/accounting-operator.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/api-integrator.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/artist.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/consumer-rights.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/contract-review.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/customer-support-operator.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/data-analyst.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/devops-operator.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/drone-operator.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/edge-ai-operator.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/eu-ai-act.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/evidence-desk.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/finance-analyst.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/game-design.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/game-literacy.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/gdpr-readiness.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/healthcare-ai-safety-reviewer.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/identity-access-management.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/learning-designer.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/literature-review.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/llm-agent-engineering.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/llm-agent-security.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/manifest.json create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/media-planner.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/mission-control.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/parent-gaming.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/policy-analyst.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/privacy-product.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/product-manager.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/project-operator.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/release-engineer.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/rights-guard.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/sales-operator.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/second-brain.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/security-incident-response.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/social-literacy.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/streaming-creator.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/sustainability-analyst.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/technical-writer.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/trust-evidence.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/ux-researcher.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/video-production-pipeline.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills/work-assistant.klickd create mode 100644 packages/pypi/klickd/src/klickd/x_klickd_skills_resources.py create mode 100644 packages/pypi/klickd/tests/test_x_klickd_skills.py create mode 100755 scripts/verify_xklickd_skill_packs.py diff --git a/README.md b/README.md index 564f4d6..044f0b3 100644 --- a/README.md +++ b/README.md @@ -188,6 +188,9 @@ npm install @klickd/core | LlamaIndex (system prompt + vector index + session resume) | [`docs/integrations/llamaindex.md`](docs/integrations/llamaindex.md) | | GitHub Copilot / M365 Copilot (hybrid pattern) | [`docs/integrations/copilot.md`](docs/integrations/copilot.md) | | Any provider (generic pattern) | [`docs/integrations/generic.md`](docs/integrations/generic.md) | +| 42 x.klickd v4.1 skill packs (load / list / hash-verify) | [`docs/integrations/skill-loader-protocol.md`](docs/integrations/skill-loader-protocol.md) | + +> **Developer path for the 42 v4.1 skill packs:** list, load, and **hash-verify** the 8 Lite + 34 Pro packs (`artifact_loaded` + `sha256_matches_manifest`) via `@klickd/core` (Node), `klickd` (PyPI), or the no-install `scripts/verify_xklickd_skill_packs.py` CLI. They are real JSON artifacts, **not** native skills in any assistant — see [`docs/integrations/skill-loader-protocol.md`](docs/integrations/skill-loader-protocol.md). > **Experimental POC:** [`integrations/hermes/`](integrations/hermes/README.md) — Hermes Agent as workflow runner, `.klickd` as portable state layer. Local dry-run only; not a production integration. diff --git a/docs/getting-started.md b/docs/getting-started.md index f93ef68..61ef794 100644 --- a/docs/getting-started.md +++ b/docs/getting-started.md @@ -57,6 +57,39 @@ That's a real x.klickd skill loaded as model context. You're done with the smoke --- +## 2b. Load the 42 x.klickd v4.1 skill packs (optional) + +Beyond the four starter skills, the repo ships **42 x.klickd v4.1 candidate +skill packs** (8 Lite + 34 Pro). The SDK can list them and load any one with a +SHA-256 check against the published manifest: + +**Python** + +```python +import klickd + +skill = klickd.load_xklickd_skill_pack("llm-agent-engineering") +assert skill["artifact_loaded"] and skill["sha256_matches_manifest"] +print(skill["tier"], skill["pack"]) # -> pro x.klickd/llm_agent_engineering +``` + +**TypeScript / Node** + +```ts +import { loadXKlickdSkillPack } from "@klickd/core"; + +const skill = loadXKlickdSkillPack("x.klickd/llm_agent_engineering"); +if (!skill.artifact_loaded || !skill.sha256_matches_manifest) throw new Error("verify failed"); +console.log(skill.tier, skill.pack); // -> pro x.klickd/llm_agent_engineering +``` + +A pack is only "used" once `artifact_loaded` **and** `sha256_matches_manifest` +are both true — these are JSON artifacts, not native skills in any assistant. +Full details, the no-install CLI, and the truth boundary: +[`integrations/skill-loader-protocol.md`](integrations/skill-loader-protocol.md). + +--- + ## 3. Plug it into a model (~1 min) A starter skill is built to drop into a **system prompt**. Pick the provider you already have a key for — each guide is a copy-paste minimal example: diff --git a/docs/integrations/README.md b/docs/integrations/README.md index ce31b2b..ff18963 100644 --- a/docs/integrations/README.md +++ b/docs/integrations/README.md @@ -22,6 +22,7 @@ Each guide here specialises the same core pattern: **parse → validate → stri | [universal-bridge.md](universal-bridge.md) | design + reference | runtime-injection layer | **Bridge-mediated, not native** | One injection layer fronting any compatible surface | | [generic.md](generic.md) | any | `system` (recommended) | Pattern (you implement it) | Any provider or agent framework not listed above | | [starter-skills.md](starter-skills.md) | — | — | — (payload pack) | Ready-made plain starter payloads to load and inject | +| [skill-loader-protocol.md](skill-loader-protocol.md) | Python + Node + CLI | loader / hash-verify | — (artifact, not native) | Loading, listing, and hash-verifying the 42 x.klickd v4.1 skill packs (`artifact_loaded`) | **Reading the Compatibility column.** *Direct* means the provider's own API accepts a system prompt and these guides inject `.klickd` content into it — no third party decrypts or auto-loads the file. *Complementary / Bridge-mediated* means there is no native `.klickd` support on that surface; compatibility is provided by a loader or injection layer you run. No third-party AI service decrypts or auto-loads a `.klickd` file today. diff --git a/docs/integrations/skill-loader-protocol.md b/docs/integrations/skill-loader-protocol.md new file mode 100644 index 0000000..6765431 --- /dev/null +++ b/docs/integrations/skill-loader-protocol.md @@ -0,0 +1,163 @@ +# x.klickd skill-loader protocol — using the 42 v4.1 skill packs safely + +This page explains how to load, list, and **hash-verify** the 42 public +x.klickd v4.1 candidate skill packs, and where the truth boundary sits between +"a `.klickd` file exists" and "a skill is being used". + +> **Truth boundary.** The 42 packs under +> [`examples/v4.1/x-klickd-skills/`](../../examples/v4.1/x-klickd-skills/) are +> **real JSON artifacts** — byte-identical, hash-pinned, downloadable. They are +> **not** automatically native skills in any AI assistant. No third-party AI +> service decrypts, auto-loads, or natively adopts a `.klickd` file today. +> Runtime use requires a loader or host integration that you run. +> +> A pack is only **"used"** once one of these is true: +> 1. its bytes have been **loaded and SHA-256-verified** against the manifest +> (`artifact_loaded = true` **and** `sha256_matches_manifest = true`), **or** +> 2. a host runtime has otherwise **explicitly integrated** it (e.g. injected +> its content into a model's `system` prompt, per +> [`generic.md`](generic.md)). +> +> These packs are **NON-NORMATIVE** and **NOT a v4.1 GA release**. They carry no +> stability, compatibility, GDPR / EU AI Act, or benchmark-superiority claims. +> See the [claim boundary](../../README.md) in the main README. + +--- + +## What the packs are + +| | | +|---|---| +| Count | **42** total — **8 Lite**, **34 Pro** | +| Location | [`examples/v4.1/x-klickd-skills/lite/*.klickd`](../../examples/v4.1/x-klickd-skills/lite/) and [`/pro/*.klickd`](../../examples/v4.1/x-klickd-skills/pro/) | +| Index | [`examples/v4.1/x-klickd-skills/manifest.json`](../../examples/v4.1/x-klickd-skills/manifest.json) — 42 entries with `tier`, `pack`, `file`, `bytes`, `sha256_file` | +| Envelope | v4.0 (`klickd_version: "4.0"`), unencrypted JSON | +| Status | `candidate_mapped`, `non_normative: true`, `claims_v41_ga: false` | + +Each pack is a `carrier_competency_pack`: it declares competency mappings +(ESCO / SFIA / O*NET / WEF), verification gates, an evidence policy, and +human-authority fields. It does **not** carry PII, secrets, or host-side prompt +strategy. + +--- + +## `artifact_loaded` — the contract + +`loadXKlickdSkillPack()` (Node) and `load_xklickd_skill_pack()` (Python) return +a summary object. Two fields define the safety contract: + +- **`artifact_loaded: true`** — the bytes were read and hashed **in-process**. + This asserts the artifact reached your code; it does **not** assert any + assistant has adopted it. +- **`sha256_matches_manifest`** — the computed SHA-256 equals the + `sha256_file` recorded in the manifest. **Treat the pack as usable only when + this is `true`.** A `false` here means the bytes you loaded are not the + published artifact — stop and re-fetch. + +Do not claim a skill is "used" or "active" before both are confirmed. + +The summary also surfaces: `id`, `tier`, `file`, `pack`, `pack_version`, +`bytes`, `sha256`, `klickd_version`, `payload_schema_version`, `domain`, +`profile_kind`, `competency_ids`, `gates`, `evidence_policy`, +`human_authority`, and `human_veto` (when present). + +--- + +## Node / TypeScript (`@klickd/core` ≥ 4.1) + +The 42 packs ship as package data — no network fetch required. + +```ts +import { + listXKlickdSkillPacks, + loadXKlickdSkillPack, + getXKlickdSkillPackBytes, +} from "@klickd/core"; + +// 1. List all 42 (manifest entries: tier, pack, file, bytes, sha256_file). +const packs = listXKlickdSkillPacks(); +console.log(packs.length); // -> 42 + +// 2. Load + hash-verify one. Accepts a file name, full pack id, or bare id. +const skill = loadXKlickdSkillPack("x.klickd/llm_agent_engineering"); +if (!skill.artifact_loaded || !skill.sha256_matches_manifest) { + throw new Error("pack failed hash verification — do not use it"); +} +console.log(skill.tier, skill.competency_ids); // -> "pro" [ 'esco:S5.6.1', ... ] + +// 3. Raw bytes (e.g. to inject into a system prompt per generic.md). +const bytes = getXKlickdSkillPackBytes("work-assistant.klickd"); +``` + +--- + +## Python (`klickd` ≥ 4.1) + +```python +import klickd + +# 1. List all 42. +packs = klickd.list_xklickd_skill_packs() +assert len(packs) == 42 + +# 2. Load + hash-verify one. +skill = klickd.load_xklickd_skill_pack("llm-agent-engineering") +assert skill["artifact_loaded"] and skill["sha256_matches_manifest"] +print(skill["tier"], skill["competency_ids"]) # -> pro ['esco:S5.6.1', ...] + +# 3. Raw bytes. +data = klickd.get_xklickd_skill_pack_bytes("x.klickd/work_assistant") +``` + +--- + +## CLI / no-install path + +If you do not want the SDK, the repo ships a dependency-free verifier + CLI that +reads the public artifacts directly: + +```bash +python scripts/verify_xklickd_skill_packs.py verify # 42 / 8 Lite / 34 Pro, JSON + fields + hashes +python scripts/verify_xklickd_skill_packs.py list # list all 42 packs +python scripts/verify_xklickd_skill_packs.py load work-assistant # load + hash-verify one (JSON summary) +``` + +`verify` checks: 42 total (8 Lite + 34 Pro), every `.klickd` parses as JSON, +required fields present (`klickd_version`, `payload_schema_version`, `domain`, +`profile_kind`, `x_klickd_pack`, `x_klickd_pack.pack`), and SHA-256 matches the +manifest. Exit code `0` = all pass. + +--- + +## Identifier resolution + +All three loaders accept any of: + +- **file name** — `work-assistant.klickd` +- **full pack id** — `x.klickd/work_assistant` +- **bare id** — `work-assistant` or `work_assistant` (hyphen/underscore agnostic) + +--- + +## Using a verified pack with a model + +Loading and verifying gives you a trustworthy artifact. To actually influence a +model you still inject its content yourself — there is no native adoption. Use +the canonical [parse → validate → strip `_`-fields → build system prompt → +inject](generic.md) pattern. `verification_gates` in a pack are **instructions +surfaced to the model**; enforce the real gate semantics in your host +application, not inside the LLM. + +--- + +## Package-coverage status + +| Surface | Status | +|---|---| +| `@klickd/core` (npm ≥ 4.1) | Bundled — `listXKlickdSkillPacks`, `getXKlickdSkillPackBytes`, `loadXKlickdSkillPack`, `getXKlickdSkillsManifest`, `getXKlickdSkillsDir` | +| `klickd` (PyPI ≥ 4.1) | Bundled — `list_xklickd_skill_packs`, `get_xklickd_skill_pack_bytes`, `load_xklickd_skill_pack`, `get_xklickd_skills_manifest`, `get_xklickd_skills_dir` | +| Repo CLI | `scripts/verify_xklickd_skill_packs.py` (`verify` / `list` / `load`) | + +The repository tree under `examples/v4.1/x-klickd-skills/` (per-tier manifests +plus this aggregated index) remains authoritative; the bundled package copies +are byte-identical mirrors verified by the package test suites. diff --git a/packages/@klickd/core/README.md b/packages/@klickd/core/README.md index 89bfb63..ca6f2d6 100644 --- a/packages/@klickd/core/README.md +++ b/packages/@klickd/core/README.md @@ -146,6 +146,34 @@ const manifest = getStarterSkillsManifest(); const dir = getStarterSkillsDir(); // absolute path to bundled starter-skills/ ``` +### x.klickd v4.1 skill packs (42 candidate packs — non-normative) + +The 42 x.klickd v4.1 candidate skill packs (8 Lite + 34 Pro) ship inside the +npm tarball under `x-klickd-skills/` alongside the aggregated download index +`manifest.json`. They are **NON-NORMATIVE** and **NOT a v4.1 GA release**, and +they are JSON artifacts — **not** native skills in any assistant. A pack is only +"used" once `artifact_loaded` **and** `sha256_matches_manifest` are both true. + +```typescript +import { + listXKlickdSkillPacks, + loadXKlickdSkillPack, + getXKlickdSkillPackBytes, + getXKlickdSkillsManifest, +} from '@klickd/core'; + +listXKlickdSkillPacks().length; // → 42 + +const skill = loadXKlickdSkillPack('x.klickd/llm_agent_engineering'); +// skill.artifact_loaded === true, skill.sha256_matches_manifest === true +// skill.tier, skill.competency_ids, skill.gates, skill.evidence_policy, ... + +const bytes = getXKlickdSkillPackBytes('work-assistant.klickd'); // by file, pack id, or bare id +``` + +Full protocol and truth boundary: +[`docs/integrations/skill-loader-protocol.md`](https://github.com/Davincc77/klickdskill/blob/main/docs/integrations/skill-loader-protocol.md). + --- ## Cryptographic specification (v3.0) diff --git a/packages/@klickd/core/package.json b/packages/@klickd/core/package.json index 565af34..5ffaf3b 100644 --- a/packages/@klickd/core/package.json +++ b/packages/@klickd/core/package.json @@ -30,6 +30,7 @@ "files": [ "dist", "starter-skills", + "x-klickd-skills", "README.md", "LICENSE" ], diff --git a/packages/@klickd/core/scripts/verify-tarball.mjs b/packages/@klickd/core/scripts/verify-tarball.mjs index 3299ea9..38c008e 100644 --- a/packages/@klickd/core/scripts/verify-tarball.mjs +++ b/packages/@klickd/core/scripts/verify-tarball.mjs @@ -65,6 +65,12 @@ if (!(bytes instanceof Uint8Array) || bytes.byteLength <= 0) { throw new Error('CJS: empty user.klickd'); } if (k.listBundledSchemas().length !== 4) throw new Error('CJS: expected 4 schemas'); +const xm = k.getXKlickdSkillsManifest(); +if (xm.total_count !== 42 || xm.packs.length !== 42) throw new Error('CJS: expected 42 x.klickd packs'); +const xs = k.loadXKlickdSkillPack('work-assistant'); +if (xs.artifact_loaded !== true || xs.sha256_matches_manifest !== true) { + throw new Error('CJS: work-assistant did not load/verify'); +} console.log('CJS smoke OK'); `; @@ -82,6 +88,12 @@ if (!(bytes instanceof Uint8Array) || bytes.byteLength <= 0) { throw new Error('ESM: empty coding.klickd'); } if (k.listBundledSchemas().length !== 4) throw new Error('ESM: expected 4 schemas'); +const xm = k.getXKlickdSkillsManifest(); +if (xm.total_count !== 42 || xm.packs.length !== 42) throw new Error('ESM: expected 42 x.klickd packs'); +const xs = k.loadXKlickdSkillPack('x.klickd/llm_agent_engineering'); +if (xs.artifact_loaded !== true || xs.sha256_matches_manifest !== true) { + throw new Error('ESM: llm_agent_engineering did not load/verify'); +} console.log('ESM smoke OK'); `; diff --git a/packages/@klickd/core/src/__tests__/x-klickd-skills.test.ts b/packages/@klickd/core/src/__tests__/x-klickd-skills.test.ts new file mode 100644 index 0000000..e67676b --- /dev/null +++ b/packages/@klickd/core/src/__tests__/x-klickd-skills.test.ts @@ -0,0 +1,69 @@ +// @klickd/core — x.klickd v4.1 skill-pack inclusion test +// SPDX-License-Identifier: CC0-1.0 + +import { createHash } from 'node:crypto'; +import { + listXKlickdSkillPacks, + getXKlickdSkillPackBytes, + getXKlickdSkillsManifest, + getXKlickdSkillsDir, + loadXKlickdSkillPack, +} from '../index.js'; + +describe('bundled x.klickd v4.1 skill packs', () => { + it('exposes a 42-pack manifest (8 Lite + 34 Pro)', () => { + const manifest = getXKlickdSkillsManifest(); + expect(manifest.non_normative).toBe(true); + expect(manifest.claims_v41_ga).toBe(false); + expect(manifest.total_count).toBe(42); + expect(manifest.packs.length).toBe(42); + const lite = manifest.packs.filter((p) => p.tier === 'lite'); + const pro = manifest.packs.filter((p) => p.tier === 'pro'); + expect(lite.length).toBe(8); + expect(pro.length).toBe(34); + }); + + it('every bundled pack hash matches the manifest', () => { + for (const pack of listXKlickdSkillPacks()) { + const bytes = getXKlickdSkillPackBytes(pack.file); + const hash = createHash('sha256').update(bytes).digest('hex'); + expect(hash).toBe(pack.sha256_file); + expect(bytes.byteLength).toBe(pack.bytes); + } + }); + + it('resolves packs by file name, full pack id, and bare id', () => { + const byFile = loadXKlickdSkillPack('work-assistant.klickd'); + const byPack = loadXKlickdSkillPack('x.klickd/work_assistant'); + const byBare = loadXKlickdSkillPack('work-assistant'); + expect(byFile.sha256).toBe(byPack.sha256); + expect(byPack.sha256).toBe(byBare.sha256); + }); + + it('loadXKlickdSkillPack reports artifact_loaded and a verified hash', () => { + const summary = loadXKlickdSkillPack('llm-agent-engineering'); + expect(summary.artifact_loaded).toBe(true); + expect(summary.sha256_matches_manifest).toBe(true); + expect(summary.tier).toBe('pro'); + expect(summary.pack).toBe('x.klickd/llm_agent_engineering'); + expect(summary.klickd_version).toBe('4.0'); + expect(summary.domain).toBe('software_engineering'); + expect(summary.profile_kind).toBe('carrier_competency_pack'); + expect(summary.competency_ids.length).toBeGreaterThan(0); + expect(summary.gates.length).toBeGreaterThan(0); + expect(summary.evidence_policy).not.toBeNull(); + expect(summary.human_authority).not.toBeNull(); + }); + + it('rejects unknown packs and path traversal', () => { + expect(() => getXKlickdSkillPackBytes('../package.json')).toThrow(); + expect(() => getXKlickdSkillPackBytes('does-not-exist')).toThrow(); + expect(() => loadXKlickdSkillPack('nope')).toThrow(); + }); + + it('returns a directory path that exists', () => { + const dir = getXKlickdSkillsDir(); + expect(typeof dir).toBe('string'); + expect(dir.length).toBeGreaterThan(0); + }); +}); diff --git a/packages/@klickd/core/src/index.ts b/packages/@klickd/core/src/index.ts index 371c0a2..05ff203 100644 --- a/packages/@klickd/core/src/index.ts +++ b/packages/@klickd/core/src/index.ts @@ -28,3 +28,16 @@ export type { StarterSkillEntry, StarterSkillManifest, } from './starter-skills.js'; +export { + getXKlickdSkillsDir, + getXKlickdSkillsManifest, + listXKlickdSkillPacks, + getXKlickdSkillPackBytes, + loadXKlickdSkillPack, +} from './x-klickd-skills.js'; +export type { + XKlickdSkillPackEntry, + XKlickdSkillManifest, + XKlickdSkillGateSummary, + XKlickdSkillPackSummary, +} from './x-klickd-skills.js'; diff --git a/packages/@klickd/core/src/x-klickd-skills.ts b/packages/@klickd/core/src/x-klickd-skills.ts new file mode 100644 index 0000000..92c3448 --- /dev/null +++ b/packages/@klickd/core/src/x-klickd-skills.ts @@ -0,0 +1,244 @@ +// @klickd/core — x.klickd v4.1 skill-pack helper +// SPDX-License-Identifier: CC0-1.0 +// +// The 42 x.klickd v4.1 candidate skill packs (8 Lite + 34 Pro) ship as +// package data under the `x-klickd-skills/` directory at the package root, +// alongside the aggregated download index `manifest.json`. They are +// NON-NORMATIVE and NOT a v4.1 GA release (see +// examples/v4.1/x-klickd-skills/README.md in the source repository). +// +// These are JSON `.klickd` artifacts, not native skills in any assistant. +// A pack is only "used" once its bytes have been loaded and hash-verified +// against the manifest (or a host runtime has otherwise integrated it). +// `loadXKlickdSkillPack` returns `artifact_loaded: true` only after that +// load + SHA-256 step has completed in-process. + +import { fileURLToPath } from 'node:url'; +import { dirname, join } from 'node:path'; +import { existsSync, readFileSync, readdirSync } from 'node:fs'; +import { createHash } from 'node:crypto'; + +export interface XKlickdSkillPackEntry { + tier: string; + pack: string; + file: string; + relative_path: string; + bytes: number; + sha256_file: string; + status: string; + [key: string]: unknown; +} + +export interface XKlickdSkillManifest { + manifest_version: string; + kind: string; + non_normative: boolean; + claims_v41_ga: boolean; + total_count: number; + tiers: Record; + packs: XKlickdSkillPackEntry[]; + [key: string]: unknown; +} + +export interface XKlickdSkillGateSummary { + id?: string; + action_class?: string; + level?: string; + reason?: string; + [key: string]: unknown; +} + +export interface XKlickdSkillPackSummary { + /** + * True only after the artifact bytes were read and their SHA-256 was + * computed in-process. A pack is not "used" until this is true. + */ + artifact_loaded: true; + id: string; + tier: string | null; + file: string; + pack: string | null; + pack_version: string | null; + bytes: number; + sha256: string; + sha256_matches_manifest: boolean; + klickd_version: string | null; + payload_schema_version: string | null; + domain: string | null; + profile_kind: string | null; + competency_ids: string[]; + gates: XKlickdSkillGateSummary[]; + evidence_policy: Record | null; + human_authority: Record | null; + human_veto: Record | null; +} + +// Resolve the directory of the running module in a way that works for both +// the CommonJS and ESM builds produced by tsup. (Same probe as +// starter-skills.ts: `import.meta.url` is rewritten to an empty object in +// the CJS bundle, and `__dirname` is undefined in the ESM bundle.) +function moduleDir(): string { + if (typeof __dirname !== 'undefined') { + return __dirname; + } + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const metaUrl: string | undefined = (import.meta as any)?.url; + if (typeof metaUrl === 'string' && metaUrl.length > 0) { + return dirname(fileURLToPath(metaUrl)); + } + throw new Error( + '@klickd/core: unable to resolve module directory for x-klickd-skills', + ); +} + +function skillsDir(): string { + const here = moduleDir(); + const candidates = [ + join(here, '..', 'x-klickd-skills'), + join(here, 'x-klickd-skills'), + ]; + for (const candidate of candidates) { + if (existsSync(candidate)) { + return candidate; + } + } + return candidates[0]; +} + +export function getXKlickdSkillsDir(): string { + return skillsDir(); +} + +export function getXKlickdSkillsManifest(): XKlickdSkillManifest { + const raw = readFileSync(join(skillsDir(), 'manifest.json'), 'utf8'); + return JSON.parse(raw) as XKlickdSkillManifest; +} + +/** + * List the 42 skill-pack manifest entries. The manifest is authoritative for + * tier, pack id, byte length, and expected SHA-256. + */ +export function listXKlickdSkillPacks(): XKlickdSkillPackEntry[] { + return getXKlickdSkillsManifest().packs; +} + +function manifestEntryFor( + idOrFilenameOrPack: string, +): XKlickdSkillPackEntry | undefined { + const packs = listXKlickdSkillPacks(); + const needle = idOrFilenameOrPack.trim(); + // Match by file name, full pack id (x.klickd/foo), or bare id (foo / foo-bar). + return packs.find((p) => { + if (p.file === needle) return true; + if (p.pack === needle) return true; + const bareFromPack = p.pack.split('/').pop(); + const bareFromFile = p.file.replace(/\.klickd$/, ''); + const normNeedle = needle.replace(/\.klickd$/, ''); + return ( + bareFromPack === normNeedle || + bareFromFile === normNeedle || + bareFromPack === normNeedle.replace(/-/g, '_') || + bareFromFile === normNeedle.replace(/_/g, '-') + ); + }); +} + +/** + * Return the raw bytes of a bundled skill pack by file name, full pack id + * (`x.klickd/work_assistant`), or bare id (`work-assistant` / `work_assistant`). + */ +export function getXKlickdSkillPackBytes( + idOrFilenameOrPack: string, +): Uint8Array { + const entry = manifestEntryFor(idOrFilenameOrPack); + if (!entry) { + throw new Error( + `unknown x.klickd skill pack: ${idOrFilenameOrPack} (see listXKlickdSkillPacks())`, + ); + } + const { file } = entry; + if (file.includes('/') || file.includes('\\') || file.includes('..')) { + throw new Error(`invalid x.klickd skill pack file: ${file}`); + } + return new Uint8Array(readFileSync(join(skillsDir(), file))); +} + +function asRecord(value: unknown): Record | null { + return value && typeof value === 'object' && !Array.isArray(value) + ? (value as Record) + : null; +} + +/** + * Load a skill pack, hash-verify it against the manifest, and return a JSON + * summary. The returned `artifact_loaded: true` asserts only that the bytes + * were read and hashed in-process — it does NOT mean any AI assistant has + * natively adopted the pack. Always check `sha256_matches_manifest`. + */ +export function loadXKlickdSkillPack( + idOrFilenameOrPack: string, +): XKlickdSkillPackSummary { + const entry = manifestEntryFor(idOrFilenameOrPack); + if (!entry) { + throw new Error( + `unknown x.klickd skill pack: ${idOrFilenameOrPack} (see listXKlickdSkillPacks())`, + ); + } + const bytes = getXKlickdSkillPackBytes(entry.file); + const sha256 = createHash('sha256').update(bytes).digest('hex'); + const payload = JSON.parse(new TextDecoder().decode(bytes)) as Record< + string, + unknown + >; + const pack = asRecord(payload.x_klickd_pack) ?? {}; + const compactIndex = asRecord(pack.compact_index) ?? {}; + + const competencyIds: string[] = Array.isArray(compactIndex.competency_ids) + ? (compactIndex.competency_ids as unknown[]).map((x) => String(x)) + : Array.isArray(pack.competencies) + ? (pack.competencies as Array>) + .map((c) => (c && c.competency_ref ? String(c.competency_ref) : '')) + .filter(Boolean) + : []; + + const verificationGates = asRecord(pack.verification_gates); + const gates: XKlickdSkillGateSummary[] = verificationGates + && Array.isArray(verificationGates.gates) + ? (verificationGates.gates as XKlickdSkillGateSummary[]) + : Array.isArray(compactIndex.gate_summaries) + ? (compactIndex.gate_summaries as XKlickdSkillGateSummary[]) + : []; + + return { + artifact_loaded: true, + id: entry.pack, + tier: typeof entry.tier === 'string' ? entry.tier : null, + file: entry.file, + pack: typeof pack.pack === 'string' ? (pack.pack as string) : null, + pack_version: + typeof pack.pack_version === 'string' + ? (pack.pack_version as string) + : null, + bytes: bytes.byteLength, + sha256, + sha256_matches_manifest: sha256 === entry.sha256_file, + klickd_version: + typeof payload.klickd_version === 'string' + ? (payload.klickd_version as string) + : null, + payload_schema_version: + typeof payload.payload_schema_version === 'string' + ? (payload.payload_schema_version as string) + : null, + domain: typeof payload.domain === 'string' ? (payload.domain as string) : null, + profile_kind: + typeof payload.profile_kind === 'string' + ? (payload.profile_kind as string) + : null, + competency_ids: competencyIds, + gates, + evidence_policy: asRecord(pack.evidence_policy), + human_authority: asRecord(pack.human_authority), + human_veto: asRecord(pack.human_veto), + }; +} diff --git a/packages/@klickd/core/x-klickd-skills/accounting-operator.klickd b/packages/@klickd/core/x-klickd-skills/accounting-operator.klickd new file mode 100644 index 0000000..8bcfbba --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/accounting-operator.klickd @@ -0,0 +1,364 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "accounting", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B29). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/accounting_operator", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b29", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/accounting_operator", + "frameworks": [ + "esco", + "onet", + "sfia" + ], + "competency_ids": [ + "esco:S4.0.2", + "esco:S4.7", + "onet:13-2011.00", + "onet:43-3031.00", + "sfia:FMIT" + ], + "gate_summaries": [ + { + "id": "ledger-back-dated-entry", + "level": "block" + }, + { + "id": "statutory-filing", + "level": "confirm" + }, + { + "id": "regulated-tax-advice", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1100, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/work", + "x.klickd/legal" + ], + "target_user": "Accounting operator (bookkeeper, accounts receivable/payable, junior controller) maintaining ledgers, reconciliations, statutory filings. NOT a tax advisor; NOT a chartered auditor.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.0.2", + "scheme": "esco", + "prefLabel": "controlling, monitoring activities, resources" + }, + { + "competency_ref": "esco:S4.7", + "scheme": "esco", + "prefLabel": "administration support" + }, + { + "competency_ref": "onet:13-2011.00", + "scheme": "onet", + "prefLabel": "Accountants and Auditors" + }, + { + "competency_ref": "onet:43-3031.00", + "scheme": "onet", + "prefLabel": "Bookkeeping, Accounting, and Auditing Clerks" + }, + { + "competency_ref": "sfia:FMIT", + "scheme": "sfia", + "prefLabel": "Financial management" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4.0.2", + "scheme": "esco", + "prefLabel": "controlling, monitoring activities, resources" + }, + { + "competency_ref": "esco:S4.7", + "scheme": "esco", + "prefLabel": "administration support" + }, + { + "competency_ref": "onet:13-2011.00", + "scheme": "onet", + "prefLabel": "Accountants and Auditors" + }, + { + "competency_ref": "onet:43-3031.00", + "scheme": "onet", + "prefLabel": "Bookkeeping, Accounting, and Auditing Clerks" + }, + { + "competency_ref": "sfia:FMIT", + "scheme": "sfia", + "prefLabel": "Financial management" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/5", + "level_label": "EQF level 5", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.accounting_operator", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.accounting_operator.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.accounting_operator.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.accounting_operator", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/accounting_operator", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:38869f92d12405171e53e3e29849a40e", + "attestation_hash": "sha256:77a3aecd5ee2381fe9efffc1e79cce2abc36e4744967169db583b0fe315661a6" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/accounting_operator/v0-draft", + "embedding_model_ref": "klickd-embed-accounting_operator-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "accounting", + "ledger", + "vat", + "month_end", + "audit_trail" + ], + "entity_classes": [ + "esco", + "sfia" + ], + "priority": "ledger_operation", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "back_dated_ledger_entry", + "statutory_filing_submission", + "regulated_tax_advice_output" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "back_dated_ledger_entry", + "regulated_tax_advice_output" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "ledger-back-dated-entry", + "action_class": "back_dated_ledger_entry", + "level": "block", + "reason": "Back-dated ledger entries outside a declared period are blocked." + }, + { + "id": "statutory-filing", + "action_class": "statutory_filing_submission", + "level": "confirm", + "reason": "Statutory filings require explicit human confirmation." + }, + { + "id": "regulated-tax-advice", + "action_class": "regulated_tax_advice_output", + "level": "block", + "reason": "Output resembling regulated tax advice is blocked; escalate to tax advisor." + } + ] + }, + "router_cost": { + "tokens_estimate": 1100, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/accounting_operator are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/api-integrator.klickd b/packages/@klickd/core/x-klickd-skills/api-integrator.klickd new file mode 100644 index 0000000..a82224c --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/api-integrator.klickd @@ -0,0 +1,381 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "software_engineering", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B23). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/api_integrator", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b23", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/api_integrator", + "frameworks": [ + "esco", + "sfia", + "onet", + "digcomp" + ], + "competency_ids": [ + "esco:S5.6", + "sfia:PROG", + "sfia:HSIN", + "sfia:METL", + "onet:15-1254.00", + "digcomp:3.4" + ], + "gate_summaries": [ + { + "id": "vendor-secret-handling", + "level": "block" + }, + { + "id": "retry-budget-override", + "level": "confirm" + }, + { + "id": "vendor-version-bump", + "level": "confirm" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/coding" + ], + "target_user": "Engineer integrating third-party APIs and building webhook / event consumers. Idempotency, retry budgets, secret hygiene, vendor change discipline.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://publications.jrc.ec.europa.eu/repository/handle/JRC128415/", + "canonical_url": "https://publications.jrc.ec.europa.eu/repository/handle/JRC128415" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT — software development" + }, + { + "competency_ref": "sfia:PROG", + "scheme": "sfia", + "prefLabel": "Programming/software development" + }, + { + "competency_ref": "sfia:HSIN", + "scheme": "sfia", + "prefLabel": "Systems integration and build" + }, + { + "competency_ref": "sfia:METL", + "scheme": "sfia", + "prefLabel": "Methods and tools" + }, + { + "competency_ref": "onet:15-1254.00", + "scheme": "onet", + "prefLabel": "Web Developers" + }, + { + "competency_ref": "digcomp:3.4", + "scheme": "digcomp", + "prefLabel": "Programming" + } + ], + "competencies": [ + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT — software development" + }, + { + "competency_ref": "sfia:PROG", + "scheme": "sfia", + "prefLabel": "Programming/software development" + }, + { + "competency_ref": "sfia:HSIN", + "scheme": "sfia", + "prefLabel": "Systems integration and build" + }, + { + "competency_ref": "sfia:METL", + "scheme": "sfia", + "prefLabel": "Methods and tools" + }, + { + "competency_ref": "onet:15-1254.00", + "scheme": "onet", + "prefLabel": "Web Developers" + }, + { + "competency_ref": "digcomp:3.4", + "scheme": "digcomp", + "prefLabel": "Programming" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.api_integrator", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.api_integrator.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.api_integrator.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.api_integrator", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/api_integrator", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:b7bbde86ab488da149599e75fd3a80c3", + "attestation_hash": "sha256:6fa4d58ca8b32001503ee90c13b8453e2e5d101e2404f4c02fc8453b96cf4561" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/api_integrator/v0-draft", + "embedding_model_ref": "klickd-embed-api_integrator-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 7, + "max_facts_per_turn": 9, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "api", + "webhook", + "retry", + "idempotency", + "schema_drift" + ], + "entity_classes": [ + "esco", + "sfia", + "onet" + ], + "priority": "integration_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "secret_in_source_or_log", + "retry_budget_override", + "vendor_major_version_bump" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "secret_in_source_or_log" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "vendor-secret-handling", + "action_class": "secret_in_source_or_log", + "level": "block", + "reason": "Vendor secrets in source or log surface are blocked." + }, + { + "id": "retry-budget-override", + "action_class": "retry_budget_override", + "level": "confirm", + "reason": "Overriding declared retry budget requires explicit confirmation." + }, + { + "id": "vendor-version-bump", + "action_class": "vendor_major_version_bump", + "level": "confirm", + "reason": "Major-version vendor SDK bumps require confirmation against a contract test." + } + ] + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/api_integrator are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/artist.klickd b/packages/@klickd/core/x-klickd-skills/artist.klickd new file mode 100644 index 0000000..4b3213e --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/artist.klickd @@ -0,0 +1,305 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "creative", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "lite", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact. Lot A artist pack, distinct from x.klickd/creator (P1)." + }, + "x_klickd_pack": { + "pack": "x.klickd/artist", + "pack_version": "0.1.0-candidate-lite", + "spec_ref": "x.klickd/v4.1#a10", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "lite", + "parent_packs": [ + "x.klickd/user", + "x.klickd/creator" + ], + "target_user": "Independent visual / musical / performing artist focused on practice rather than production-line creator workflow.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "lifecomp", + "version": "2020", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/lifecomp/2020/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/lifecomp_en" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "lifecomp", + "version": "2020" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "creativity and innovation" + }, + { + "competency_ref": "lifecomp:P3", + "scheme": "lifecomp", + "prefLabel": "Well-being" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "creativity and innovation" + }, + { + "competency_ref": "esco:S1.5", + "scheme": "esco", + "prefLabel": "performing artistic work" + }, + { + "competency_ref": "lifecomp:P3", + "scheme": "lifecomp", + "prefLabel": "Well-being" + }, + { + "competency_ref": "digcomp:3.1", + "scheme": "digcomp", + "prefLabel": "Developing digital content" + } + ], + "competencies": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "creativity and innovation" + }, + { + "competency_ref": "esco:S1.5", + "scheme": "esco", + "prefLabel": "performing artistic work" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/5", + "level_label": "EQF level 5", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.artist", + "memory_segments": [ + { + "id": "works", + "scope": "memory.x_klickd.artist.works", + "policy": "pointer_only_attribution" + }, + { + "id": "ai-training-consent", + "scope": "memory.x_klickd.artist.consent", + "policy": "explicit_opt_in_required" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.artist", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/artist", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:5607a96ccfb90c24663dbf3a3b88d9a6", + "attestation_hash": "sha256:9453db73e1f98ca8ceec5852791d193832271a15e90c9514f5efc66148bf4ff2" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/artist/v0-draft", + "embedding_model_ref": "klickd-embed-artist-2026-v0-placeholder", + "dim": 384, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 4, + "max_facts_per_turn": 6, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "creator", + "visual_arts", + "portfolio", + "originality" + ], + "entity_classes": [ + "esco", + "lifecomp" + ], + "priority": "creative_practice", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "work_attribution", + "ai_training_use", + "third_party_likeness" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "ai_training_use_without_opt_in" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "human_carrier_only" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "ai_training_consent_default": "opt_out", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "ai-training-use", + "action_class": "ai_training_use", + "level": "block", + "reason": "AI-training use of carrier's work is opt-out by default; explicit opt-in required." + }, + { + "id": "work-attribution", + "action_class": "work_attribution", + "level": "confirm", + "reason": "Attribution of a work requires explicit confirmation by carrier." + }, + { + "id": "third-party-likeness", + "action_class": "third_party_likeness", + "level": "confirm", + "reason": "Use of a recognisable third-party likeness requires consent and confirmation." + } + ] + }, + "router_cost": { + "tokens_estimate": 750, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into ESCO, LifeComp, or DigComp.", + "AI-training-use is opt-out by default; explicit opt-in required to lower.", + "Pointer-only evidence for works; no inline work bytes.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == lite and tokens_estimate <= 900", + "ai_training_consent_default == opt_out" + ], + "review": [ + "Reviewer verifies opt-out default is preserved.", + "Reviewer verifies third_party_likeness gate stays at confirm or above." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/consumer-rights.klickd b/packages/@klickd/core/x-klickd-skills/consumer-rights.klickd new file mode 100644 index 0000000..0e94334 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/consumer-rights.klickd @@ -0,0 +1,301 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "legal", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "lite", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact. Lot A consumer-rights pack composing x.klickd/user and x.klickd/legal (P0)." + }, + "x_klickd_pack": { + "pack": "x.klickd/consumer_rights", + "pack_version": "0.1.0-candidate-lite", + "spec_ref": "x.klickd/v4.1#a7", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "lite", + "parent_packs": [ + "x.klickd/user", + "x.klickd/legal" + ], + "target_user": "Consumer carrier dealing with returns, warranty, distance-selling, GDPR data-subject rights. Not litigation.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + } + ], + "citation_only_references": [ + { + "id": "eu-consumer-rights-directive", + "ref": "Directive 2011/83/EU", + "url": "https://eur-lex.europa.eu/eli/dir/2011/83/oj" + }, + { + "id": "gdpr-art-12-22", + "ref": "Regulation (EU) 2016/679 Art. 12-22", + "url": "https://eur-lex.europa.eu/eli/reg/2016/679/oj" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "digcomp", + "version": "2.2" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.7", + "scheme": "esco", + "prefLabel": "administration" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "digcomp:4.2", + "scheme": "digcomp", + "prefLabel": "Protecting personal data and privacy" + } + ], + "competencies": [ + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "digcomp:4.2", + "scheme": "digcomp", + "prefLabel": "Protecting personal data and privacy" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/4", + "level_label": "EQF level 4", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.consumer_rights", + "memory_segments": [ + { + "id": "disputes", + "scope": "memory.x_klickd.consumer_rights.disputes", + "policy": "pointer_only_no_third_party_text" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.consumer_rights", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/consumer_rights", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:9a9fb73fa76bacedb09e5a853152d335", + "attestation_hash": "sha256:1e0f9f135f49a1c743fe4405740a255abdc587fac74ae6e411420e96a608671e" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/consumer_rights/v0-draft", + "embedding_model_ref": "klickd-embed-consumer_rights-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 5, + "max_facts_per_turn": 6, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "consumer", + "eu_law", + "redress", + "complaint", + "warranty" + ], + "entity_classes": [ + "esco", + "eu_law_ref" + ], + "priority": "rights_lookup", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "legal_dispute_escalation", + "contract_assertion", + "third_party_communication" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "litigation_action" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "licensed_lawyer_required_after_first_written_reply" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "third-party-comms", + "action_class": "third_party_communication", + "level": "confirm", + "reason": "Outgoing communication to a vendor / counterparty requires explicit confirmation." + }, + { + "id": "legal-assertion", + "action_class": "contract_assertion", + "level": "confirm", + "reason": "Asserting a legal right requires grounding to the specific clause / directive." + }, + { + "id": "litigation-action", + "action_class": "litigation_action", + "level": "block", + "reason": "Litigation steps require licensed counsel; this pack cannot authorise them." + } + ] + }, + "router_cost": { + "tokens_estimate": 700, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into ESCO or DigComp.", + "EU directives are cited (citation_only_references), not registered as frameworks[] schemes.", + "Litigation actions blocked; mandatory escalation to licensed lawyer.", + "Pointer-only evidence; no inline third-party contract text.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == lite and tokens_estimate <= 900" + ], + "review": [ + "Reviewer verifies EU AI Act / GDPR are citation-only, not in frameworks[].", + "Reviewer verifies litigation_action gate stays block." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/contract-review.klickd b/packages/@klickd/core/x-klickd-skills/contract-review.klickd new file mode 100644 index 0000000..dac085f --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/contract-review.klickd @@ -0,0 +1,338 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "legal", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B8). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/contract_review", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b8", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/contract_review", + "frameworks": [ + "esco", + "onet" + ], + "competency_ids": [ + "esco:S4.6", + "esco:S4.6.3", + "onet:23-1011.00" + ], + "gate_summaries": [ + { + "id": "clause-flag-send", + "level": "confirm" + }, + { + "id": "liability-redline", + "level": "block" + }, + { + "id": "confidential-text-inline", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/legal" + ], + "target_user": "Legal-adjacent reviewer (in-house counsel, contract manager, founder) reading commercial contracts. Clause spotting, risk flagging, escalation. Not legal advice.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "onet", + "version": "28.0" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S4.6.3", + "scheme": "esco", + "prefLabel": "contract law and commercial law" + }, + { + "competency_ref": "onet:23-1011.00", + "scheme": "onet", + "prefLabel": "Lawyers" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S4.6.3", + "scheme": "esco", + "prefLabel": "contract law and commercial law" + }, + { + "competency_ref": "onet:23-1011.00", + "scheme": "onet", + "prefLabel": "Lawyers" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.contract_review", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.contract_review.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.contract_review.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.contract_review", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/contract_review", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:221e7aa3a54a2d8953921c03076f2564", + "attestation_hash": "sha256:749185ac2b1c0353e15891b0d1aa6de022fa97b01a5e8332e390e5a57e02d4ae" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/contract_review/v0-draft", + "embedding_model_ref": "klickd-embed-contract_review-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "none", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "contract", + "liability_clause", + "indemnity", + "redline", + "term_extraction" + ], + "entity_classes": [ + "esco", + "eu_law_ref" + ], + "priority": "legal_review", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "clause_flag_send_to_counterparty", + "redline_liability_indemnity_termination", + "confidential_contract_text_inline" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "redline_liability_indemnity_termination", + "confidential_contract_text_inline" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "clause-flag-send", + "action_class": "clause_flag_send_to_counterparty", + "level": "confirm", + "reason": "Clause flags sent to counterparty require explicit confirmation." + }, + { + "id": "liability-redline", + "action_class": "redline_liability_indemnity_termination", + "level": "block", + "reason": "Redlines on liability/indemnity/termination require licensed lawyer escalation; floor not lowerable." + }, + { + "id": "confidential-text-inline", + "action_class": "confidential_contract_text_inline", + "level": "block", + "reason": "Inline confidential contract text blocked unless carrier asserts rights." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/contract_review are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/customer-support-operator.klickd b/packages/@klickd/core/x-klickd-skills/customer-support-operator.klickd new file mode 100644 index 0000000..3cf606c --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/customer-support-operator.klickd @@ -0,0 +1,391 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "customer_support", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B27). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/customer_support_operator", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b27", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/customer_support_operator", + "frameworks": [ + "esco", + "onet", + "lifecomp", + "wef" + ], + "competency_ids": [ + "esco:S3", + "esco:S1.2", + "esco:S4.0.1", + "onet:43-4051.00", + "lifecomp:S1", + "lifecomp:S2", + "wef:active-learning" + ], + "gate_summaries": [ + { + "id": "pii-share-cross-ticket", + "level": "block" + }, + { + "id": "refund-floor-override", + "level": "confirm" + }, + { + "id": "auto-close-without-confirm", + "level": "confirm" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1100, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/work" + ], + "target_user": "Customer-support / success operator running tier-1/2 triage, response, escalation. Empathy, claim grounding, GDPR-aware data handling. NOT social media community management at scale.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "lifecomp", + "version": "2020", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/lifecomp/2020/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/lifecomp_en" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S3", + "scheme": "esco", + "prefLabel": "communicating, collaborating, advising, mediating" + }, + { + "competency_ref": "esco:S1.2", + "scheme": "esco", + "prefLabel": "supporting interpersonal communication" + }, + { + "competency_ref": "esco:S4.0.1", + "scheme": "esco", + "prefLabel": "managing activities, resources, requirements" + }, + { + "competency_ref": "onet:43-4051.00", + "scheme": "onet", + "prefLabel": "Customer Service Representatives" + }, + { + "competency_ref": "lifecomp:S1", + "scheme": "lifecomp", + "prefLabel": "Empathy" + }, + { + "competency_ref": "lifecomp:S2", + "scheme": "lifecomp", + "prefLabel": "Collaboration" + }, + { + "competency_ref": "wef:active-learning", + "scheme": "wef", + "prefLabel": "Active learning and learning strategies" + } + ], + "competencies": [ + { + "competency_ref": "esco:S3", + "scheme": "esco", + "prefLabel": "communicating, collaborating, advising, mediating" + }, + { + "competency_ref": "esco:S1.2", + "scheme": "esco", + "prefLabel": "supporting interpersonal communication" + }, + { + "competency_ref": "esco:S4.0.1", + "scheme": "esco", + "prefLabel": "managing activities, resources, requirements" + }, + { + "competency_ref": "onet:43-4051.00", + "scheme": "onet", + "prefLabel": "Customer Service Representatives" + }, + { + "competency_ref": "lifecomp:S1", + "scheme": "lifecomp", + "prefLabel": "Empathy" + }, + { + "competency_ref": "lifecomp:S2", + "scheme": "lifecomp", + "prefLabel": "Collaboration" + }, + { + "competency_ref": "wef:active-learning", + "scheme": "wef", + "prefLabel": "Active learning and learning strategies" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/4", + "level_label": "EQF level 4", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.customer_support_operator", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.customer_support_operator.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.customer_support_operator.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.customer_support_operator", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/customer_support_operator", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:5e1eb28df87681b224070c7cc9692a0b", + "attestation_hash": "sha256:6e1a6ccbdc767e03fcc41074a57da3c0dcb0162041d1a6cddd4b74da7791de1e" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/customer_support_operator/v0-draft", + "embedding_model_ref": "klickd-embed-customer_support_operator-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "support", + "ticket", + "macro", + "csat", + "escalation" + ], + "entity_classes": [ + "esco", + "sfia" + ], + "priority": "support_operation", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "share_pii_across_ticket", + "refund_floor_override", + "auto_close_without_customer_confirm" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "share_pii_across_ticket" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "pii-share-cross-ticket", + "action_class": "share_pii_across_ticket", + "level": "block", + "reason": "Sharing one customer's PII into another ticket is blocked." + }, + { + "id": "refund-floor-override", + "action_class": "refund_floor_override", + "level": "confirm", + "reason": "Refund-floor overrides require explicit confirmation." + }, + { + "id": "auto-close-without-confirm", + "action_class": "auto_close_without_customer_confirm", + "level": "confirm", + "reason": "Auto-closing a ticket without customer confirmation requires confirmation." + } + ] + }, + "router_cost": { + "tokens_estimate": 1100, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/customer_support_operator are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/data-analyst.klickd b/packages/@klickd/core/x-klickd-skills/data-analyst.klickd new file mode 100644 index 0000000..56ba9b3 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/data-analyst.klickd @@ -0,0 +1,393 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "data_analysis", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B22). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/data_analyst", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b22", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/data_analyst", + "frameworks": [ + "esco", + "sfia", + "onet", + "wef" + ], + "competency_ids": [ + "esco:S5.5", + "esco:S2.0", + "sfia:DTAN", + "sfia:INAN", + "onet:15-2051.00", + "wef:analytical-thinking", + "wef:ai-and-big-data" + ], + "gate_summaries": [ + { + "id": "production-query", + "level": "confirm" + }, + { + "id": "deanonymisation-skip", + "level": "block" + }, + { + "id": "metric-definition-override", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/research" + ], + "target_user": "Data analyst building dashboards, reports, and ad-hoc analyses. Statistical literacy, query discipline, reproducibility. NOT a data scientist building ML models (that's a separate scope).", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S5.5", + "scheme": "esco", + "prefLabel": "developing, programming and using software for data analysis" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "sfia:DTAN", + "scheme": "sfia", + "prefLabel": "Data analytics" + }, + { + "competency_ref": "sfia:INAN", + "scheme": "sfia", + "prefLabel": "Information analysis" + }, + { + "competency_ref": "onet:15-2051.00", + "scheme": "onet", + "prefLabel": "Data Scientists" + }, + { + "competency_ref": "wef:analytical-thinking", + "scheme": "wef", + "prefLabel": "Analytical thinking" + }, + { + "competency_ref": "wef:ai-and-big-data", + "scheme": "wef", + "prefLabel": "AI and big data" + } + ], + "competencies": [ + { + "competency_ref": "esco:S5.5", + "scheme": "esco", + "prefLabel": "developing, programming and using software for data analysis" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "sfia:DTAN", + "scheme": "sfia", + "prefLabel": "Data analytics" + }, + { + "competency_ref": "sfia:INAN", + "scheme": "sfia", + "prefLabel": "Information analysis" + }, + { + "competency_ref": "onet:15-2051.00", + "scheme": "onet", + "prefLabel": "Data Scientists" + }, + { + "competency_ref": "wef:analytical-thinking", + "scheme": "wef", + "prefLabel": "Analytical thinking" + }, + { + "competency_ref": "wef:ai-and-big-data", + "scheme": "wef", + "prefLabel": "AI and big data" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.data_analyst", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.data_analyst.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.data_analyst.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.data_analyst", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/data_analyst", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:3220dcaaa9a78c592b918b05184a0069", + "attestation_hash": "sha256:babe0507f2426600ff82c2e16245d26cd4052acbd57776695e06813b2001b58d" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/data_analyst/v0-draft", + "embedding_model_ref": "klickd-embed-data_analyst-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 7, + "max_facts_per_turn": 9, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "sql", + "metric_definition", + "deanonymisation_guard", + "dashboard" + ], + "entity_classes": [ + "esco", + "sfia", + "onet", + "wef" + ], + "priority": "analytic_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "production_dataset_write", + "skip_deanonymisation_guard", + "metric_definition_silent_change" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "skip_deanonymisation_guard", + "metric_definition_silent_change" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "production-query", + "action_class": "production_dataset_write", + "level": "confirm", + "reason": "Writes against a production dataset require explicit confirmation." + }, + { + "id": "deanonymisation-skip", + "action_class": "skip_deanonymisation_guard", + "level": "block", + "reason": "Skipping de-anonymisation guards is blocked; joins that re-identify subjects must escalate." + }, + { + "id": "metric-definition-override", + "action_class": "metric_definition_silent_change", + "level": "block", + "reason": "Silent metric-definition changes are blocked; metrics must be versioned." + } + ] + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/data_analyst are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/devops-operator.klickd b/packages/@klickd/core/x-klickd-skills/devops-operator.klickd new file mode 100644 index 0000000..ad43678 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/devops-operator.klickd @@ -0,0 +1,394 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "operations", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B24). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/devops_operator", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b24", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/devops_operator", + "frameworks": [ + "esco", + "sfia", + "onet", + "nice" + ], + "competency_ids": [ + "esco:S5.6", + "esco:S5.0", + "sfia:ITOP", + "sfia:SCAD", + "sfia:AVMT", + "onet:15-1244.00", + "nice:OM-NET" + ], + "gate_summaries": [ + { + "id": "production-deploy", + "level": "confirm" + }, + { + "id": "alert-mute-prolonged", + "level": "block" + }, + { + "id": "iac-drift-ignore", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/coding", + "x.klickd/security" + ], + "target_user": "DevOps / SRE operator running CI/CD, observability, incident-readiness. Distinct from release_engineer (which focuses on supply-chain artefacts); this pack focuses on operating systems day-to-day.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "nice", + "version": "NIST SP 800-181r1", + "iri_prefix": "https://csrc.nist.gov/projects/cybersecurity-workforce-framework/", + "canonical_url": "https://niccs.cisa.gov/workforce-development/nice-framework" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT — software deployment" + }, + { + "competency_ref": "esco:S5.0", + "scheme": "esco", + "prefLabel": "ICT — generic" + }, + { + "competency_ref": "sfia:ITOP", + "scheme": "sfia", + "prefLabel": "IT infrastructure" + }, + { + "competency_ref": "sfia:SCAD", + "scheme": "sfia", + "prefLabel": "Systems and software life cycle engineering" + }, + { + "competency_ref": "sfia:AVMT", + "scheme": "sfia", + "prefLabel": "Availability management" + }, + { + "competency_ref": "onet:15-1244.00", + "scheme": "onet", + "prefLabel": "Network and Computer Systems Administrators" + }, + { + "competency_ref": "nice:OM-NET", + "scheme": "nice", + "prefLabel": "Operate and Maintain — Network Operations" + } + ], + "competencies": [ + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT — software deployment" + }, + { + "competency_ref": "esco:S5.0", + "scheme": "esco", + "prefLabel": "ICT — generic" + }, + { + "competency_ref": "sfia:ITOP", + "scheme": "sfia", + "prefLabel": "IT infrastructure" + }, + { + "competency_ref": "sfia:SCAD", + "scheme": "sfia", + "prefLabel": "Systems and software life cycle engineering" + }, + { + "competency_ref": "sfia:AVMT", + "scheme": "sfia", + "prefLabel": "Availability management" + }, + { + "competency_ref": "onet:15-1244.00", + "scheme": "onet", + "prefLabel": "Network and Computer Systems Administrators" + }, + { + "competency_ref": "nice:OM-NET", + "scheme": "nice", + "prefLabel": "Operate and Maintain — Network Operations" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.devops_operator", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.devops_operator.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.devops_operator.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.devops_operator", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/devops_operator", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:db77f7f03be3a1b03d70ff11df439e86", + "attestation_hash": "sha256:d9f6a194d4025c1d583b455d78b4febbc51ee3f969b69f4e80ba6a9ac445db68" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/devops_operator/v0-draft", + "embedding_model_ref": "klickd-embed-devops_operator-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 7, + "max_facts_per_turn": 9, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "devops", + "incident", + "deploy", + "rollback", + "observability" + ], + "entity_classes": [ + "esco", + "sfia", + "onet" + ], + "priority": "ops_operation", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "production_deploy_write", + "prolonged_alert_mute", + "infrastructure_drift_silent_apply" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "prolonged_alert_mute", + "infrastructure_drift_silent_apply" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "production-deploy", + "action_class": "production_deploy_write", + "level": "confirm", + "reason": "Production deploy writes require explicit confirmation." + }, + { + "id": "alert-mute-prolonged", + "action_class": "prolonged_alert_mute", + "level": "block", + "reason": "Prolonged alert mutes (beyond declared maintenance window) are blocked." + }, + { + "id": "iac-drift-ignore", + "action_class": "infrastructure_drift_silent_apply", + "level": "block", + "reason": "Silently applying drift to infrastructure-as-code state is blocked." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/devops_operator are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/drone-operator.klickd b/packages/@klickd/core/x-klickd-skills/drone-operator.klickd new file mode 100644 index 0000000..68fde43 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/drone-operator.klickd @@ -0,0 +1,336 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "operations", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B15). Pro tier; compact_index loading strategy declared.", + "renamed_from": "drone.klickd" + }, + "x_klickd_pack": { + "pack": "x.klickd/drone_operator", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b15", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/drone_operator", + "frameworks": [ + "esco" + ], + "competency_ids": [ + "esco:S6", + "esco:S6.4", + "esco:S4.6" + ], + "gate_summaries": [ + { + "id": "no-fly-zone-override", + "level": "block" + }, + { + "id": "first-flight-in-area", + "level": "confirm" + }, + { + "id": "minor-flight-write", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/security", + "x.klickd/legal" + ], + "target_user": "Civil drone (UAV) operator. Pre-flight discipline, airspace literacy, no-fly zones, incident reporting. Not military; not commercial heavy-lift.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + } + ], + "citation_only_references": [ + { + "id": "eu-2019-947", + "ref": "EU Regulation 2019/947 (UAS rules)", + "url": "https://eur-lex.europa.eu/eli/reg_impl/2019/947/oj" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S6", + "scheme": "esco", + "prefLabel": "transport, transportation" + }, + { + "competency_ref": "esco:S6.4", + "scheme": "esco", + "prefLabel": "operating aerial vehicles" + }, + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + } + ], + "competencies": [ + { + "competency_ref": "esco:S6", + "scheme": "esco", + "prefLabel": "transport, transportation" + }, + { + "competency_ref": "esco:S6.4", + "scheme": "esco", + "prefLabel": "operating aerial vehicles" + }, + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.drone_operator", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.drone_operator.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.drone_operator.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.drone_operator", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/drone_operator", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:e53a157f506d5b4999213d325322d711", + "attestation_hash": "sha256:b5fcb42af348bce61c800965ed1a4fd888d7f6671153d894105666971224a68f" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/drone_operator/v0-draft", + "embedding_model_ref": "klickd-embed-drone_operator-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 5, + "max_facts_per_turn": 7, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "drone", + "easa", + "flight_plan", + "no_fly_zone", + "preflight" + ], + "entity_classes": [ + "esco", + "easa_ref" + ], + "priority": "field_operation", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "no_fly_zone_override", + "first_flight_in_area", + "flight_write_by_minor_without_guardian" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "no_fly_zone_override", + "flight_write_by_minor_without_guardian" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "no-fly-zone-override", + "action_class": "no_fly_zone_override", + "level": "block", + "reason": "No-fly-zone overrides blocked; floor not lowerable." + }, + { + "id": "first-flight-in-area", + "action_class": "first_flight_in_area", + "level": "confirm", + "reason": "First flight in a new area requires explicit confirmation." + }, + { + "id": "minor-flight-write", + "action_class": "flight_write_by_minor_without_guardian", + "level": "block", + "reason": "Flight writes by minors without guardian blocked; floor not lowerable." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/drone_operator are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/edge-ai-operator.klickd b/packages/@klickd/core/x-klickd-skills/edge-ai-operator.klickd new file mode 100644 index 0000000..5faf222 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/edge-ai-operator.klickd @@ -0,0 +1,404 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "edge_ai", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B34). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/edge_ai_operator", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b34", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/edge_ai_operator", + "frameworks": [ + "esco", + "sfia", + "onet", + "wef" + ], + "competency_ids": [ + "esco:S5.6.1", + "esco:S5.5", + "sfia:PROG", + "sfia:HSIN", + "sfia:HCEV", + "onet:17-2199.10", + "wef:ai-and-big-data", + "wef:technology-design-programming" + ], + "gate_summaries": [ + { + "id": "field-ota-without-rollback", + "level": "block" + }, + { + "id": "model-quant-silent-accuracy-drop", + "level": "block" + }, + { + "id": "safety-critical-deploy", + "level": "confirm" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/coding", + "x.klickd/security" + ], + "target_user": "Engineer deploying and operating AI models on edge devices (mobile, embedded, robotics). Latency, power, model-quantisation hygiene, on-device evaluation. Distinct from llm_agent_engineering (cloud LLM agents).", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S5.6.1", + "scheme": "esco", + "prefLabel": "developing AI and machine learning systems" + }, + { + "competency_ref": "esco:S5.5", + "scheme": "esco", + "prefLabel": "developing, programming and using software" + }, + { + "competency_ref": "sfia:PROG", + "scheme": "sfia", + "prefLabel": "Programming/software development" + }, + { + "competency_ref": "sfia:HSIN", + "scheme": "sfia", + "prefLabel": "Systems integration and build" + }, + { + "competency_ref": "sfia:HCEV", + "scheme": "sfia", + "prefLabel": "User experience evaluation" + }, + { + "competency_ref": "onet:17-2199.10", + "scheme": "onet", + "prefLabel": "Robotics Engineers" + }, + { + "competency_ref": "wef:ai-and-big-data", + "scheme": "wef", + "prefLabel": "AI and big data" + }, + { + "competency_ref": "wef:technology-design-programming", + "scheme": "wef", + "prefLabel": "Technology design and programming" + } + ], + "competencies": [ + { + "competency_ref": "esco:S5.6.1", + "scheme": "esco", + "prefLabel": "developing AI and machine learning systems" + }, + { + "competency_ref": "esco:S5.5", + "scheme": "esco", + "prefLabel": "developing, programming and using software" + }, + { + "competency_ref": "sfia:PROG", + "scheme": "sfia", + "prefLabel": "Programming/software development" + }, + { + "competency_ref": "sfia:HSIN", + "scheme": "sfia", + "prefLabel": "Systems integration and build" + }, + { + "competency_ref": "sfia:HCEV", + "scheme": "sfia", + "prefLabel": "User experience evaluation" + }, + { + "competency_ref": "onet:17-2199.10", + "scheme": "onet", + "prefLabel": "Robotics Engineers" + }, + { + "competency_ref": "wef:ai-and-big-data", + "scheme": "wef", + "prefLabel": "AI and big data" + }, + { + "competency_ref": "wef:technology-design-programming", + "scheme": "wef", + "prefLabel": "Technology design and programming" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.edge_ai_operator", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.edge_ai_operator.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.edge_ai_operator.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.edge_ai_operator", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/edge_ai_operator", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:17676a2ed3d1917072e808aa72efe0ad", + "attestation_hash": "sha256:44aa19eb9953994ab873ca36570a62ba252634e4796a6a2734f612e669838f90" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/edge_ai_operator/v0-draft", + "embedding_model_ref": "klickd-embed-edge_ai_operator-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "edge_inference", + "model_pinning", + "latency_budget", + "device_fleet" + ], + "entity_classes": [ + "esco", + "sfia", + "onet" + ], + "priority": "ops_operation", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "ota_deploy_without_rollback", + "quantisation_silent_accuracy_drop", + "safety_critical_edge_deploy" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "ota_deploy_without_rollback", + "quantisation_silent_accuracy_drop" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "field-ota-without-rollback", + "action_class": "ota_deploy_without_rollback", + "level": "block", + "reason": "OTA deploys without a rollback path are blocked." + }, + { + "id": "model-quant-silent-accuracy-drop", + "action_class": "quantisation_silent_accuracy_drop", + "level": "block", + "reason": "Quantisation that drops accuracy below declared floor without escalation is blocked." + }, + { + "id": "safety-critical-deploy", + "action_class": "safety_critical_edge_deploy", + "level": "confirm", + "reason": "Safety-critical edge deploys (medical / vehicular / industrial) require explicit confirmation." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/edge_ai_operator are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/eu-ai-act.klickd b/packages/@klickd/core/x-klickd-skills/eu-ai-act.klickd new file mode 100644 index 0000000..10075bf --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/eu-ai-act.klickd @@ -0,0 +1,338 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "legal", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B6). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/eu_ai_act", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b6", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/eu_ai_act", + "frameworks": [ + "esco" + ], + "competency_ids": [ + "esco:S4.6", + "esco:S4.6.1", + "esco:S2.0" + ], + "gate_summaries": [ + { + "id": "compliance-attestation", + "level": "confirm" + }, + { + "id": "risk-class-downgrade", + "level": "block" + }, + { + "id": "counsel-escalation-skip", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/legal" + ], + "target_user": "Compliance officer / DPO / engineer mapping a system to the EU AI Act. Risk class, obligations, transparency, post-market monitoring.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + } + ], + "citation_only_references": [ + { + "id": "eu-ai-act", + "ref": "Regulation (EU) 2024/1689", + "url": "https://eur-lex.europa.eu/eli/reg/2024/1689/oj" + }, + { + "id": "enisa-ai-threat", + "ref": "ENISA AI Threat Landscape", + "url": "https://www.enisa.europa.eu/topics/cybersecurity-threats/threats-and-trends" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S4.6.1", + "scheme": "esco", + "prefLabel": "regulatory compliance" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S4.6.1", + "scheme": "esco", + "prefLabel": "regulatory compliance" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.eu_ai_act", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.eu_ai_act.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.eu_ai_act.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.eu_ai_act", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/eu_ai_act", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:75e8377715968519d9d5e50288fa9f4b", + "attestation_hash": "sha256:ca20bedbe2452370fe2b0876ba86639b62732be6bc47f9a3bcecfac406a4241d" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/eu_ai_act/v0-draft", + "embedding_model_ref": "klickd-embed-eu_ai_act-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "none", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "eu_ai_act", + "risk_class", + "transparency_obligation", + "logging" + ], + "entity_classes": [ + "esco", + "eu_law_ref" + ], + "priority": "compliance_lookup", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "compliance_attestation", + "risk_class_below_evidence", + "skip_counsel_for_definitive_decision" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "risk_class_below_evidence", + "skip_counsel_for_definitive_decision" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "compliance-attestation", + "action_class": "compliance_attestation", + "level": "confirm", + "reason": "Compliance attestations require explicit confirmation." + }, + { + "id": "risk-class-downgrade", + "action_class": "risk_class_below_evidence", + "level": "block", + "reason": "Risk-class downgrade below evidence blocked; floor not lowerable." + }, + { + "id": "counsel-escalation-skip", + "action_class": "skip_counsel_for_definitive_decision", + "level": "block", + "reason": "Definitive risk-class decisions require qualified counsel; skip blocked." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/eu_ai_act are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/evidence-desk.klickd b/packages/@klickd/core/x-klickd-skills/evidence-desk.klickd new file mode 100644 index 0000000..ad9e3f6 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/evidence-desk.klickd @@ -0,0 +1,376 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "trust_and_safety", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B10). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/evidence_desk", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b10", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/evidence_desk", + "frameworks": [ + "esco", + "digcomp" + ], + "competency_ids": [ + "esco:S2.5", + "esco:S1.5", + "esco:S1.5.1", + "digcomp:1.2", + "digcomp:1.3", + "digcomp:4.2" + ], + "gate_summaries": [ + { + "id": "source-identity-reveal", + "level": "block" + }, + { + "id": "public-attribution", + "level": "confirm" + }, + { + "id": "editor-counsel-skip", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/research", + "x.klickd/trust_evidence" + ], + "target_user": "Operator running an evidence-intake / triage desk (journalism investigations, OSINT, civic accountability). Submission triage, source protection, claim grounding, chain-of-custody.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "digcomp", + "version": "2.2" + } + ], + "transversal_refs": [ + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S2.5", + "scheme": "esco", + "prefLabel": "investigating and reporting" + }, + { + "competency_ref": "esco:S1.5", + "scheme": "esco", + "prefLabel": "performing artistic work" + }, + { + "competency_ref": "esco:S1.5.1", + "scheme": "esco", + "prefLabel": "investigative journalism" + }, + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "digcomp:1.3", + "scheme": "digcomp", + "prefLabel": "Managing data, information and digital content" + }, + { + "competency_ref": "digcomp:4.2", + "scheme": "digcomp", + "prefLabel": "Protecting personal data and privacy" + } + ], + "competencies": [ + { + "competency_ref": "esco:S2.5", + "scheme": "esco", + "prefLabel": "investigating and reporting" + }, + { + "competency_ref": "esco:S1.5", + "scheme": "esco", + "prefLabel": "performing artistic work" + }, + { + "competency_ref": "esco:S1.5.1", + "scheme": "esco", + "prefLabel": "investigative journalism" + }, + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "digcomp:1.3", + "scheme": "digcomp", + "prefLabel": "Managing data, information and digital content" + }, + { + "competency_ref": "digcomp:4.2", + "scheme": "digcomp", + "prefLabel": "Protecting personal data and privacy" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.evidence_desk", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.evidence_desk.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.evidence_desk.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.evidence_desk", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/evidence_desk", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:baa7bc1f2a89289e53952878605fbe68", + "attestation_hash": "sha256:9162170c2bd6e956d76df35fac05639e9a42d639ba4ea2b28e586007d12f1981" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/evidence_desk/v0-draft", + "embedding_model_ref": "klickd-embed-evidence_desk-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "evidence", + "chain_of_custody", + "attestation", + "verification_artifact" + ], + "entity_classes": [ + "esco", + "sfia" + ], + "priority": "evidence_handling", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "source_identity_reveal", + "public_attribution_write", + "skip_editor_counsel_before_public_release" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "source_identity_reveal", + "skip_editor_counsel_before_public_release" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "source-identity-reveal", + "action_class": "source_identity_reveal", + "level": "block", + "reason": "Source identity reveal blocked; floor not lowerable." + }, + { + "id": "public-attribution", + "action_class": "public_attribution_write", + "level": "confirm", + "reason": "Public attribution writes require explicit confirmation." + }, + { + "id": "editor-counsel-skip", + "action_class": "skip_editor_counsel_before_public_release", + "level": "block", + "reason": "Editor / counsel escalation skip blocked before public release." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/evidence_desk are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/finance-analyst.klickd b/packages/@klickd/core/x-klickd-skills/finance-analyst.klickd new file mode 100644 index 0000000..c119742 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/finance-analyst.klickd @@ -0,0 +1,382 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "finance", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B28). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/finance_analyst", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b28", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/finance_analyst", + "frameworks": [ + "esco", + "sfia", + "onet", + "wef" + ], + "competency_ids": [ + "esco:S4.0", + "esco:S4.0.2", + "sfia:FMIT", + "sfia:METL", + "onet:13-2051.00", + "wef:analytical-thinking" + ], + "gate_summaries": [ + { + "id": "forecast-publish-external", + "level": "confirm" + }, + { + "id": "model-assumption-silent-change", + "level": "block" + }, + { + "id": "regulated-investment-advice", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/work" + ], + "target_user": "Corporate / FP&A finance analyst building forecasts, budgets, variance analyses for a company. NOT personal financial advice; NOT regulated investment advice.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.0", + "scheme": "esco", + "prefLabel": "management" + }, + { + "competency_ref": "esco:S4.0.2", + "scheme": "esco", + "prefLabel": "controlling, monitoring activities, resources" + }, + { + "competency_ref": "sfia:FMIT", + "scheme": "sfia", + "prefLabel": "Financial management" + }, + { + "competency_ref": "sfia:METL", + "scheme": "sfia", + "prefLabel": "Methods and tools" + }, + { + "competency_ref": "onet:13-2051.00", + "scheme": "onet", + "prefLabel": "Financial and Investment Analysts" + }, + { + "competency_ref": "wef:analytical-thinking", + "scheme": "wef", + "prefLabel": "Analytical thinking" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4.0", + "scheme": "esco", + "prefLabel": "management" + }, + { + "competency_ref": "esco:S4.0.2", + "scheme": "esco", + "prefLabel": "controlling, monitoring activities, resources" + }, + { + "competency_ref": "sfia:FMIT", + "scheme": "sfia", + "prefLabel": "Financial management" + }, + { + "competency_ref": "sfia:METL", + "scheme": "sfia", + "prefLabel": "Methods and tools" + }, + { + "competency_ref": "onet:13-2051.00", + "scheme": "onet", + "prefLabel": "Financial and Investment Analysts" + }, + { + "competency_ref": "wef:analytical-thinking", + "scheme": "wef", + "prefLabel": "Analytical thinking" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.finance_analyst", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.finance_analyst.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.finance_analyst.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.finance_analyst", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/finance_analyst", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:8905b2ce9b4cb7c7a036a83c49facec3", + "attestation_hash": "sha256:fcef7d627c8b43c8b7b999044a0cb602805cf817ff2fc662dd18c4c63ed382bf" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/finance_analyst/v0-draft", + "embedding_model_ref": "klickd-embed-finance_analyst-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 7, + "max_facts_per_turn": 9, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "finance", + "valuation", + "scenario", + "kpi", + "forecast" + ], + "entity_classes": [ + "esco", + "sfia", + "onet" + ], + "priority": "analytic_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "external_forecast_publication", + "model_assumption_silent_change", + "regulated_investment_advice_output" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "model_assumption_silent_change", + "regulated_investment_advice_output" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "forecast-publish-external", + "action_class": "external_forecast_publication", + "level": "confirm", + "reason": "Publishing a forecast externally (investor / press) requires confirmation." + }, + { + "id": "model-assumption-silent-change", + "action_class": "model_assumption_silent_change", + "level": "block", + "reason": "Silent changes to forecast-model assumptions are blocked; assumptions must be versioned." + }, + { + "id": "regulated-investment-advice", + "action_class": "regulated_investment_advice_output", + "level": "block", + "reason": "Output resembling regulated investment advice is blocked; escalate to licensed advisor." + } + ] + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/finance_analyst are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/game-design.klickd b/packages/@klickd/core/x-klickd-skills/game-design.klickd new file mode 100644 index 0000000..1be322e --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/game-design.klickd @@ -0,0 +1,397 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "creative", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B17). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/game_design", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b17", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/game_design", + "frameworks": [ + "esco", + "sfia", + "onet", + "wef" + ], + "competency_ids": [ + "esco:S1.0", + "esco:S5.6.3", + "sfia:DESN", + "sfia:RFEN", + "onet:15-1255.00", + "wef:creativity-originality-initiative" + ], + "gate_summaries": [ + { + "id": "monetisation-affecting-minors", + "level": "confirm" + }, + { + "id": "accessibility-review-disable", + "level": "block" + }, + { + "id": "rating-self-class-disable", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/creator", + "x.klickd/coding" + ], + "target_user": "Game designer / systems designer. Mechanic / dynamic / aesthetic literacy, playtesting discipline, accessibility, rating literacy. Distinct from x.klickd/game_literacy by author-vs-reader axis.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + } + ], + "citation_only_references": [ + { + "id": "pegi", + "ref": "PEGI Pan-European Game Information", + "url": "https://pegi.info/" + }, + { + "id": "esrb", + "ref": "ESRB Entertainment Software Rating Board", + "url": "https://www.esrb.org/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "sfia", + "version": "8" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "creativity and innovation" + }, + { + "competency_ref": "esco:S5.6.3", + "scheme": "esco", + "prefLabel": "ICT game development" + }, + { + "competency_ref": "sfia:DESN", + "scheme": "sfia", + "prefLabel": "Systems design" + }, + { + "competency_ref": "sfia:RFEN", + "scheme": "sfia", + "prefLabel": "Requirements engineering" + }, + { + "competency_ref": "onet:15-1255.00", + "scheme": "onet", + "prefLabel": "Web and Digital Interface Designers" + }, + { + "competency_ref": "wef:creativity-originality-initiative", + "scheme": "wef", + "prefLabel": "Creativity, originality and initiative" + } + ], + "competencies": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "creativity and innovation" + }, + { + "competency_ref": "esco:S5.6.3", + "scheme": "esco", + "prefLabel": "ICT game development" + }, + { + "competency_ref": "sfia:DESN", + "scheme": "sfia", + "prefLabel": "Systems design" + }, + { + "competency_ref": "sfia:RFEN", + "scheme": "sfia", + "prefLabel": "Requirements engineering" + }, + { + "competency_ref": "onet:15-1255.00", + "scheme": "onet", + "prefLabel": "Web and Digital Interface Designers" + }, + { + "competency_ref": "wef:creativity-originality-initiative", + "scheme": "wef", + "prefLabel": "Creativity, originality and initiative" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.game_design", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.game_design.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.game_design.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.game_design", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/game_design", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:f274dd8b814db6b641a282aeb56188d9", + "attestation_hash": "sha256:ff608554fdb92f37cad714bd83405c6fb23fd47bb36e5d1917770664ff9f4889" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/game_design/v0-draft", + "embedding_model_ref": "klickd-embed-game_design-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 5, + "max_facts_per_turn": 7, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "game_design", + "loop_design", + "monetisation_pattern", + "balance" + ], + "entity_classes": [ + "esco", + "onet" + ], + "priority": "creative_practice", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "monetisation_design_affecting_minors", + "disable_accessibility_review", + "disable_rating_self_classification" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "disable_accessibility_review", + "disable_rating_self_classification" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "monetisation-affecting-minors", + "action_class": "monetisation_design_affecting_minors", + "level": "confirm", + "reason": "Monetisation design affecting minors requires explicit confirmation." + }, + { + "id": "accessibility-review-disable", + "action_class": "disable_accessibility_review", + "level": "block", + "reason": "Accessibility review disables blocked; floor not lowerable." + }, + { + "id": "rating-self-class-disable", + "action_class": "disable_rating_self_classification", + "level": "block", + "reason": "Rating self-classification disables blocked; floor not lowerable." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/game_design are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/game-literacy.klickd b/packages/@klickd/core/x-klickd-skills/game-literacy.klickd new file mode 100644 index 0000000..45ae0ab --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/game-literacy.klickd @@ -0,0 +1,297 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "media_literacy", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "lite", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact. Lot A game-literacy pack, distinct from x.klickd/gaming (P1) and x.klickd/game_design (B17)." + }, + "x_klickd_pack": { + "pack": "x.klickd/game_literacy", + "pack_version": "0.1.0-candidate-lite", + "spec_ref": "x.klickd/v4.1#a12", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "lite", + "parent_packs": [ + "x.klickd/user", + "x.klickd/gaming" + ], + "target_user": "General-public carrier learning to read games as media: genres, rules, mechanics, time-budget hygiene. Not competitive play; not game development.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "digcomp", + "version": "2.2" + } + ], + "transversal_refs": [ + { + "competency_ref": "wef:complex-problem-solving", + "scheme": "wef", + "prefLabel": "Complex problem solving" + }, + { + "competency_ref": "digcomp:4.3", + "scheme": "digcomp", + "prefLabel": "Protecting health and well-being" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "creativity and innovation" + }, + { + "competency_ref": "wef:complex-problem-solving", + "scheme": "wef", + "prefLabel": "Complex problem solving" + }, + { + "competency_ref": "digcomp:4.3", + "scheme": "digcomp", + "prefLabel": "Protecting health and well-being" + }, + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + } + ], + "competencies": [ + { + "competency_ref": "wef:complex-problem-solving", + "scheme": "wef", + "prefLabel": "Complex problem solving" + }, + { + "competency_ref": "digcomp:4.3", + "scheme": "digcomp", + "prefLabel": "Protecting health and well-being" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/3", + "level_label": "EQF level 3", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.game_literacy", + "memory_segments": [ + { + "id": "play-log", + "scope": "memory.x_klickd.game_literacy.play_log", + "policy": "pointer_only_summary" + }, + { + "id": "time-budget", + "scope": "memory.x_klickd.game_literacy.time_budget", + "policy": "self_declared" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.game_literacy", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/game_literacy", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:52fee9581a77631f14f6af64e3d1f3cc", + "attestation_hash": "sha256:e6556f50c2073708281df17798a265b1c3b4a7415b295915f3c59da99a4dad3b" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/game_literacy/v0-draft", + "embedding_model_ref": "klickd-embed-game_literacy-2026-v0-placeholder", + "dim": 384, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 4, + "max_facts_per_turn": 5, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "gaming", + "spend_control", + "design_pattern", + "minor_safety" + ], + "entity_classes": [ + "esco", + "digcomp" + ], + "priority": "literacy_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier_with_guardian_if_minor", + "scope": [ + "in_game_purchase", + "time_budget_override" + ] + } + }, + "human_veto": { + "owner": "human_carrier_with_guardian_if_minor", + "raise_only": true, + "non_lowerable_floor": [ + "in_game_purchase_minor" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier_with_guardian_if_minor", + "agent_role": "advisory", + "escalation": "guardian_if_minor" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "in-game-purchase", + "action_class": "in_game_purchase", + "level": "confirm", + "reason": "In-game purchases require explicit confirmation." + }, + { + "id": "time-budget", + "action_class": "time_budget_override", + "level": "confirm", + "reason": "Time-budget overrides require confirmation; carrier MAY set the limit, pack does not lower it." + } + ] + }, + "router_cost": { + "tokens_estimate": 720, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into ESCO, WEF, or DigComp.", + "Minor carriers default to human_carrier_with_guardian.", + "Time-budget posture declared; pack does not lower carrier-set limit.", + "Pointer-only evidence; no inline screenshots.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == lite and tokens_estimate <= 900" + ], + "review": [ + "Reviewer verifies in-game-purchase gate stays confirm or stricter for minors.", + "Reviewer verifies time_budget is self-declared, not pack-imposed." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/gdpr-readiness.klickd b/packages/@klickd/core/x-klickd-skills/gdpr-readiness.klickd new file mode 100644 index 0000000..322ee25 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/gdpr-readiness.klickd @@ -0,0 +1,344 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "legal", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B7). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/gdpr_readiness", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b7", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/gdpr_readiness", + "frameworks": [ + "esco" + ], + "competency_ids": [ + "esco:S4.6", + "esco:S4.6.2", + "esco:S2.0" + ], + "gate_summaries": [ + { + "id": "dpia-write", + "level": "confirm" + }, + { + "id": "transfer-mechanism-skip", + "level": "block" + }, + { + "id": "dpo-escalation-skip", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/legal" + ], + "target_user": "DPO / privacy engineer running a GDPR-readiness assessment. Art. 30 records, DPIA, data-subject rights, transfer mechanisms.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + } + ], + "citation_only_references": [ + { + "id": "gdpr", + "ref": "Regulation (EU) 2016/679 (GDPR)", + "url": "https://eur-lex.europa.eu/eli/reg/2016/679/oj" + }, + { + "id": "edpb-guidelines", + "ref": "European Data Protection Board guidelines", + "url": "https://www.edpb.europa.eu/our-work-tools/general-guidance_en" + }, + { + "id": "enisa-handbook", + "ref": "ENISA Handbook on Security of Personal Data Processing", + "url": "https://www.enisa.europa.eu/publications/handbook-on-security-of-personal-data-processing" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S4.6.2", + "scheme": "esco", + "prefLabel": "data protection" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S4.6.2", + "scheme": "esco", + "prefLabel": "data protection" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.gdpr_readiness", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.gdpr_readiness.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.gdpr_readiness.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.gdpr_readiness", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/gdpr_readiness", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:f60ded9822763832d01d12696990c1d6", + "attestation_hash": "sha256:0579e05d267e431ffc9943b680a1518e251c6606168984c9ae4816f2a15982c1" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/gdpr_readiness/v0-draft", + "embedding_model_ref": "klickd-embed-gdpr_readiness-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "none", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "gdpr", + "art17_erasure", + "dsar", + "lawful_basis", + "ropa" + ], + "entity_classes": [ + "esco", + "eu_law_ref" + ], + "priority": "compliance_lookup", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "dpia_write", + "skip_transfer_mechanism_check", + "skip_dpo_escalation" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "skip_transfer_mechanism_check", + "skip_dpo_escalation" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "dpia-write", + "action_class": "dpia_write", + "level": "confirm", + "reason": "DPIA / Art. 30 writes require explicit confirmation." + }, + { + "id": "transfer-mechanism-skip", + "action_class": "skip_transfer_mechanism_check", + "level": "block", + "reason": "Transfer-mechanism check skip blocked for non-EU processors." + }, + { + "id": "dpo-escalation-skip", + "action_class": "skip_dpo_escalation", + "level": "block", + "reason": "DPO escalation skip blocked for ambiguous lawful basis or retention." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/gdpr_readiness are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/healthcare-ai-safety-reviewer.klickd b/packages/@klickd/core/x-klickd-skills/healthcare-ai-safety-reviewer.klickd new file mode 100644 index 0000000..b0f96b7 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/healthcare-ai-safety-reviewer.klickd @@ -0,0 +1,382 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "healthcare_ai", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B33). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/healthcare_ai_safety_reviewer", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b33", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/healthcare_ai_safety_reviewer", + "frameworks": [ + "esco", + "enisa", + "nice" + ], + "competency_ids": [ + "esco:S4.6", + "esco:S5.6", + "esco:S2.0", + "enisa:CRM", + "nice:OV-SPP" + ], + "gate_summaries": [ + { + "id": "clinical-claim-without-trial", + "level": "block" + }, + { + "id": "mdr-classification-downgrade", + "level": "block" + }, + { + "id": "patient-pii-export", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1300, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/research", + "x.klickd/legal", + "x.klickd/security" + ], + "target_user": "Reviewer auditing an AI system intended for a healthcare setting (clinical decision support, triage assistant, scribe). Maps risk under EU AI Act + MDR. NOT a clinician; NOT a notified body.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "enisa", + "version": "ECSF 1.0", + "iri_prefix": "https://www.enisa.europa.eu/topics/skills-and-competences/ecsf/", + "canonical_url": "https://www.enisa.europa.eu/topics/skills-and-competences/ecsf" + }, + { + "scheme": "nice", + "version": "NIST SP 800-181r1", + "iri_prefix": "https://csrc.nist.gov/projects/cybersecurity-workforce-framework/", + "canonical_url": "https://niccs.cisa.gov/workforce-development/nice-framework" + } + ], + "citation_only_references": [ + { + "id": "eu-ai-act", + "ref": "EU AI Act (Regulation (EU) 2024/1689)", + "url": "https://eur-lex.europa.eu/eli/reg/2024/1689/oj" + }, + { + "id": "mdr", + "ref": "EU Medical Device Regulation (Regulation (EU) 2017/745)", + "url": "https://eur-lex.europa.eu/eli/reg/2017/745/oj" + }, + { + "id": "who-ethics-ai-health", + "ref": "WHO Ethics and Governance of AI for Health", + "url": "https://www.who.int/publications/i/item/9789240029200" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT — software analysis" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "enisa:CRM", + "scheme": "enisa", + "prefLabel": "Cybersecurity Risk Manager" + }, + { + "competency_ref": "nice:OV-SPP", + "scheme": "nice", + "prefLabel": "Oversee and Govern — Strategic Planning and Policy" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT — software analysis" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "enisa:CRM", + "scheme": "enisa", + "prefLabel": "Cybersecurity Risk Manager" + }, + { + "competency_ref": "nice:OV-SPP", + "scheme": "nice", + "prefLabel": "Oversee and Govern — Strategic Planning and Policy" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/7", + "level_label": "EQF level 7", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.healthcare_ai_safety_reviewer", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.healthcare_ai_safety_reviewer.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.healthcare_ai_safety_reviewer.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.healthcare_ai_safety_reviewer", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/healthcare_ai_safety_reviewer", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:7ce036b1e17d0aa0fe774596c955c053", + "attestation_hash": "sha256:259703bf7a62c029f1be4df2e007743d28c718fe69f733a8b662b2d07d4d2b6f" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/healthcare_ai_safety_reviewer/v0-draft", + "embedding_model_ref": "klickd-embed-healthcare_ai_safety_reviewer-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 5, + "max_facts_per_turn": 7, + "freshness_weighting": "none", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "healthcare_ai", + "clinical_risk", + "device_class", + "mdr_ivdr" + ], + "entity_classes": [ + "esco", + "eu_law_ref" + ], + "priority": "safety_review", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "clinical_efficacy_claim_without_evidence", + "mdr_risk_class_downgrade_without_evidence", + "patient_pii_export" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "clinical_efficacy_claim_without_evidence", + "mdr_risk_class_downgrade_without_evidence", + "patient_pii_export" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "clinical-claim-without-trial", + "action_class": "clinical_efficacy_claim_without_evidence", + "level": "block", + "reason": "Clinical efficacy claims without trial / regulatory evidence are blocked." + }, + { + "id": "mdr-classification-downgrade", + "action_class": "mdr_risk_class_downgrade_without_evidence", + "level": "block", + "reason": "Downgrading MDR / AI Act risk class without evidence is blocked." + }, + { + "id": "patient-pii-export", + "action_class": "patient_pii_export", + "level": "block", + "reason": "Exporting patient PII outside declared lawful basis is blocked." + } + ] + }, + "router_cost": { + "tokens_estimate": 1300, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/healthcare_ai_safety_reviewer are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/identity-access-management.klickd b/packages/@klickd/core/x-klickd-skills/identity-access-management.klickd new file mode 100644 index 0000000..4b171e8 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/identity-access-management.klickd @@ -0,0 +1,380 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "security", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B3). Pro tier; compact_index loading strategy declared. Scoped to identity & access (NICE Identity Management + ENISA + CIS controls 5/6). Endpoint-hardening (CIS control 9 etc.) is intentionally out of scope.", + "renamed_from": "iam-endpoint.klickd" + }, + "x_klickd_pack": { + "pack": "x.klickd/identity_access_management", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b3", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/identity_access_management", + "frameworks": [ + "nice", + "enisa", + "cis" + ], + "competency_ids": [ + "nice:identity-management", + "nice:defensive-cybersecurity", + "enisa:cyber-incident-responder", + "enisa:cybersecurity-implementer", + "cis:control-5", + "cis:control-6" + ], + "gate_summaries": [ + { + "id": "iam-write", + "level": "confirm" + }, + { + "id": "mfa-downgrade", + "level": "block" + }, + { + "id": "session-token-inline", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/security" + ], + "target_user": "Identity & access engineer covering account/access management, MFA, hardware-token discipline, and session hygiene. Endpoint-hardening competencies (EDR/MDM/email-and-web protections) are out of scope for this pack; they live in x.klickd/security and possibly a future endpoint-hardening pack.", + "frameworks": [ + { + "scheme": "nice", + "version": "r1", + "iri_prefix": "https://niccs.cisa.gov/workforce-development/nice-framework/", + "canonical_url": "https://niccs.cisa.gov/workforce-development/nice-framework" + }, + { + "scheme": "enisa", + "version": "1.0", + "iri_prefix": "https://www.enisa.europa.eu/topics/skills-and-competences/skills-development/european-cybersecurity-skills-framework/", + "canonical_url": "https://www.enisa.europa.eu/topics/skills-and-competences/skills-development/european-cybersecurity-skills-framework" + }, + { + "scheme": "cis", + "version": "v8", + "iri_prefix": "https://www.cisecurity.org/controls/v8/", + "canonical_url": "https://www.cisecurity.org/controls/cis-controls-list" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "nice", + "version": "r1" + }, + { + "scheme": "enisa", + "version": "1.0" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S1", + "scheme": "esco", + "prefLabel": "communication, collaboration and creativity" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "nice:identity-management", + "scheme": "nice", + "prefLabel": "Identity Management" + }, + { + "competency_ref": "nice:defensive-cybersecurity", + "scheme": "nice", + "prefLabel": "Defensive Cybersecurity" + }, + { + "competency_ref": "enisa:cyber-incident-responder", + "scheme": "enisa", + "prefLabel": "Cyber Incident Responder" + }, + { + "competency_ref": "enisa:cybersecurity-implementer", + "scheme": "enisa", + "prefLabel": "Cybersecurity Implementer" + }, + { + "competency_ref": "cis:control-5", + "scheme": "cis", + "prefLabel": "Account Management" + }, + { + "competency_ref": "cis:control-6", + "scheme": "cis", + "prefLabel": "Access Control Management" + } + ], + "competencies": [ + { + "competency_ref": "nice:identity-management", + "scheme": "nice", + "prefLabel": "Identity Management" + }, + { + "competency_ref": "nice:defensive-cybersecurity", + "scheme": "nice", + "prefLabel": "Defensive Cybersecurity" + }, + { + "competency_ref": "enisa:cyber-incident-responder", + "scheme": "enisa", + "prefLabel": "Cyber Incident Responder" + }, + { + "competency_ref": "enisa:cybersecurity-implementer", + "scheme": "enisa", + "prefLabel": "Cybersecurity Implementer" + }, + { + "competency_ref": "cis:control-5", + "scheme": "cis", + "prefLabel": "Account Management" + }, + { + "competency_ref": "cis:control-6", + "scheme": "cis", + "prefLabel": "Access Control Management" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.identity_access_management", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.identity_access_management.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.identity_access_management.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.identity_access_management", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/identity_access_management", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:07aa3f55803e07ff80ca6c58f943962c", + "attestation_hash": "sha256:8f0eae4f9464762ab6f8478045324f06eb0e87d7aae237a08fbeff0460068440" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/identity_access_management/v0-draft", + "embedding_model_ref": "klickd-embed-identity_access_management-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "iam", + "rbac", + "abac", + "session_lifecycle", + "key_rotation" + ], + "entity_classes": [ + "esco", + "sfia", + "nice" + ], + "priority": "security_operation", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "iam_write", + "mfa_downgrade", + "session_token_inline" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "mfa_downgrade", + "session_token_inline" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "iam-write", + "action_class": "iam_write", + "level": "confirm", + "reason": "IAM writes affect blast radius; confirm required." + }, + { + "id": "mfa-downgrade", + "action_class": "mfa_downgrade", + "level": "block", + "reason": "MFA / hardware-token requirement downgrade blocked; floor not lowerable." + }, + { + "id": "session-token-inline", + "action_class": "session_token_inline", + "level": "block", + "reason": "Session tokens never inline." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/identity_access_management are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/learning-designer.klickd b/packages/@klickd/core/x-klickd-skills/learning-designer.klickd new file mode 100644 index 0000000..ff775a3 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/learning-designer.klickd @@ -0,0 +1,391 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "education", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B31). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/learning_designer", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b31", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/learning_designer", + "frameworks": [ + "esco", + "digcomp", + "onet", + "lifecomp" + ], + "competency_ids": [ + "esco:S1.6", + "esco:S2.0", + "digcomp:3.1", + "digcomp:5.3", + "onet:25-9031.00", + "lifecomp:L1", + "lifecomp:L3" + ], + "gate_summaries": [ + { + "id": "accessibility-skip", + "level": "block" + }, + { + "id": "minor-learner-pii", + "level": "block" + }, + { + "id": "high-stakes-assessment", + "level": "confirm" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/research" + ], + "target_user": "Learning experience designer / instructional designer building curricula, courses, assessments. Constructive alignment, accessibility, evidence-grounded outcomes. NOT a host-side tutor (that's host_skill).", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://publications.jrc.ec.europa.eu/repository/handle/JRC128415/", + "canonical_url": "https://publications.jrc.ec.europa.eu/repository/handle/JRC128415" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "lifecomp", + "version": "2020", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/lifecomp/2020/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/lifecomp_en" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S1.6", + "scheme": "esco", + "prefLabel": "training, coaching, teaching" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "digcomp:3.1", + "scheme": "digcomp", + "prefLabel": "Developing digital content" + }, + { + "competency_ref": "digcomp:5.3", + "scheme": "digcomp", + "prefLabel": "Creatively using digital technologies" + }, + { + "competency_ref": "onet:25-9031.00", + "scheme": "onet", + "prefLabel": "Instructional Coordinators" + }, + { + "competency_ref": "lifecomp:L1", + "scheme": "lifecomp", + "prefLabel": "Growth mindset" + }, + { + "competency_ref": "lifecomp:L3", + "scheme": "lifecomp", + "prefLabel": "Managing learning" + } + ], + "competencies": [ + { + "competency_ref": "esco:S1.6", + "scheme": "esco", + "prefLabel": "training, coaching, teaching" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "digcomp:3.1", + "scheme": "digcomp", + "prefLabel": "Developing digital content" + }, + { + "competency_ref": "digcomp:5.3", + "scheme": "digcomp", + "prefLabel": "Creatively using digital technologies" + }, + { + "competency_ref": "onet:25-9031.00", + "scheme": "onet", + "prefLabel": "Instructional Coordinators" + }, + { + "competency_ref": "lifecomp:L1", + "scheme": "lifecomp", + "prefLabel": "Growth mindset" + }, + { + "competency_ref": "lifecomp:L3", + "scheme": "lifecomp", + "prefLabel": "Managing learning" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/7", + "level_label": "EQF level 7", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.learning_designer", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.learning_designer.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.learning_designer.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.learning_designer", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/learning_designer", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:a834db6ff63350a74dfb519ea3e537ba", + "attestation_hash": "sha256:fe82dcf3012ca6f6f6f271247dc52f7ba48d9c40d88ab6064bf3fe34ec57589d" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/learning_designer/v0-draft", + "embedding_model_ref": "klickd-embed-learning_designer-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "instructional_design", + "learning_objective", + "assessment", + "scaffold" + ], + "entity_classes": [ + "esco", + "eqf" + ], + "priority": "design_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "skip_accessibility_review", + "minor_learner_pii_write", + "high_stakes_assessment_publish" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "skip_accessibility_review", + "minor_learner_pii_write" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "accessibility-skip", + "action_class": "skip_accessibility_review", + "level": "block", + "reason": "Skipping accessibility review on a published learning artefact is blocked." + }, + { + "id": "minor-learner-pii", + "action_class": "minor_learner_pii_write", + "level": "block", + "reason": "Inline PII of minor learners is blocked." + }, + { + "id": "high-stakes-assessment", + "action_class": "high_stakes_assessment_publish", + "level": "confirm", + "reason": "Publishing a high-stakes assessment requires confirmation against the validity evidence." + } + ] + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/learning_designer are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/literature-review.klickd b/packages/@klickd/core/x-klickd-skills/literature-review.klickd new file mode 100644 index 0000000..4038339 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/literature-review.klickd @@ -0,0 +1,348 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "research", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B13). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/literature_review", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b13", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/literature_review", + "frameworks": [ + "esco", + "digcomp" + ], + "competency_ids": [ + "esco:S2.5", + "esco:S2.5.1", + "digcomp:1.2", + "digcomp:1.3" + ], + "gate_summaries": [ + { + "id": "inclusion-exclusion-write", + "level": "confirm" + }, + { + "id": "risk-of-bias-solo", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/research" + ], + "target_user": "Researcher / postgraduate carrier running a systematic-or-narrative literature review. Search strategy, inclusion criteria, risk-of-bias assessment, citation hygiene.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + } + ], + "citation_only_references": [ + { + "id": "prisma-2020", + "ref": "PRISMA 2020", + "url": "http://www.prisma-statement.org/PRISMAStatement/PRISMAStatement" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "digcomp", + "version": "2.2" + } + ], + "transversal_refs": [ + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S2.5", + "scheme": "esco", + "prefLabel": "investigating and reporting" + }, + { + "competency_ref": "esco:S2.5.1", + "scheme": "esco", + "prefLabel": "literature review" + }, + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "digcomp:1.3", + "scheme": "digcomp", + "prefLabel": "Managing data, information and digital content" + } + ], + "competencies": [ + { + "competency_ref": "esco:S2.5", + "scheme": "esco", + "prefLabel": "investigating and reporting" + }, + { + "competency_ref": "esco:S2.5.1", + "scheme": "esco", + "prefLabel": "literature review" + }, + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "digcomp:1.3", + "scheme": "digcomp", + "prefLabel": "Managing data, information and digital content" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.literature_review", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.literature_review.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.literature_review.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.literature_review", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/literature_review", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:250160a379ff99a0f02a0a5a723a642f", + "attestation_hash": "sha256:ac834224f9b4b91f0b44bfb781416924f89e63ba9ca4b2056831efb260aaadc5" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/literature_review/v0-draft", + "embedding_model_ref": "klickd-embed-literature_review-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 7, + "max_facts_per_turn": 9, + "freshness_weighting": "none", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "literature", + "systematic_review", + "prisma", + "citation" + ], + "entity_classes": [ + "esco", + "onet" + ], + "priority": "research_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "inclusion_exclusion_write", + "risk_of_bias_solo_assessment" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "risk_of_bias_solo_assessment" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "inclusion-exclusion-write", + "action_class": "inclusion_exclusion_write", + "level": "confirm", + "reason": "Inclusion / exclusion writes require explicit confirmation." + }, + { + "id": "risk-of-bias-solo", + "action_class": "risk_of_bias_solo_assessment", + "level": "block", + "reason": "Risk-of-bias solo assessment blocked; second reviewer required." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/literature_review are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/llm-agent-engineering.klickd b/packages/@klickd/core/x-klickd-skills/llm-agent-engineering.klickd new file mode 100644 index 0000000..290ff57 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/llm-agent-engineering.klickd @@ -0,0 +1,398 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "software_engineering", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B2). Pro tier; compact_index loading strategy declared.", + "renamed_from": "ai-agent-builder.klickd" + }, + "x_klickd_pack": { + "pack": "x.klickd/llm_agent_engineering", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b2", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/llm_agent_engineering", + "frameworks": [ + "esco", + "sfia", + "onet", + "wef" + ], + "competency_ids": [ + "esco:S5.6.1", + "sfia:PROG", + "sfia:ARCH", + "sfia:METL", + "onet:15-1252.00", + "wef:ai-and-big-data", + "wef:programming" + ], + "gate_summaries": [ + { + "id": "agent-deployment", + "level": "confirm" + }, + { + "id": "eval-gating-disable", + "level": "block" + }, + { + "id": "cost-budget-override", + "level": "confirm" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/coding", + "x.klickd/llm_agent_security" + ], + "target_user": "Developer building production LLM agents. Tool design, eval harness, observability, cost discipline.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "sfia", + "version": "8" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S5.6.1", + "scheme": "esco", + "prefLabel": "developing AI and machine learning systems" + }, + { + "competency_ref": "sfia:PROG", + "scheme": "sfia", + "prefLabel": "Programming/software development" + }, + { + "competency_ref": "sfia:ARCH", + "scheme": "sfia", + "prefLabel": "Solution architecture" + }, + { + "competency_ref": "sfia:METL", + "scheme": "sfia", + "prefLabel": "Methods and tools" + }, + { + "competency_ref": "onet:15-1252.00", + "scheme": "onet", + "prefLabel": "Software Developers" + }, + { + "competency_ref": "wef:ai-and-big-data", + "scheme": "wef", + "prefLabel": "AI and big data" + }, + { + "competency_ref": "wef:programming", + "scheme": "wef", + "prefLabel": "Programming" + } + ], + "competencies": [ + { + "competency_ref": "esco:S5.6.1", + "scheme": "esco", + "prefLabel": "developing AI and machine learning systems" + }, + { + "competency_ref": "sfia:PROG", + "scheme": "sfia", + "prefLabel": "Programming/software development" + }, + { + "competency_ref": "sfia:ARCH", + "scheme": "sfia", + "prefLabel": "Solution architecture" + }, + { + "competency_ref": "sfia:METL", + "scheme": "sfia", + "prefLabel": "Methods and tools" + }, + { + "competency_ref": "onet:15-1252.00", + "scheme": "onet", + "prefLabel": "Software Developers" + }, + { + "competency_ref": "wef:ai-and-big-data", + "scheme": "wef", + "prefLabel": "AI and big data" + }, + { + "competency_ref": "wef:programming", + "scheme": "wef", + "prefLabel": "Programming" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.llm_agent_engineering", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.llm_agent_engineering.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.llm_agent_engineering.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.llm_agent_engineering", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/llm_agent_engineering", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:c9702fb4d102ff3ba0e1dc325e1aee5e", + "attestation_hash": "sha256:400756ab3a65fe8fb53a347114b49e8fb140659ee7a3d62d74dbba247f67a873" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/llm_agent_engineering/v0-draft", + "embedding_model_ref": "klickd-embed-llm_agent_engineering-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 7, + "max_facts_per_turn": 9, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "agent", + "tool_use", + "router", + "eval_harness", + "regression" + ], + "entity_classes": [ + "esco", + "sfia", + "onet" + ], + "priority": "engineering_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "agent_deployment", + "disable_eval_gating_on_model_bump", + "cost_budget_override" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "disable_eval_gating_on_model_bump" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "agent-deployment", + "action_class": "agent_deployment", + "level": "confirm", + "reason": "Agent deployments are hard to reverse." + }, + { + "id": "eval-gating-disable", + "action_class": "disable_eval_gating_on_model_bump", + "level": "block", + "reason": "Eval gating disables blocked on model version bumps; floor not lowerable." + }, + { + "id": "cost-budget-override", + "action_class": "cost_budget_override", + "level": "confirm", + "reason": "Cost budget overrides require explicit attestation." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/llm_agent_engineering are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/llm-agent-security.klickd b/packages/@klickd/core/x-klickd-skills/llm-agent-security.klickd new file mode 100644 index 0000000..b732593 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/llm-agent-security.klickd @@ -0,0 +1,420 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "security", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B1). Pro tier; compact_index loading strategy declared.", + "renamed_from": "agent-security.klickd" + }, + "x_klickd_pack": { + "pack": "x.klickd/llm_agent_security", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b1", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/llm_agent_security", + "frameworks": [ + "nice", + "enisa", + "cis", + "esco" + ], + "competency_ids": [ + "nice:adversary-emulation", + "nice:secure-software-assessment", + "nice:vulnerability-assessment", + "enisa:cybersecurity-risk-manager", + "enisa:penetration-tester", + "cis:control-16", + "cis:control-18", + "esco:S5.6" + ], + "gate_summaries": [ + { + "id": "agent-deployment", + "level": "confirm" + }, + { + "id": "prompt-injection-screen-disable", + "level": "block" + }, + { + "id": "memory-write-guard-disable", + "level": "block" + }, + { + "id": "responsible-disclosure", + "level": "confirm" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/security", + "x.klickd/coding" + ], + "target_user": "Engineer / SRE / red-teamer building or operating LLM agents and MCP / tool-using systems. Prompt-injection literacy, tool-use sandboxing, eval discipline.", + "frameworks": [ + { + "scheme": "nice", + "version": "r1", + "iri_prefix": "https://niccs.cisa.gov/workforce-development/nice-framework/", + "canonical_url": "https://niccs.cisa.gov/workforce-development/nice-framework" + }, + { + "scheme": "enisa", + "version": "1.0", + "iri_prefix": "https://www.enisa.europa.eu/topics/skills-and-competences/skills-development/european-cybersecurity-skills-framework/", + "canonical_url": "https://www.enisa.europa.eu/topics/skills-and-competences/skills-development/european-cybersecurity-skills-framework" + }, + { + "scheme": "cis", + "version": "v8", + "iri_prefix": "https://www.cisecurity.org/controls/v8/", + "canonical_url": "https://www.cisecurity.org/controls/cis-controls-list" + }, + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "nice", + "version": "r1" + }, + { + "scheme": "enisa", + "version": "1.0" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "nice:adversary-emulation", + "scheme": "nice", + "prefLabel": "Adversary Emulation" + }, + { + "competency_ref": "nice:secure-software-assessment", + "scheme": "nice", + "prefLabel": "Secure Software Assessment" + }, + { + "competency_ref": "nice:vulnerability-assessment", + "scheme": "nice", + "prefLabel": "Vulnerability Assessment" + }, + { + "competency_ref": "enisa:cybersecurity-risk-manager", + "scheme": "enisa", + "prefLabel": "Cybersecurity Risk Manager" + }, + { + "competency_ref": "enisa:penetration-tester", + "scheme": "enisa", + "prefLabel": "Penetration Tester" + }, + { + "competency_ref": "cis:control-16", + "scheme": "cis", + "prefLabel": "Application Software Security" + }, + { + "competency_ref": "cis:control-18", + "scheme": "cis", + "prefLabel": "Penetration Testing" + }, + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT security" + } + ], + "competencies": [ + { + "competency_ref": "nice:adversary-emulation", + "scheme": "nice", + "prefLabel": "Adversary Emulation" + }, + { + "competency_ref": "nice:secure-software-assessment", + "scheme": "nice", + "prefLabel": "Secure Software Assessment" + }, + { + "competency_ref": "nice:vulnerability-assessment", + "scheme": "nice", + "prefLabel": "Vulnerability Assessment" + }, + { + "competency_ref": "enisa:cybersecurity-risk-manager", + "scheme": "enisa", + "prefLabel": "Cybersecurity Risk Manager" + }, + { + "competency_ref": "enisa:penetration-tester", + "scheme": "enisa", + "prefLabel": "Penetration Tester" + }, + { + "competency_ref": "cis:control-16", + "scheme": "cis", + "prefLabel": "Application Software Security" + }, + { + "competency_ref": "cis:control-18", + "scheme": "cis", + "prefLabel": "Penetration Testing" + }, + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT security" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.llm_agent_security", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.llm_agent_security.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.llm_agent_security.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.llm_agent_security", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/llm_agent_security", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:1c1d4fda631d9a0a5c96e8254beb8193", + "attestation_hash": "sha256:a84abb41a8690e74bdae73e7237557559b9334f940a07bdbae110d0a8886d5b8" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/llm_agent_security/v0-draft", + "embedding_model_ref": "klickd-embed-llm_agent_security-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 7, + "max_facts_per_turn": 9, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "prompt_injection", + "jailbreak", + "exfiltration", + "owasp_llm" + ], + "entity_classes": [ + "esco", + "nice", + "enisa_ref" + ], + "priority": "security_operation", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "agent_capability_deployment", + "disable_prompt_injection_screen", + "disable_memory_write_guard", + "vuln_disclosure" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "disable_prompt_injection_screen", + "disable_memory_write_guard" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "agent-deployment", + "action_class": "agent_capability_deployment", + "level": "confirm", + "reason": "Agent capability changes are hard to reverse once shipped." + }, + { + "id": "prompt-injection-screen-disable", + "action_class": "disable_prompt_injection_screen", + "level": "block", + "reason": "Default disables blocked; floor not lowerable by this pack." + }, + { + "id": "memory-write-guard-disable", + "action_class": "disable_memory_write_guard", + "level": "block", + "reason": "Memory-write guard disables blocked; floor not lowerable." + }, + { + "id": "responsible-disclosure", + "action_class": "vuln_disclosure", + "level": "confirm", + "reason": "Vulnerability disclosure must follow declared responsible-disclosure path." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/llm_agent_security are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/manifest.json b/packages/@klickd/core/x-klickd-skills/manifest.json new file mode 100644 index 0000000..73d85a0 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/manifest.json @@ -0,0 +1,402 @@ +{ + "manifest_version": "1.0", + "kind": "x_klickd_v4_1_download_index", + "non_normative": true, + "claims_v41_ga": false, + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "generated_at": "2026-05-28T01:00:00Z", + "hash_algo": "sha256", + "raw_url_template": "https://raw.githubusercontent.com/Davincc77/klickdskill/main/{relative_path}", + "note": "Aggregated download index for the public x.klickd v4.1 candidate skill catalog. NON-NORMATIVE. NOT GA. Each entry's `relative_path` substituted into `raw_url_template` yields a raw GitHub URL serving the byte-identical .klickd JSON whose SHA-256 is `sha256_file`. The per-tier manifests under `lite/` and `pro/` remain authoritative; this index is a convenience surface for the public site so it can link to 42 distinct raw URLs from a single hard-coded entry point.", + "tiers": { + "lite": { + "expected_count": 8, + "actual_count": 8 + }, + "pro": { + "expected_count": 34, + "actual_count": 34 + } + }, + "total_count": 42, + "packs": [ + { + "tier": "lite", + "pack": "x.klickd/artist", + "file": "artist.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/lite/artist.klickd", + "bytes": 9308, + "sha256_file": "56dbd966942475354e4f2daac48c3aeabfedbf3ff48f6248c443cdf8fe82b5c8", + "status": "candidate_mapped" + }, + { + "tier": "lite", + "pack": "x.klickd/consumer_rights", + "file": "consumer-rights.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/lite/consumer-rights.klickd", + "bytes": 9353, + "sha256_file": "16f77c9b7cb0801f198407f063c1b8395b98f6f729a14597ede8a15ae766ebbc", + "status": "candidate_mapped" + }, + { + "tier": "lite", + "pack": "x.klickd/game_literacy", + "file": "game-literacy.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/lite/game-literacy.klickd", + "bytes": 9325, + "sha256_file": "6e3158a2bde1024f54db53d149e525b820c4c167a71124416c8f4e8df38a3632", + "status": "candidate_mapped" + }, + { + "tier": "lite", + "pack": "x.klickd/media_planner", + "file": "media-planner.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/lite/media-planner.klickd", + "bytes": 9719, + "sha256_file": "a399ef56eb140d5adf272ffe3578448085f082154647811853e3d52e58b3a33e", + "status": "candidate_mapped" + }, + { + "tier": "lite", + "pack": "x.klickd/parent_gaming", + "file": "parent-gaming.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/lite/parent-gaming.klickd", + "bytes": 10149, + "sha256_file": "f2016892ac731f284d37d207a9464dcb93551b6934ff86f09d05fcd9d1a0ce52", + "status": "candidate_mapped" + }, + { + "tier": "lite", + "pack": "x.klickd/social_literacy", + "file": "social-literacy.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/lite/social-literacy.klickd", + "bytes": 9745, + "sha256_file": "5da46abae45a40adf562d1119bd4240c60d14b7c2b798e8e47aed4122834d9dc", + "status": "candidate_mapped" + }, + { + "tier": "lite", + "pack": "x.klickd/streaming_creator", + "file": "streaming-creator.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/lite/streaming-creator.klickd", + "bytes": 9332, + "sha256_file": "83a47a7370650c9870d28566344a11e52298a9e0a581003dc0ea8009558ac8ce", + "status": "candidate_mapped" + }, + { + "tier": "lite", + "pack": "x.klickd/work_assistant", + "file": "work-assistant.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/lite/work-assistant.klickd", + "bytes": 10312, + "sha256_file": "7918922d04e406c406f1d8a1a6aeaa3f82fb2a9c5697a547f001cfac85063bcb", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/accounting_operator", + "file": "accounting-operator.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/accounting-operator.klickd", + "bytes": 11371, + "sha256_file": "0464b9d8bd284e7c498a60064f8f923e148f2ac3e0e39fd7c0f479174c8ad243", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/api_integrator", + "file": "api-integrator.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/api-integrator.klickd", + "bytes": 11707, + "sha256_file": "875536c647ff1905f2e54a7997977b7d4087b7153b8b9a7c3270aef301af6dab", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/contract_review", + "file": "contract-review.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/contract-review.klickd", + "bytes": 10615, + "sha256_file": "4be316d9bbb758e9d98dcf81ac25ef1fc9a8e24d9cb6462055d66660f104ba41", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/customer_support_operator", + "file": "customer-support-operator.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/customer-support-operator.klickd", + "bytes": 12349, + "sha256_file": "9e6c755f8d975110bd8fd5bfdb1d87773f1a571968bf27933357b7bcc13516e9", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/data_analyst", + "file": "data-analyst.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/data-analyst.klickd", + "bytes": 12175, + "sha256_file": "8ae8fe5e3b55d4402e0da93738e97d23c41d3daeb93c6bdc41301486a2f6cd4f", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/devops_operator", + "file": "devops-operator.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/devops-operator.klickd", + "bytes": 12201, + "sha256_file": "bfad80b1110461f683c7000b9af1104ccdcd33a10c3059e3898dabea3f1d6fb4", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/drone_operator", + "file": "drone-operator.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/drone-operator.klickd", + "bytes": 10450, + "sha256_file": "d4017d93c8b8ac765e59914b61116bd90bd68944c4a2b47e031dafc7d562ec23", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/edge_ai_operator", + "file": "edge-ai-operator.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/edge-ai-operator.klickd", + "bytes": 12705, + "sha256_file": "295cd879168320e5af7d19a0c82a1bd0f8be52fbf9f16ec80c9db7f33b3cef6e", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/eu_ai_act", + "file": "eu-ai-act.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/eu-ai-act.klickd", + "bytes": 10507, + "sha256_file": "4df66de2930e3f4d726c08a1e0d15e64c6929f4cbbd6a593d69b9f88c5a9de93", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/evidence_desk", + "file": "evidence-desk.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/evidence-desk.klickd", + "bytes": 11765, + "sha256_file": "a1cc35277960a95ebbe12ca12c00d9d70ce71dc58cae99b642653835b90d14dd", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/finance_analyst", + "file": "finance-analyst.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/finance-analyst.klickd", + "bytes": 11950, + "sha256_file": "dbf02eac4910f73b35f818bd20545cd41f6a391ca06adf59f9470aa421afb326", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/game_design", + "file": "game-design.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/game-design.klickd", + "bytes": 12342, + "sha256_file": "0894cec1f3f54b770a16fd3f07e16817ee57e574bdb2ca0837b8653362f3abb3", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/gdpr_readiness", + "file": "gdpr-readiness.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/gdpr-readiness.klickd", + "bytes": 10671, + "sha256_file": "d5c4cb7b707fc3f028424f34149cb95300fae583f9a261dfc161914da43bbc40", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/healthcare_ai_safety_reviewer", + "file": "healthcare-ai-safety-reviewer.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/healthcare-ai-safety-reviewer.klickd", + "bytes": 12293, + "sha256_file": "183965179ebcdb7ef0f67866aa9c7364aaad1bd02996b4d0c696580ee2c6f789", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/identity_access_management", + "file": "identity-access-management.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/identity-access-management.klickd", + "bytes": 12310, + "sha256_file": "d9112c7f82733e77bc382c4ca314c2bf3112c63ca03455a7efd037b6c33cd74d", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/learning_designer", + "file": "learning-designer.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/learning-designer.klickd", + "bytes": 12206, + "sha256_file": "f7b1f5d39ee4f05261b4735a32475dee2583556681124c59b0250335729188f9", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/literature_review", + "file": "literature-review.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/literature-review.klickd", + "bytes": 10906, + "sha256_file": "104865d2750605d9261fd27208b0e19e2908861e9e5672ed453d383701a770f1", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/llm_agent_engineering", + "file": "llm-agent-engineering.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/llm-agent-engineering.klickd", + "bytes": 12164, + "sha256_file": "1649234c2859b8309c404f71f5c0db714805655cdbb714b7bdb9394644fb49f8", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/llm_agent_security", + "file": "llm-agent-security.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/llm-agent-security.klickd", + "bytes": 13319, + "sha256_file": "baed596a642f68086cabc1a76d09ba6d987231a057c8fb66f1aabb84dd137098", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/mission_control", + "file": "mission-control.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/mission-control.klickd", + "bytes": 11861, + "sha256_file": "2c2d02b4ecec40f022c4c7da0cdb3f082e588dfe11d3f14d1692dbbdba7e8ba2", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/policy_analyst", + "file": "policy-analyst.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/policy-analyst.klickd", + "bytes": 11275, + "sha256_file": "f348f1d1a73797979a51005586dcd9f1069a17fab173dab7df742290127c73a7", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/privacy_product", + "file": "privacy-product.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/privacy-product.klickd", + "bytes": 10728, + "sha256_file": "5a35d4a214a98f945f048c6647528df5ce2188aaa3d0913b7c6a1af2305eff00", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/product_manager", + "file": "product-manager.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/product-manager.klickd", + "bytes": 12231, + "sha256_file": "dbf2365508df3ae9acbbb6e002e3c44fb2a81e9166d0003cacb94a3714fdaeda", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/project_operator", + "file": "project-operator.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/project-operator.klickd", + "bytes": 11164, + "sha256_file": "5d019adfc08bcf518780bbe3e18a428682374397475a8bf6282d1e474ae6d5ce", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/release_engineer", + "file": "release-engineer.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/release-engineer.klickd", + "bytes": 12865, + "sha256_file": "c96329cff482f39d52a13b628bd027cd5854f15d40ce58c945fb58aec52aef9e", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/rights_guard", + "file": "rights-guard.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/rights-guard.klickd", + "bytes": 10347, + "sha256_file": "3efa2982479b6ba3544092d848fb52b91dc7687031c4a481181547d9728703b3", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/sales_operator", + "file": "sales-operator.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/sales-operator.klickd", + "bytes": 12186, + "sha256_file": "1bdc2c5895e07b909dda9bd04040917004727bed00198962c006a43a0be13060", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/second_brain", + "file": "second-brain.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/second-brain.klickd", + "bytes": 11153, + "sha256_file": "06504aa5dddc1b53634310210fff4374e68e0a2b959ae9dfa191b29995153bdb", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/security_incident_response", + "file": "security-incident-response.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/security-incident-response.klickd", + "bytes": 12682, + "sha256_file": "1315833cf73b3d04e00fe73006e985b0a7af7d266c457e18f61204cca09dcc7a", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/sustainability_analyst", + "file": "sustainability-analyst.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/sustainability-analyst.klickd", + "bytes": 12667, + "sha256_file": "445a7f1111e6474ca87bc717d0f50d6af5016863fe3fd87083502d77eeffcf1f", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/technical_writer", + "file": "technical-writer.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/technical-writer.klickd", + "bytes": 12150, + "sha256_file": "473c44c67a889c783872494f262feb16bdb1377a74dd5b4d605fe340ecebecc9", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/trust_evidence", + "file": "trust-evidence.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/trust-evidence.klickd", + "bytes": 11317, + "sha256_file": "57f4ac349438d3c3305e03ecf9a09a44d20e289550f8afa292267666bcc150ad", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/ux_researcher", + "file": "ux-researcher.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/ux-researcher.klickd", + "bytes": 12109, + "sha256_file": "d91afbf120c6175c4d23d175265697b7a0a7bd4f11dd60fc08bb053c8113e13e", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/video_production_pipeline", + "file": "video-production-pipeline.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/video-production-pipeline.klickd", + "bytes": 16908, + "sha256_file": "d6da8f7569953f7c6fb4f0ce02cb2649187bcbf52ae3f4d32a35c8fe885498a8", + "status": "candidate_mapped" + } + ] +} diff --git a/packages/@klickd/core/x-klickd-skills/media-planner.klickd b/packages/@klickd/core/x-klickd-skills/media-planner.klickd new file mode 100644 index 0000000..386a234 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/media-planner.klickd @@ -0,0 +1,312 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "creative", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "lite", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact. Composes with x.klickd/creator (P1); narrower planning / publishing scope for end-user creators.", + "renamed_from": "media-lite.klickd" + }, + "x_klickd_pack": { + "pack": "x.klickd/media_planner", + "pack_version": "0.1.0-candidate-lite", + "spec_ref": "x.klickd/v4.1#a4", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "lite", + "parent_packs": [ + "x.klickd/user", + "x.klickd/creator" + ], + "target_user": "End-user creator: hobbyist editor, occasional newsletter author, light social-media poster. Not a journalist; not a full editorial role.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "digcomp", + "version": "2.2" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S1", + "scheme": "esco", + "prefLabel": "communication, collaboration and creativity" + }, + { + "competency_ref": "digcomp:3.1", + "scheme": "digcomp", + "prefLabel": "Developing digital content" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "creativity and innovation" + }, + { + "competency_ref": "digcomp:3.1", + "scheme": "digcomp", + "prefLabel": "Developing digital content" + }, + { + "competency_ref": "digcomp:3.2", + "scheme": "digcomp", + "prefLabel": "Integrating and re-elaborating digital content" + }, + { + "competency_ref": "digcomp:3.3", + "scheme": "digcomp", + "prefLabel": "Copyright and licences" + }, + { + "competency_ref": "digcomp:2.2", + "scheme": "digcomp", + "prefLabel": "Sharing through digital technologies" + } + ], + "competencies": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "creativity and innovation" + }, + { + "competency_ref": "digcomp:3.1", + "scheme": "digcomp", + "prefLabel": "Developing digital content" + }, + { + "competency_ref": "digcomp:3.3", + "scheme": "digcomp", + "prefLabel": "Copyright and licences" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/4", + "level_label": "EQF level 4", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.media_planner", + "memory_segments": [ + { + "id": "drafts", + "scope": "memory.x_klickd.media_planner.drafts", + "policy": "pointer_only_summary" + }, + { + "id": "rights", + "scope": "memory.x_klickd.media_planner.rights", + "policy": "pointer_only_attribution" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.media_planner", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/media_planner", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:057abe1e1239dee682ee525b04e2cd2c", + "attestation_hash": "sha256:d5e67a7380ecdc90265d7b2dc40564ec5a12de1cafd95527c0c910193bed7eb6" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/media_planner/v0-draft", + "embedding_model_ref": "klickd-embed-media_planner-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 5, + "max_facts_per_turn": 7, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "media", + "audience", + "campaign", + "channel_mix", + "kpi" + ], + "entity_classes": [ + "esco" + ], + "priority": "planning_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "media_profile_compose_ref": "rfc-001#media_profile", + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "public_post", + "third_party_identifiable_content", + "minor_in_frame" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "minor_in_frame", + "third_party_identifiable_content" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "human_carrier_only" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "third-party-identifiable", + "action_class": "third_party_identifiable_content", + "level": "confirm", + "reason": "Content identifying a third party requires explicit consent and confirmation." + }, + { + "id": "minor-in-frame", + "action_class": "minor_in_frame", + "level": "block", + "reason": "Minors-in-frame require guardian consent; floor cannot be lowered by this pack." + }, + { + "id": "copyright-claim", + "action_class": "copyright_claim", + "level": "confirm", + "reason": "Copyright / licence claims must be grounded against the actual licence text (RFC-002 §8b)." + } + ] + }, + "router_cost": { + "tokens_estimate": 750, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into ESCO or DigComp.", + "RFC-001 media_profile is composed by reference, not redefined inline.", + "Minor-in-frame gate is block and non-lowerable by this pack.", + "Pointer-only evidence; no inline media bytes.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == lite and tokens_estimate <= 900", + "media_profile_compose_ref points to RFC-001 §media_profile" + ], + "review": [ + "Reviewer verifies copyright/licence claims have RFC-002 §8b grounding shape.", + "Reviewer verifies minor-in-frame floor is not lowered." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/mission-control.klickd b/packages/@klickd/core/x-klickd-skills/mission-control.klickd new file mode 100644 index 0000000..e47821f --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/mission-control.klickd @@ -0,0 +1,374 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "operations", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B16). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/mission_control", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b16", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/mission_control", + "frameworks": [ + "esco", + "nice", + "enisa", + "wef" + ], + "competency_ids": [ + "esco:S4.1", + "esco:S4.1.2", + "nice:incident-response", + "enisa:cyber-incident-responder", + "wef:complex-problem-solving" + ], + "gate_summaries": [ + { + "id": "status-declaration", + "level": "confirm" + }, + { + "id": "escalation-bypass", + "level": "block" + }, + { + "id": "confidential-channel-inline", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/mission", + "x.klickd/security" + ], + "target_user": "Operator running a time-critical multi-system mission. Incident command, status declaration, comms discipline, escalation ladder.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "nice", + "version": "r1", + "iri_prefix": "https://niccs.cisa.gov/workforce-development/nice-framework/", + "canonical_url": "https://niccs.cisa.gov/workforce-development/nice-framework" + }, + { + "scheme": "enisa", + "version": "1.0", + "iri_prefix": "https://www.enisa.europa.eu/topics/skills-and-competences/skills-development/european-cybersecurity-skills-framework/", + "canonical_url": "https://www.enisa.europa.eu/topics/skills-and-competences/skills-development/european-cybersecurity-skills-framework" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "nice", + "version": "r1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.1", + "scheme": "esco", + "prefLabel": "project management" + }, + { + "competency_ref": "esco:S4.1.2", + "scheme": "esco", + "prefLabel": "operations management" + }, + { + "competency_ref": "nice:incident-response", + "scheme": "nice", + "prefLabel": "Incident Response" + }, + { + "competency_ref": "enisa:cyber-incident-responder", + "scheme": "enisa", + "prefLabel": "Cyber Incident Responder" + }, + { + "competency_ref": "wef:complex-problem-solving", + "scheme": "wef", + "prefLabel": "Complex problem solving" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4.1", + "scheme": "esco", + "prefLabel": "project management" + }, + { + "competency_ref": "esco:S4.1.2", + "scheme": "esco", + "prefLabel": "operations management" + }, + { + "competency_ref": "nice:incident-response", + "scheme": "nice", + "prefLabel": "Incident Response" + }, + { + "competency_ref": "enisa:cyber-incident-responder", + "scheme": "enisa", + "prefLabel": "Cyber Incident Responder" + }, + { + "competency_ref": "wef:complex-problem-solving", + "scheme": "wef", + "prefLabel": "Complex problem solving" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.mission_control", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.mission_control.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.mission_control.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.mission_control", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/mission_control", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:48f4749d4eaeffeed878e48f21f3f348", + "attestation_hash": "sha256:439c831eb711463a02abf283d75e5d3f6ed2c8224fbaccb994da6b2f3f7c4f28" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/mission_control/v0-draft", + "embedding_model_ref": "klickd-embed-mission_control-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "mission_control", + "task_routing", + "agent_orchestration", + "audit" + ], + "entity_classes": [ + "esco", + "sfia" + ], + "priority": "orchestration_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "status_up_or_down_declaration", + "escalation_step_bypass", + "confidential_channel_content_inline" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "escalation_step_bypass", + "confidential_channel_content_inline" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "status-declaration", + "action_class": "status_up_or_down_declaration", + "level": "confirm", + "reason": "Status declarations affect downstream consumers; confirm required." + }, + { + "id": "escalation-bypass", + "action_class": "escalation_step_bypass", + "level": "block", + "reason": "Escalation step bypass blocked; floor not lowerable." + }, + { + "id": "confidential-channel-inline", + "action_class": "confidential_channel_content_inline", + "level": "block", + "reason": "Inline confidential channel content blocked." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/mission_control are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/parent-gaming.klickd b/packages/@klickd/core/x-klickd-skills/parent-gaming.klickd new file mode 100644 index 0000000..351125d --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/parent-gaming.klickd @@ -0,0 +1,325 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "family_support", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "lite", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact. Lot A parent-gaming pack: carries the PARENT carrier's state; does NOT carry the child's state." + }, + "x_klickd_pack": { + "pack": "x.klickd/parent_gaming", + "pack_version": "0.1.0-candidate-lite", + "spec_ref": "x.klickd/v4.1#a13", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "lite", + "parent_packs": [ + "x.klickd/user", + "x.klickd/gaming", + "x.klickd/security" + ], + "target_user": "Parent / guardian carrier supporting a minor's gaming. Rating literacy (PEGI / ESRB / USK), screen-time discipline, online-safety hygiene. Carries the parent carrier's state only; does NOT carry the child's state.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + }, + { + "scheme": "lifecomp", + "version": "2020", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/lifecomp/2020/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/lifecomp_en" + } + ], + "citation_only_references": [ + { + "id": "pegi", + "ref": "PEGI Pan-European Game Information", + "url": "https://pegi.info/" + }, + { + "id": "esrb", + "ref": "ESRB Entertainment Software Rating Board", + "url": "https://www.esrb.org/" + }, + { + "id": "usk", + "ref": "USK Unterhaltungssoftware Selbstkontrolle", + "url": "https://usk.de/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "digcomp", + "version": "2.2" + }, + { + "scheme": "lifecomp", + "version": "2020" + } + ], + "transversal_refs": [ + { + "competency_ref": "digcomp:4.1", + "scheme": "digcomp", + "prefLabel": "Protecting devices" + }, + { + "competency_ref": "lifecomp:S1", + "scheme": "lifecomp", + "prefLabel": "Empathy" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S2.1", + "scheme": "esco", + "prefLabel": "providing educational support" + }, + { + "competency_ref": "digcomp:4.1", + "scheme": "digcomp", + "prefLabel": "Protecting devices" + }, + { + "competency_ref": "digcomp:4.2", + "scheme": "digcomp", + "prefLabel": "Protecting personal data and privacy" + }, + { + "competency_ref": "digcomp:4.3", + "scheme": "digcomp", + "prefLabel": "Protecting health and well-being" + }, + { + "competency_ref": "lifecomp:S1", + "scheme": "lifecomp", + "prefLabel": "Empathy" + } + ], + "competencies": [ + { + "competency_ref": "digcomp:4.1", + "scheme": "digcomp", + "prefLabel": "Protecting devices" + }, + { + "competency_ref": "digcomp:4.2", + "scheme": "digcomp", + "prefLabel": "Protecting personal data and privacy" + }, + { + "competency_ref": "digcomp:4.3", + "scheme": "digcomp", + "prefLabel": "Protecting health and well-being" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/4", + "level_label": "EQF level 4", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.parent_gaming", + "memory_segments": [ + { + "id": "rating-notes", + "scope": "memory.x_klickd.parent_gaming.rating_notes", + "policy": "pointer_only_no_child_pii" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.parent_gaming", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/parent_gaming", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:7cfed4e277597a8b89b2627c3fb5c45e", + "attestation_hash": "sha256:a0f2a94fabf0eaa9a5d647451943d2399313d6a2b4620f48ad3236a41f416ecf" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/parent_gaming/v0-draft", + "embedding_model_ref": "klickd-embed-parent_gaming-2026-v0-placeholder", + "dim": 384, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 4, + "max_facts_per_turn": 5, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "parenting", + "child_safety", + "screen_time", + "age_rating" + ], + "entity_classes": [ + "esco", + "lifecomp", + "digcomp" + ], + "priority": "guardian_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "child_facing_recommendation", + "child_pii_write" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "child_pii_write", + "override_child_carrier_guardian_posture" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "human_carrier_only", + "minor_carrier_compose_rule": "this_pack_cannot_override_human_carrier_with_guardian_posture_on_child_carrier_file" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr", + "de" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "child-pii-write", + "action_class": "child_pii_write", + "level": "block", + "reason": "Writing PII about a child to this carrier's file is blocked; floor non-lowerable." + }, + { + "id": "child-carrier-override", + "action_class": "override_child_carrier_guardian_posture", + "level": "block", + "reason": "Cannot lower the human_carrier_with_guardian posture on a child's own carrier file." + } + ] + }, + "router_cost": { + "tokens_estimate": 800, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into ESCO, DigComp, or LifeComp.", + "PEGI/ESRB/USK are citation-only, not frameworks[] schemes.", + "child_pii_write gate is block and non-lowerable.", + "Pack carries parent state only; explicit rule that it cannot override child's guardian posture.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == lite and tokens_estimate <= 900", + "block on child_pii_write present" + ], + "review": [ + "Reviewer verifies minor_carrier_compose_rule is preserved.", + "Reviewer verifies no child PII shape is required by the pack." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/policy-analyst.klickd b/packages/@klickd/core/x-klickd-skills/policy-analyst.klickd new file mode 100644 index 0000000..f6b62a2 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/policy-analyst.klickd @@ -0,0 +1,364 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "research", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B11). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/policy_analyst", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b11", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/policy_analyst", + "frameworks": [ + "esco", + "wef", + "onet" + ], + "competency_ids": [ + "esco:S4.6", + "esco:S4.6.4", + "esco:S2.5", + "wef:analytical-thinking", + "wef:systems-thinking", + "onet:19-3094.00" + ], + "gate_summaries": [ + { + "id": "named-attribution", + "level": "confirm" + }, + { + "id": "regulated-submission", + "level": "confirm" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/research", + "x.klickd/legal" + ], + "target_user": "Public-policy analyst. Legislative tracking, stakeholder mapping, comparative-jurisdiction analysis, briefing-note discipline.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "wef", + "version": "2023" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S4.6.4", + "scheme": "esco", + "prefLabel": "public administration" + }, + { + "competency_ref": "esco:S2.5", + "scheme": "esco", + "prefLabel": "investigating and reporting" + }, + { + "competency_ref": "wef:analytical-thinking", + "scheme": "wef", + "prefLabel": "Analytical thinking" + }, + { + "competency_ref": "wef:systems-thinking", + "scheme": "wef", + "prefLabel": "Systems thinking" + }, + { + "competency_ref": "onet:19-3094.00", + "scheme": "onet", + "prefLabel": "Political Scientists" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S4.6.4", + "scheme": "esco", + "prefLabel": "public administration" + }, + { + "competency_ref": "esco:S2.5", + "scheme": "esco", + "prefLabel": "investigating and reporting" + }, + { + "competency_ref": "wef:analytical-thinking", + "scheme": "wef", + "prefLabel": "Analytical thinking" + }, + { + "competency_ref": "wef:systems-thinking", + "scheme": "wef", + "prefLabel": "Systems thinking" + }, + { + "competency_ref": "onet:19-3094.00", + "scheme": "onet", + "prefLabel": "Political Scientists" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.policy_analyst", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.policy_analyst.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.policy_analyst.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.policy_analyst", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/policy_analyst", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:1b34594337e191a57deda4e9a0bebd43", + "attestation_hash": "sha256:edd86b567c26d66a03d3a760445db2a62330538a542c2f166dc3ba58adc0cdd3" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/policy_analyst/v0-draft", + "embedding_model_ref": "klickd-embed-policy_analyst-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "policy", + "impact_assessment", + "stakeholder_map", + "scenario" + ], + "entity_classes": [ + "esco", + "eu_law_ref" + ], + "priority": "policy_analysis", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "named_legislator_or_institution_attribution", + "regulated_submission_informed_by_analysis" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "named-attribution", + "action_class": "named_legislator_or_institution_attribution", + "level": "confirm", + "reason": "Attribution to a named legislator or institution requires confirmation." + }, + { + "id": "regulated-submission", + "action_class": "regulated_submission_informed_by_analysis", + "level": "confirm", + "reason": "Analyses informing regulated submissions require counsel escalation." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/policy_analyst are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/privacy-product.klickd b/packages/@klickd/core/x-klickd-skills/privacy-product.klickd new file mode 100644 index 0000000..5be3842 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/privacy-product.klickd @@ -0,0 +1,343 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "legal", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B9). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/privacy_product", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b9", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/privacy_product", + "frameworks": [ + "esco", + "digcomp" + ], + "competency_ids": [ + "esco:S5.6.2", + "esco:S4.6.2", + "digcomp:4.2" + ], + "gate_summaries": [ + { + "id": "data-flow-cross-processor", + "level": "confirm" + }, + { + "id": "dpo-escalation-skip", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/legal", + "x.klickd/coding" + ], + "target_user": "Product manager / engineer applying privacy-by-design to a product. Data flows, retention, lawful basis, consent UX, DSR surfaces.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + } + ], + "citation_only_references": [ + { + "id": "gdpr-art-25", + "ref": "GDPR Art. 25 (Data protection by design and by default)", + "url": "https://eur-lex.europa.eu/eli/reg/2016/679/oj" + }, + { + "id": "enisa-privacy-by-design", + "ref": "ENISA Privacy by Design", + "url": "https://www.enisa.europa.eu/topics/data-protection/privacy-by-design" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "digcomp", + "version": "2.2" + } + ], + "transversal_refs": [ + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S5.6.2", + "scheme": "esco", + "prefLabel": "ICT privacy engineering" + }, + { + "competency_ref": "esco:S4.6.2", + "scheme": "esco", + "prefLabel": "data protection" + }, + { + "competency_ref": "digcomp:4.2", + "scheme": "digcomp", + "prefLabel": "Protecting personal data and privacy" + } + ], + "competencies": [ + { + "competency_ref": "esco:S5.6.2", + "scheme": "esco", + "prefLabel": "ICT privacy engineering" + }, + { + "competency_ref": "esco:S4.6.2", + "scheme": "esco", + "prefLabel": "data protection" + }, + { + "competency_ref": "digcomp:4.2", + "scheme": "digcomp", + "prefLabel": "Protecting personal data and privacy" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.privacy_product", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.privacy_product.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.privacy_product.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.privacy_product", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/privacy_product", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:0b0bad96adaf394a37ef89b4d0924afa", + "attestation_hash": "sha256:672a6015e1f6153fc94699845ebb91c8de243dbdce02fe93043c151b99971de8" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/privacy_product/v0-draft", + "embedding_model_ref": "klickd-embed-privacy_product-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "privacy_by_design", + "consent", + "dpia", + "data_minimisation" + ], + "entity_classes": [ + "esco", + "eu_law_ref" + ], + "priority": "design_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "data_flow_cross_processor", + "skip_dpo_escalation" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "skip_dpo_escalation" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "data-flow-cross-processor", + "action_class": "data_flow_cross_processor", + "level": "confirm", + "reason": "Data flows crossing a processor boundary require explicit confirmation." + }, + { + "id": "dpo-escalation-skip", + "action_class": "skip_dpo_escalation", + "level": "block", + "reason": "DPO escalation skip blocked when retention or lawful basis is ambiguous." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/privacy_product are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/product-manager.klickd b/packages/@klickd/core/x-klickd-skills/product-manager.klickd new file mode 100644 index 0000000..20b1897 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/product-manager.klickd @@ -0,0 +1,393 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "product_management", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B20). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/product_manager", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b20", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/product_manager", + "frameworks": [ + "esco", + "sfia", + "onet", + "wef" + ], + "competency_ids": [ + "esco:S4", + "esco:S4.0.1", + "sfia:PROD", + "sfia:RLMT", + "onet:11-2021.00", + "wef:leadership-social-influence", + "wef:analytical-thinking" + ], + "gate_summaries": [ + { + "id": "roadmap-commit", + "level": "confirm" + }, + { + "id": "feature-cut-on-evidence-skip", + "level": "block" + }, + { + "id": "pricing-change", + "level": "confirm" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/work", + "x.klickd/coding" + ], + "target_user": "Product manager driving roadmap, discovery, and delivery for a software product. Stakeholder alignment, prioritisation, evidence-based decisions. NOT a senior people-manager role.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4", + "scheme": "esco", + "prefLabel": "management skills" + }, + { + "competency_ref": "esco:S4.0.1", + "scheme": "esco", + "prefLabel": "managing activities, resources, requirements" + }, + { + "competency_ref": "sfia:PROD", + "scheme": "sfia", + "prefLabel": "Product management" + }, + { + "competency_ref": "sfia:RLMT", + "scheme": "sfia", + "prefLabel": "Stakeholder relationship management" + }, + { + "competency_ref": "onet:11-2021.00", + "scheme": "onet", + "prefLabel": "Marketing Managers" + }, + { + "competency_ref": "wef:leadership-social-influence", + "scheme": "wef", + "prefLabel": "Leadership and social influence" + }, + { + "competency_ref": "wef:analytical-thinking", + "scheme": "wef", + "prefLabel": "Analytical thinking" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4", + "scheme": "esco", + "prefLabel": "management skills" + }, + { + "competency_ref": "esco:S4.0.1", + "scheme": "esco", + "prefLabel": "managing activities, resources, requirements" + }, + { + "competency_ref": "sfia:PROD", + "scheme": "sfia", + "prefLabel": "Product management" + }, + { + "competency_ref": "sfia:RLMT", + "scheme": "sfia", + "prefLabel": "Stakeholder relationship management" + }, + { + "competency_ref": "onet:11-2021.00", + "scheme": "onet", + "prefLabel": "Marketing Managers" + }, + { + "competency_ref": "wef:leadership-social-influence", + "scheme": "wef", + "prefLabel": "Leadership and social influence" + }, + { + "competency_ref": "wef:analytical-thinking", + "scheme": "wef", + "prefLabel": "Analytical thinking" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.product_manager", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.product_manager.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.product_manager.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.product_manager", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/product_manager", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:2193273b6b3f084daa9ea494527b33ae", + "attestation_hash": "sha256:f7e76f47ab3549c62cc7a7dd587c64fdab0873bec7a6beda07562ab709ed1c3d" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/product_manager/v0-draft", + "embedding_model_ref": "klickd-embed-product_manager-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "product", + "discovery", + "roadmap", + "north_star", + "prioritisation" + ], + "entity_classes": [ + "esco", + "sfia", + "onet" + ], + "priority": "planning_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "roadmap_external_commit", + "skip_evidence_for_feature_decision", + "pricing_change_write" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "skip_evidence_for_feature_decision" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "roadmap-commit", + "action_class": "roadmap_external_commit", + "level": "confirm", + "reason": "Roadmap commitments to external stakeholders are hard to retract." + }, + { + "id": "feature-cut-on-evidence-skip", + "action_class": "skip_evidence_for_feature_decision", + "level": "block", + "reason": "Cutting or pursuing a feature without evidence is blocked; decisions must cite a research artefact." + }, + { + "id": "pricing-change", + "action_class": "pricing_change_write", + "level": "confirm", + "reason": "Pricing-change writes require explicit confirmation." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/product_manager are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/project-operator.klickd b/packages/@klickd/core/x-klickd-skills/project-operator.klickd new file mode 100644 index 0000000..2b8456d --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/project-operator.klickd @@ -0,0 +1,356 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "professional", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B14). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/project_operator", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b14", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/project_operator", + "frameworks": [ + "esco", + "wef", + "onet" + ], + "competency_ids": [ + "esco:S4.1", + "esco:S4.1.1", + "wef:resilience-stress-tolerance", + "wef:leadership-social-influence", + "onet:11-3071.04" + ], + "gate_summaries": [ + { + "id": "cross-org-stakeholder", + "level": "confirm" + }, + { + "id": "exit-condition-violation", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/work", + "x.klickd/mission" + ], + "target_user": "Senior operator running multi-stakeholder projects. Risk register, dependency tracking, escalation discipline, exit-condition declaration.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "wef", + "version": "2023" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.1", + "scheme": "esco", + "prefLabel": "project management" + }, + { + "competency_ref": "esco:S4.1.1", + "scheme": "esco", + "prefLabel": "risk management" + }, + { + "competency_ref": "wef:resilience-stress-tolerance", + "scheme": "wef", + "prefLabel": "Resilience, stress tolerance and flexibility" + }, + { + "competency_ref": "wef:leadership-social-influence", + "scheme": "wef", + "prefLabel": "Leadership and social influence" + }, + { + "competency_ref": "onet:11-3071.04", + "scheme": "onet", + "prefLabel": "Supply Chain Managers" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4.1", + "scheme": "esco", + "prefLabel": "project management" + }, + { + "competency_ref": "esco:S4.1.1", + "scheme": "esco", + "prefLabel": "risk management" + }, + { + "competency_ref": "wef:resilience-stress-tolerance", + "scheme": "wef", + "prefLabel": "Resilience, stress tolerance and flexibility" + }, + { + "competency_ref": "wef:leadership-social-influence", + "scheme": "wef", + "prefLabel": "Leadership and social influence" + }, + { + "competency_ref": "onet:11-3071.04", + "scheme": "onet", + "prefLabel": "Supply Chain Managers" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.project_operator", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.project_operator.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.project_operator.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.project_operator", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/project_operator", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:5653e1713ca9758d2ec943e0552b03eb", + "attestation_hash": "sha256:7b638d18a86cc17e2dc513d55876fa37ef6cddab2f79ea7c49909aa5fcadd971" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/project_operator/v0-draft", + "embedding_model_ref": "klickd-embed-project_operator-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "project", + "schedule", + "raci", + "risk_register", + "milestone" + ], + "entity_classes": [ + "esco", + "sfia" + ], + "priority": "delivery_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "cross_org_stakeholder_write", + "timeline_change_violates_exit_condition" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "timeline_change_violates_exit_condition" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "cross-org-stakeholder", + "action_class": "cross_org_stakeholder_write", + "level": "confirm", + "reason": "Cross-org stakeholder writes require explicit confirmation." + }, + { + "id": "exit-condition-violation", + "action_class": "timeline_change_violates_exit_condition", + "level": "block", + "reason": "Timeline changes that violate an exit condition blocked; floor not lowerable." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/project_operator are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/release-engineer.klickd b/packages/@klickd/core/x-klickd-skills/release-engineer.klickd new file mode 100644 index 0000000..9932e70 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/release-engineer.klickd @@ -0,0 +1,421 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "software_engineering", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B4). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/release_engineer", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b4", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/release_engineer", + "frameworks": [ + "esco", + "sfia", + "nice", + "cis" + ], + "competency_ids": [ + "esco:S5.7", + "sfia:RELM", + "sfia:CFMG", + "sfia:PORT", + "nice:software-development", + "nice:supply-chain-risk-management", + "cis:control-2", + "cis:control-11" + ], + "gate_summaries": [ + { + "id": "production-release", + "level": "confirm" + }, + { + "id": "artefact-signing-disable", + "level": "block" + }, + { + "id": "sbom-emission-disable", + "level": "block" + }, + { + "id": "rollback-path-undeclared", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/coding", + "x.klickd/security" + ], + "target_user": "Release engineer / build owner. Supply-chain hygiene, SBOM, reproducible builds, signing, rollback discipline.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "nice", + "version": "r1", + "iri_prefix": "https://niccs.cisa.gov/workforce-development/nice-framework/", + "canonical_url": "https://niccs.cisa.gov/workforce-development/nice-framework" + }, + { + "scheme": "cis", + "version": "v8", + "iri_prefix": "https://www.cisecurity.org/controls/v8/", + "canonical_url": "https://www.cisecurity.org/controls/cis-controls-list" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "sfia", + "version": "8" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S5.7", + "scheme": "esco", + "prefLabel": "software deployment" + }, + { + "competency_ref": "sfia:RELM", + "scheme": "sfia", + "prefLabel": "Release management" + }, + { + "competency_ref": "sfia:CFMG", + "scheme": "sfia", + "prefLabel": "Configuration management" + }, + { + "competency_ref": "sfia:PORT", + "scheme": "sfia", + "prefLabel": "Porting/software configuration" + }, + { + "competency_ref": "nice:software-development", + "scheme": "nice", + "prefLabel": "Software Development" + }, + { + "competency_ref": "nice:supply-chain-risk-management", + "scheme": "nice", + "prefLabel": "Supply Chain Risk Management" + }, + { + "competency_ref": "cis:control-2", + "scheme": "cis", + "prefLabel": "Inventory and Control of Software Assets" + }, + { + "competency_ref": "cis:control-11", + "scheme": "cis", + "prefLabel": "Data Recovery" + } + ], + "competencies": [ + { + "competency_ref": "esco:S5.7", + "scheme": "esco", + "prefLabel": "software deployment" + }, + { + "competency_ref": "sfia:RELM", + "scheme": "sfia", + "prefLabel": "Release management" + }, + { + "competency_ref": "sfia:CFMG", + "scheme": "sfia", + "prefLabel": "Configuration management" + }, + { + "competency_ref": "sfia:PORT", + "scheme": "sfia", + "prefLabel": "Porting/software configuration" + }, + { + "competency_ref": "nice:software-development", + "scheme": "nice", + "prefLabel": "Software Development" + }, + { + "competency_ref": "nice:supply-chain-risk-management", + "scheme": "nice", + "prefLabel": "Supply Chain Risk Management" + }, + { + "competency_ref": "cis:control-2", + "scheme": "cis", + "prefLabel": "Inventory and Control of Software Assets" + }, + { + "competency_ref": "cis:control-11", + "scheme": "cis", + "prefLabel": "Data Recovery" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.release_engineer", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.release_engineer.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.release_engineer.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.release_engineer", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/release_engineer", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:06092cdae084b1163250b48f9b63f265", + "attestation_hash": "sha256:d93ffe806ac0d7349759bcab35b148ced122f61dbe8bab927c892314fc46f093" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/release_engineer/v0-draft", + "embedding_model_ref": "klickd-embed-release_engineer-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "release", + "sbom", + "sign", + "rollback", + "supply_chain" + ], + "entity_classes": [ + "esco", + "sfia", + "nice" + ], + "priority": "ops_operation", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "production_release", + "disable_artefact_signing", + "disable_sbom_emission", + "release_without_rollback_path" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "disable_artefact_signing", + "disable_sbom_emission", + "release_without_rollback_path" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "production-release", + "action_class": "production_release", + "level": "confirm", + "reason": "Production releases require explicit confirmation." + }, + { + "id": "artefact-signing-disable", + "action_class": "disable_artefact_signing", + "level": "block", + "reason": "Artefact signing disables blocked; floor not lowerable." + }, + { + "id": "sbom-emission-disable", + "action_class": "disable_sbom_emission", + "level": "block", + "reason": "SBOM emission disables blocked; floor not lowerable." + }, + { + "id": "rollback-path-undeclared", + "action_class": "release_without_rollback_path", + "level": "block", + "reason": "Releases without declared rollback path blocked." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/release_engineer are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/rights-guard.klickd b/packages/@klickd/core/x-klickd-skills/rights-guard.klickd new file mode 100644 index 0000000..75bc836 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/rights-guard.klickd @@ -0,0 +1,333 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "legal", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B18). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/rights_guard", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b18", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/rights_guard", + "frameworks": [ + "esco" + ], + "competency_ids": [ + "esco:S4.6", + "esco:S4.6.5", + "esco:S1.0.1" + ], + "gate_summaries": [ + { + "id": "licence-classification", + "level": "confirm" + }, + { + "id": "commercial-redistribution", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/legal", + "x.klickd/creator" + ], + "target_user": "Rights / licensing manager. IP / copyright literacy, licence-compatibility analysis, attribution discipline, DMCA / EU Copyright Directive Art. 17 awareness.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + } + ], + "citation_only_references": [ + { + "id": "eu-copyright-2019-790", + "ref": "EU Copyright Directive 2019/790", + "url": "https://eur-lex.europa.eu/eli/dir/2019/790/oj" + }, + { + "id": "berne", + "ref": "Berne Convention", + "url": "https://www.wipo.int/treaties/en/ip/berne/" + }, + { + "id": "cc-4-0", + "ref": "Creative Commons 4.0", + "url": "https://creativecommons.org/licenses/by/4.0/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S4.6.5", + "scheme": "esco", + "prefLabel": "intellectual property law" + }, + { + "competency_ref": "esco:S1.0.1", + "scheme": "esco", + "prefLabel": "rights management" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S4.6.5", + "scheme": "esco", + "prefLabel": "intellectual property law" + }, + { + "competency_ref": "esco:S1.0.1", + "scheme": "esco", + "prefLabel": "rights management" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.rights_guard", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.rights_guard.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.rights_guard.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.rights_guard", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/rights_guard", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:9191180e1dc7e6dcd5ec66769424ae0c", + "attestation_hash": "sha256:4ccf40adac1975979b6bb7b046cf3851cb4cbc2842b3fbda5a146365706699a0" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/rights_guard/v0-draft", + "embedding_model_ref": "klickd-embed-rights_guard-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 5, + "max_facts_per_turn": 7, + "freshness_weighting": "none", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "rights", + "copyright", + "moral_rights", + "license", + "takedown" + ], + "entity_classes": [ + "esco", + "eu_law_ref" + ], + "priority": "rights_lookup", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "licence_classification_write", + "commercial_redistribution_decision" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "commercial_redistribution_decision" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "licence-classification", + "action_class": "licence_classification_write", + "level": "confirm", + "reason": "Licence classification writes require explicit confirmation." + }, + { + "id": "commercial-redistribution", + "action_class": "commercial_redistribution_decision", + "level": "block", + "reason": "Commercial redistribution decisions require qualified IP counsel; floor not lowerable." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/rights_guard are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/sales-operator.klickd b/packages/@klickd/core/x-klickd-skills/sales-operator.klickd new file mode 100644 index 0000000..47eb52a --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/sales-operator.klickd @@ -0,0 +1,382 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "sales", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B26). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/sales_operator", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b26", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/sales_operator", + "frameworks": [ + "esco", + "onet", + "wef", + "lifecomp" + ], + "competency_ids": [ + "esco:S3", + "esco:S4.0.1", + "onet:41-3091.00", + "onet:41-4011.00", + "wef:leadership-social-influence", + "lifecomp:S1" + ], + "gate_summaries": [ + { + "id": "outbound-cold-list", + "level": "block" + }, + { + "id": "claim-without-evidence", + "level": "block" + }, + { + "id": "discount-floor-override", + "level": "confirm" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1150, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/work" + ], + "target_user": "B2B / SaaS sales operator running discovery, qualification, demo, proposal, close. CRM discipline, claim grounding, no-overpromise discipline. Distinct from marketing.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + }, + { + "scheme": "lifecomp", + "version": "2020", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/lifecomp/2020/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/lifecomp_en" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S3", + "scheme": "esco", + "prefLabel": "communicating, collaborating, advising, mediating" + }, + { + "competency_ref": "esco:S4.0.1", + "scheme": "esco", + "prefLabel": "managing activities, resources, requirements" + }, + { + "competency_ref": "onet:41-3091.00", + "scheme": "onet", + "prefLabel": "Sales Representatives of Services" + }, + { + "competency_ref": "onet:41-4011.00", + "scheme": "onet", + "prefLabel": "Sales Representatives, Wholesale and Manufacturing — Technical and Scientific Products" + }, + { + "competency_ref": "wef:leadership-social-influence", + "scheme": "wef", + "prefLabel": "Leadership and social influence" + }, + { + "competency_ref": "lifecomp:S1", + "scheme": "lifecomp", + "prefLabel": "Empathy" + } + ], + "competencies": [ + { + "competency_ref": "esco:S3", + "scheme": "esco", + "prefLabel": "communicating, collaborating, advising, mediating" + }, + { + "competency_ref": "esco:S4.0.1", + "scheme": "esco", + "prefLabel": "managing activities, resources, requirements" + }, + { + "competency_ref": "onet:41-3091.00", + "scheme": "onet", + "prefLabel": "Sales Representatives of Services" + }, + { + "competency_ref": "onet:41-4011.00", + "scheme": "onet", + "prefLabel": "Sales Representatives, Wholesale and Manufacturing — Technical and Scientific Products" + }, + { + "competency_ref": "wef:leadership-social-influence", + "scheme": "wef", + "prefLabel": "Leadership and social influence" + }, + { + "competency_ref": "lifecomp:S1", + "scheme": "lifecomp", + "prefLabel": "Empathy" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/5", + "level_label": "EQF level 5", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.sales_operator", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.sales_operator.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.sales_operator.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.sales_operator", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/sales_operator", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:af40c4a4d7e203c26c71eb0b1a02b57d", + "attestation_hash": "sha256:22649c84a643dc69344bd0650492aa096c378e4da5bf490fcbfedcff244a349b" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/sales_operator/v0-draft", + "embedding_model_ref": "klickd-embed-sales_operator-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "sales", + "pipeline", + "discovery_call", + "objection", + "forecast" + ], + "entity_classes": [ + "esco", + "sfia", + "onet" + ], + "priority": "sales_operation", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "cold_outbound_to_unconsented_list", + "product_claim_without_evidence", + "discount_floor_override" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "cold_outbound_to_unconsented_list", + "product_claim_without_evidence" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "outbound-cold-list", + "action_class": "cold_outbound_to_unconsented_list", + "level": "block", + "reason": "Cold outbound to a list without lawful basis is blocked under GDPR/CAN-SPAM compliance." + }, + { + "id": "claim-without-evidence", + "action_class": "product_claim_without_evidence", + "level": "block", + "reason": "Product claims to a prospect without an evidence pointer are blocked." + }, + { + "id": "discount-floor-override", + "action_class": "discount_floor_override", + "level": "confirm", + "reason": "Discount-floor overrides require explicit confirmation." + } + ] + }, + "router_cost": { + "tokens_estimate": 1150, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/sales_operator are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/second-brain.klickd b/packages/@klickd/core/x-klickd-skills/second-brain.klickd new file mode 100644 index 0000000..3b2468f --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/second-brain.klickd @@ -0,0 +1,360 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "research", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B12). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/second_brain", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b12", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/second_brain", + "frameworks": [ + "esco", + "digcomp", + "lifecomp" + ], + "competency_ids": [ + "esco:S2.0", + "esco:S2.4", + "digcomp:1.3", + "digcomp:3.3", + "lifecomp:L3" + ], + "gate_summaries": [ + { + "id": "notes-export-third-party", + "level": "confirm" + }, + { + "id": "inline-note-content", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/research" + ], + "target_user": "Knowledge-worker carrier running a long-running notes / PKM practice. Capture discipline, citation hygiene, atomic notes, link integrity. Carries PKM state, not the notes.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + }, + { + "scheme": "lifecomp", + "version": "2020", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/lifecomp/2020/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/lifecomp_en" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "digcomp", + "version": "2.2" + } + ], + "transversal_refs": [ + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "esco:S2.4", + "scheme": "esco", + "prefLabel": "knowledge management" + }, + { + "competency_ref": "digcomp:1.3", + "scheme": "digcomp", + "prefLabel": "Managing data, information and digital content" + }, + { + "competency_ref": "digcomp:3.3", + "scheme": "digcomp", + "prefLabel": "Copyright and licences" + }, + { + "competency_ref": "lifecomp:L3", + "scheme": "lifecomp", + "prefLabel": "Managing learning" + } + ], + "competencies": [ + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "esco:S2.4", + "scheme": "esco", + "prefLabel": "knowledge management" + }, + { + "competency_ref": "digcomp:1.3", + "scheme": "digcomp", + "prefLabel": "Managing data, information and digital content" + }, + { + "competency_ref": "digcomp:3.3", + "scheme": "digcomp", + "prefLabel": "Copyright and licences" + }, + { + "competency_ref": "lifecomp:L3", + "scheme": "lifecomp", + "prefLabel": "Managing learning" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.second_brain", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.second_brain.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.second_brain.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.second_brain", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/second_brain", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:183a074c715748ba750cee6cbf5729bf", + "attestation_hash": "sha256:8156ab6b91c069dcd88d9563877b4a0d3b2937a75556fcd37dd1ead28f7d40d0" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/second_brain/v0-draft", + "embedding_model_ref": "klickd-embed-second_brain-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 8, + "max_facts_per_turn": 10, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "note", + "atomic_note", + "link", + "spaced_review", + "weekly_review" + ], + "entity_classes": [ + "esco", + "lifecomp" + ], + "priority": "personal_research", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "notes_export_to_third_party", + "inline_note_content" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "inline_note_content" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "notes-export-third-party", + "action_class": "notes_export_to_third_party", + "level": "confirm", + "reason": "Exporting notes to a third party requires explicit confirmation." + }, + { + "id": "inline-note-content", + "action_class": "inline_note_content", + "level": "block", + "reason": "Inline note content blocked; pack carries pointers only." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/second_brain are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/security-incident-response.klickd b/packages/@klickd/core/x-klickd-skills/security-incident-response.klickd new file mode 100644 index 0000000..400ebb3 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/security-incident-response.klickd @@ -0,0 +1,386 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "security", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B25). Pro tier; compact_index loading strategy declared. Disambiguation: B25 owns the incident lifecycle (detect / triage / contain / eradicate / recover / lessons-learned) on conventional infrastructure; B1 (llm_agent_security) owns LLM/agent-system prompt-injection and tool-sandbox literacy at design + eval time; B3 (identity_access_management) owns IAM / MFA / session hygiene at operate time. Composition is explicit via parent_packs; this pack MUST NOT lower any default from x.klickd/security or from B1/B3 when they are also loaded." + }, + "x_klickd_pack": { + "pack": "x.klickd/security_incident_response", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b25", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/security_incident_response", + "frameworks": [ + "nice", + "enisa", + "cis", + "esco" + ], + "competency_ids": [ + "nice:PR-CDA", + "nice:PR-INF", + "enisa:CIR", + "cis:17", + "cis:8", + "esco:S5.6.3" + ], + "gate_summaries": [ + { + "id": "public-disclosure-bypass", + "level": "block" + }, + { + "id": "evidence-chain-break", + "level": "block" + }, + { + "id": "containment-action", + "level": "confirm" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1300, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/security" + ], + "target_user": "Security incident responder running detection, triage, containment, eradication, recovery, and lessons-learned. Distinct from identity_access_management (B3) and llm_agent_security (B1) by incident-time scope.", + "frameworks": [ + { + "scheme": "nice", + "version": "NIST SP 800-181r1", + "iri_prefix": "https://csrc.nist.gov/projects/cybersecurity-workforce-framework/", + "canonical_url": "https://niccs.cisa.gov/workforce-development/nice-framework" + }, + { + "scheme": "enisa", + "version": "ECSF 1.0", + "iri_prefix": "https://www.enisa.europa.eu/topics/skills-and-competences/ecsf/", + "canonical_url": "https://www.enisa.europa.eu/topics/skills-and-competences/ecsf" + }, + { + "scheme": "cis", + "version": "v8", + "iri_prefix": "https://www.cisecurity.org/controls/v8/", + "canonical_url": "https://www.cisecurity.org/controls/v8" + }, + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "nice", + "version": "NIST SP 800-181r1" + }, + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "nice:PR-CDA", + "scheme": "nice", + "prefLabel": "Protect and Defend — Cyber Defense Analysis" + }, + { + "competency_ref": "nice:PR-INF", + "scheme": "nice", + "prefLabel": "Protect and Defend — Incident Response" + }, + { + "competency_ref": "enisa:CIR", + "scheme": "enisa", + "prefLabel": "Cyber Incident Responder" + }, + { + "competency_ref": "cis:17", + "scheme": "cis", + "prefLabel": "Incident Response Management" + }, + { + "competency_ref": "cis:8", + "scheme": "cis", + "prefLabel": "Audit Log Management" + }, + { + "competency_ref": "esco:S5.6.3", + "scheme": "esco", + "prefLabel": "addressing problems" + } + ], + "competencies": [ + { + "competency_ref": "nice:PR-CDA", + "scheme": "nice", + "prefLabel": "Protect and Defend — Cyber Defense Analysis" + }, + { + "competency_ref": "nice:PR-INF", + "scheme": "nice", + "prefLabel": "Protect and Defend — Incident Response" + }, + { + "competency_ref": "enisa:CIR", + "scheme": "enisa", + "prefLabel": "Cyber Incident Responder" + }, + { + "competency_ref": "cis:17", + "scheme": "cis", + "prefLabel": "Incident Response Management" + }, + { + "competency_ref": "cis:8", + "scheme": "cis", + "prefLabel": "Audit Log Management" + }, + { + "competency_ref": "esco:S5.6.3", + "scheme": "esco", + "prefLabel": "addressing problems" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.security_incident_response", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.security_incident_response.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.security_incident_response.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.security_incident_response", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/security_incident_response", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:bd1fdd7cb77fb8abaa6b7833cc28f1fc", + "attestation_hash": "sha256:d2de3b1e04f88f863e8cc9e4898c67b3c5e82464584ade2c16af145643cc1bbd" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/security_incident_response/v0-draft", + "embedding_model_ref": "klickd-embed-security_incident_response-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 7, + "max_facts_per_turn": 9, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "incident", + "containment", + "forensics", + "post_mortem", + "ttp" + ], + "entity_classes": [ + "esco", + "nice", + "enisa_ref" + ], + "priority": "security_operation", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "public_disclosure_without_legal", + "evidence_chain_of_custody_break", + "containment_action_write" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "public_disclosure_without_legal", + "evidence_chain_of_custody_break" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "public-disclosure-bypass", + "action_class": "public_disclosure_without_legal", + "level": "block", + "reason": "Public incident disclosure without legal/counsel sign-off is blocked." + }, + { + "id": "evidence-chain-break", + "action_class": "evidence_chain_of_custody_break", + "level": "block", + "reason": "Breaking chain-of-custody on incident evidence is blocked." + }, + { + "id": "containment-action", + "action_class": "containment_action_write", + "level": "confirm", + "reason": "Containment actions (isolate host, revoke key) require explicit confirmation." + } + ] + }, + "router_cost": { + "tokens_estimate": 1300, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/security_incident_response are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/social-literacy.klickd b/packages/@klickd/core/x-klickd-skills/social-literacy.klickd new file mode 100644 index 0000000..02e1262 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/social-literacy.klickd @@ -0,0 +1,313 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "media_literacy", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "lite", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact. Lot A social-literacy pack composing x.klickd/user.", + "renamed_from": "social.klickd" + }, + "x_klickd_pack": { + "pack": "x.klickd/social_literacy", + "pack_version": "0.1.0-candidate-lite", + "spec_ref": "x.klickd/v4.1#a9", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "lite", + "parent_packs": [ + "x.klickd/user" + ], + "target_user": "Carrier with active social-media use, interested in critical literacy, attention hygiene, disinformation resistance. Not growth-hacking; not marketing.", + "frameworks": [ + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + }, + { + "scheme": "lifecomp", + "version": "2020", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/lifecomp/2020/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/lifecomp_en" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "digcomp", + "version": "2.2" + }, + { + "scheme": "lifecomp", + "version": "2020" + } + ], + "transversal_refs": [ + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "lifecomp:P1", + "scheme": "lifecomp", + "prefLabel": "Self-regulation" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "digcomp:2.2", + "scheme": "digcomp", + "prefLabel": "Sharing through digital technologies" + }, + { + "competency_ref": "digcomp:2.4", + "scheme": "digcomp", + "prefLabel": "Collaborating through digital technologies" + }, + { + "competency_ref": "digcomp:4.3", + "scheme": "digcomp", + "prefLabel": "Protecting health and well-being" + }, + { + "competency_ref": "lifecomp:S1", + "scheme": "lifecomp", + "prefLabel": "Empathy" + }, + { + "competency_ref": "wef:active-learning", + "scheme": "wef", + "prefLabel": "Active learning and learning strategies" + } + ], + "competencies": [ + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "digcomp:2.2", + "scheme": "digcomp", + "prefLabel": "Sharing through digital technologies" + }, + { + "competency_ref": "digcomp:4.3", + "scheme": "digcomp", + "prefLabel": "Protecting health and well-being" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/4", + "level_label": "EQF level 4", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.social_literacy", + "memory_segments": [ + { + "id": "shares", + "scope": "memory.x_klickd.social_literacy.shares", + "policy": "pointer_only_summary" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.social_literacy", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/social_literacy", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:377a2c4e666e706217a2ce388bee306b", + "attestation_hash": "sha256:54a90718642ca3ebee3cc139983c53cc3f69b0051f2222bd0baa511b49de581e" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/social_literacy/v0-draft", + "embedding_model_ref": "klickd-embed-social_literacy-2026-v0-placeholder", + "dim": 384, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 5, + "max_facts_per_turn": 6, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "social_media", + "verification", + "disinformation", + "consent" + ], + "entity_classes": [ + "digcomp", + "lifecomp" + ], + "priority": "literacy_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "third_party_naming", + "minor_naming", + "factual_claim_share" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "minor_naming" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier_with_guardian_if_minor", + "agent_role": "advisory", + "escalation": "guardian_if_minor" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "third-party-naming", + "action_class": "third_party_naming", + "level": "confirm", + "reason": "Naming a third party in a public post requires confirmation." + }, + { + "id": "minor-naming", + "action_class": "minor_naming", + "level": "block", + "reason": "Naming a minor in a public post is blocked by default; floor not lowerable." + }, + { + "id": "factual-claim-share", + "action_class": "factual_claim_share", + "level": "confirm", + "reason": "Sharing a factual claim requires grounding (RFC-002 §8b)." + } + ] + }, + "router_cost": { + "tokens_estimate": 720, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into DigComp, LifeComp, or WEF.", + "Minor-naming gate is block and non-lowerable.", + "Pointer-only evidence; no inline post bodies of others.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == lite and tokens_estimate <= 900" + ], + "review": [ + "Reviewer verifies factual-claim-share gate has RFC-002 §8b grounding shape.", + "Reviewer verifies minor-naming block is preserved." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/streaming-creator.klickd b/packages/@klickd/core/x-klickd-skills/streaming-creator.klickd new file mode 100644 index 0000000..764d2ea --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/streaming-creator.klickd @@ -0,0 +1,302 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "creative", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "lite", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact. Lot A entry-tier streaming-creator pack composing x.klickd/creator (P1).", + "renamed_from": "streamer-lite.klickd" + }, + "x_klickd_pack": { + "pack": "x.klickd/streaming_creator", + "pack_version": "0.1.0-candidate-lite", + "spec_ref": "x.klickd/v4.1#a11", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "lite", + "parent_packs": [ + "x.klickd/user", + "x.klickd/creator" + ], + "target_user": "Live-streaming carrier (gaming, IRL, study-with-me). Entry tier; not a full broadcasting professional.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "digcomp", + "version": "2.2" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S1.5", + "scheme": "esco", + "prefLabel": "performing artistic work" + }, + { + "competency_ref": "digcomp:4.3", + "scheme": "digcomp", + "prefLabel": "Protecting health and well-being" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S1.5", + "scheme": "esco", + "prefLabel": "performing artistic work" + }, + { + "competency_ref": "digcomp:2.2", + "scheme": "digcomp", + "prefLabel": "Sharing through digital technologies" + }, + { + "competency_ref": "digcomp:4.3", + "scheme": "digcomp", + "prefLabel": "Protecting health and well-being" + }, + { + "competency_ref": "digcomp:4.2", + "scheme": "digcomp", + "prefLabel": "Protecting personal data and privacy" + } + ], + "competencies": [ + { + "competency_ref": "esco:S1.5", + "scheme": "esco", + "prefLabel": "performing artistic work" + }, + { + "competency_ref": "digcomp:4.2", + "scheme": "digcomp", + "prefLabel": "Protecting personal data and privacy" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/4", + "level_label": "EQF level 4", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.streaming_creator", + "memory_segments": [ + { + "id": "clips", + "scope": "memory.x_klickd.streaming_creator.clips", + "policy": "pointer_only_no_third_party_likeness" + }, + { + "id": "guests", + "scope": "memory.x_klickd.streaming_creator.guests", + "policy": "explicit_consent_required" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.streaming_creator", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/streaming_creator", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:c40c9f7147948a03a2b5f5cb7202e39d", + "attestation_hash": "sha256:bd94b552a2fba17b59afc75c3cdfc23f0a47f16b03cb8bcd2609dd65ec0c8f59" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/streaming_creator/v0-draft", + "embedding_model_ref": "klickd-embed-streaming_creator-2026-v0-placeholder", + "dim": 384, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 5, + "max_facts_per_turn": 6, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "livestream", + "creator_economy", + "monetisation", + "compliance" + ], + "entity_classes": [ + "esco", + "digcomp" + ], + "priority": "creator_practice", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "media_profile_compose_ref": "rfc-001#media_profile", + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "location_reveal", + "minor_on_stream", + "chat_driven_dare" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "minor_on_stream", + "chat_driven_dare_unsafe" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier_with_guardian_if_minor", + "agent_role": "advisory", + "escalation": "guardian_if_minor" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "location-reveal", + "action_class": "location_reveal", + "level": "confirm", + "reason": "Revealing real-world location requires explicit confirmation." + }, + { + "id": "minor-on-stream", + "action_class": "minor_on_stream", + "level": "block", + "reason": "Minors on stream require guardian consent; floor not lowerable." + }, + { + "id": "chat-driven-dare", + "action_class": "chat_driven_dare_unsafe", + "level": "block", + "reason": "Chat-driven unsafe dares blocked by default; floor not lowerable." + } + ] + }, + "router_cost": { + "tokens_estimate": 780, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into ESCO or DigComp.", + "Minor-on-stream and unsafe-dare gates are block and non-lowerable.", + "RFC-001 media_profile composed by reference; not redefined inline.", + "Pointer-only evidence; no inline clips.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == lite and tokens_estimate <= 900", + "block on minor_on_stream present" + ], + "review": [ + "Reviewer verifies guest-consent shape is present.", + "Reviewer verifies media_profile_compose_ref points to RFC-001." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/sustainability-analyst.klickd b/packages/@klickd/core/x-klickd-skills/sustainability-analyst.klickd new file mode 100644 index 0000000..48f82b7 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/sustainability-analyst.klickd @@ -0,0 +1,404 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "sustainability", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B32). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/sustainability_analyst", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b32", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/sustainability_analyst", + "frameworks": [ + "esco", + "onet", + "wef" + ], + "competency_ids": [ + "esco:S4.8", + "esco:S2.0", + "esco:S4.0.2", + "onet:13-1199.05", + "onet:19-2041.03", + "wef:environmental-stewardship", + "wef:analytical-thinking" + ], + "gate_summaries": [ + { + "id": "scope-3-omission", + "level": "block" + }, + { + "id": "external-disclosure-claim", + "level": "confirm" + }, + { + "id": "greenwashing-language", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/research", + "x.klickd/legal" + ], + "target_user": "Sustainability / ESG analyst running emissions accounting, CSRD/ESRS readiness, supplier-questionnaire analysis, materiality assessments. NOT certified auditor.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + } + ], + "citation_only_references": [ + { + "id": "csrd", + "ref": "Corporate Sustainability Reporting Directive (Directive (EU) 2022/2464)", + "url": "https://eur-lex.europa.eu/eli/dir/2022/2464/oj" + }, + { + "id": "esrs", + "ref": "European Sustainability Reporting Standards (EFRAG)", + "url": "https://www.efrag.org/lab6" + }, + { + "id": "ghg-protocol", + "ref": "GHG Protocol Corporate Standard", + "url": "https://ghgprotocol.org/corporate-standard" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.8", + "scheme": "esco", + "prefLabel": "sustainability" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "esco:S4.0.2", + "scheme": "esco", + "prefLabel": "controlling, monitoring activities, resources" + }, + { + "competency_ref": "onet:13-1199.05", + "scheme": "onet", + "prefLabel": "Sustainability Specialists" + }, + { + "competency_ref": "onet:19-2041.03", + "scheme": "onet", + "prefLabel": "Industrial Ecologists" + }, + { + "competency_ref": "wef:environmental-stewardship", + "scheme": "wef", + "prefLabel": "Environmental stewardship" + }, + { + "competency_ref": "wef:analytical-thinking", + "scheme": "wef", + "prefLabel": "Analytical thinking" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4.8", + "scheme": "esco", + "prefLabel": "sustainability" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "esco:S4.0.2", + "scheme": "esco", + "prefLabel": "controlling, monitoring activities, resources" + }, + { + "competency_ref": "onet:13-1199.05", + "scheme": "onet", + "prefLabel": "Sustainability Specialists" + }, + { + "competency_ref": "onet:19-2041.03", + "scheme": "onet", + "prefLabel": "Industrial Ecologists" + }, + { + "competency_ref": "wef:environmental-stewardship", + "scheme": "wef", + "prefLabel": "Environmental stewardship" + }, + { + "competency_ref": "wef:analytical-thinking", + "scheme": "wef", + "prefLabel": "Analytical thinking" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.sustainability_analyst", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.sustainability_analyst.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.sustainability_analyst.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.sustainability_analyst", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/sustainability_analyst", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:97a36c2a5d80fcc77658b203a3476b3f", + "attestation_hash": "sha256:607d018701c1500548c382519f7019758955154ebf501eb77cbadc977523d909" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/sustainability_analyst/v0-draft", + "embedding_model_ref": "klickd-embed-sustainability_analyst-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "sustainability", + "csrd", + "scope1", + "scope2", + "scope3", + "esg" + ], + "entity_classes": [ + "esco", + "eu_law_ref" + ], + "priority": "analytic_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "scope_three_material_omission", + "external_sustainability_claim", + "unsubstantiated_environmental_claim" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "scope_three_material_omission", + "unsubstantiated_environmental_claim" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "scope-3-omission", + "action_class": "scope_three_material_omission", + "level": "block", + "reason": "Omitting material Scope 3 categories from disclosed emissions is blocked." + }, + { + "id": "external-disclosure-claim", + "action_class": "external_sustainability_claim", + "level": "confirm", + "reason": "External sustainability claims require evidence and confirmation." + }, + { + "id": "greenwashing-language", + "action_class": "unsubstantiated_environmental_claim", + "level": "block", + "reason": "Unsubstantiated environmental claims (greenwashing) are blocked." + } + ] + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/sustainability_analyst are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/technical-writer.klickd b/packages/@klickd/core/x-klickd-skills/technical-writer.klickd new file mode 100644 index 0000000..3d88841 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/technical-writer.klickd @@ -0,0 +1,393 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "communication", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B30). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/technical_writer", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b30", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/technical_writer", + "frameworks": [ + "esco", + "sfia", + "onet", + "digcomp" + ], + "competency_ids": [ + "esco:S1.0", + "esco:S5.6", + "sfia:TECH", + "sfia:HCEV", + "onet:27-3042.00", + "digcomp:3.1", + "digcomp:3.3" + ], + "gate_summaries": [ + { + "id": "stale-source-of-truth", + "level": "block" + }, + { + "id": "third-party-attribution", + "level": "confirm" + }, + { + "id": "doc-licence-mismatch", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1100, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/coding", + "x.klickd/research" + ], + "target_user": "Technical writer producing API docs, runbooks, user guides, ADRs. Audience modelling, source-of-truth discipline, version-aware references.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://publications.jrc.ec.europa.eu/repository/handle/JRC128415/", + "canonical_url": "https://publications.jrc.ec.europa.eu/repository/handle/JRC128415" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "communication, collaboration and creativity" + }, + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT — software documentation" + }, + { + "competency_ref": "sfia:TECH", + "scheme": "sfia", + "prefLabel": "Technical specialism" + }, + { + "competency_ref": "sfia:HCEV", + "scheme": "sfia", + "prefLabel": "User experience evaluation" + }, + { + "competency_ref": "onet:27-3042.00", + "scheme": "onet", + "prefLabel": "Technical Writers" + }, + { + "competency_ref": "digcomp:3.1", + "scheme": "digcomp", + "prefLabel": "Developing digital content" + }, + { + "competency_ref": "digcomp:3.3", + "scheme": "digcomp", + "prefLabel": "Copyright and licences" + } + ], + "competencies": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "communication, collaboration and creativity" + }, + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT — software documentation" + }, + { + "competency_ref": "sfia:TECH", + "scheme": "sfia", + "prefLabel": "Technical specialism" + }, + { + "competency_ref": "sfia:HCEV", + "scheme": "sfia", + "prefLabel": "User experience evaluation" + }, + { + "competency_ref": "onet:27-3042.00", + "scheme": "onet", + "prefLabel": "Technical Writers" + }, + { + "competency_ref": "digcomp:3.1", + "scheme": "digcomp", + "prefLabel": "Developing digital content" + }, + { + "competency_ref": "digcomp:3.3", + "scheme": "digcomp", + "prefLabel": "Copyright and licences" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.technical_writer", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.technical_writer.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.technical_writer.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.technical_writer", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/technical_writer", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:83d00313bbf2182e1942229820f469a3", + "attestation_hash": "sha256:5ca5f4932b2353be4cf32250de2653e7affb934081ec4b48662bdea88993e291" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/technical_writer/v0-draft", + "embedding_model_ref": "klickd-embed-technical_writer-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "docs", + "style_guide", + "diataxis", + "release_notes", + "api_reference" + ], + "entity_classes": [ + "esco", + "sfia" + ], + "priority": "writing_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "publish_against_stale_source", + "third_party_attribution_write", + "doc_licence_mismatch" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "publish_against_stale_source", + "doc_licence_mismatch" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "stale-source-of-truth", + "action_class": "publish_against_stale_source", + "level": "block", + "reason": "Publishing docs that contradict the version-locked source-of-truth is blocked." + }, + { + "id": "third-party-attribution", + "action_class": "third_party_attribution_write", + "level": "confirm", + "reason": "Attributing a quoted statement to a third party requires confirmation." + }, + { + "id": "doc-licence-mismatch", + "action_class": "doc_licence_mismatch", + "level": "block", + "reason": "Publishing third-party content under a mismatched licence is blocked." + } + ] + }, + "router_cost": { + "tokens_estimate": 1100, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/technical_writer are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/trust-evidence.klickd b/packages/@klickd/core/x-klickd-skills/trust-evidence.klickd new file mode 100644 index 0000000..2152346 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/trust-evidence.klickd @@ -0,0 +1,364 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "trust_and_safety", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B5). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/trust_evidence", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b5", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/trust_evidence", + "frameworks": [ + "esco", + "digcomp" + ], + "competency_ids": [ + "esco:S2.0", + "esco:S2.5", + "esco:S4.6", + "digcomp:1.2", + "digcomp:1.3" + ], + "gate_summaries": [ + { + "id": "third-party-attribution", + "level": "confirm" + }, + { + "id": "data-subject-right-touch", + "level": "confirm" + }, + { + "id": "chain-of-custody-break", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/research" + ], + "target_user": "Trust & safety analyst / evidence-desk operator. Claim grounding, chain-of-custody, escalation discipline.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "digcomp", + "version": "2.2" + } + ], + "transversal_refs": [ + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "esco:S2.5", + "scheme": "esco", + "prefLabel": "investigating and reporting" + }, + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "digcomp:1.3", + "scheme": "digcomp", + "prefLabel": "Managing data, information and digital content" + } + ], + "competencies": [ + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "esco:S2.5", + "scheme": "esco", + "prefLabel": "investigating and reporting" + }, + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "digcomp:1.3", + "scheme": "digcomp", + "prefLabel": "Managing data, information and digital content" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.trust_evidence", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.trust_evidence.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.trust_evidence.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.trust_evidence", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/trust_evidence", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:5101c35112cd915e469e2a83714eb724", + "attestation_hash": "sha256:6e1fc58ba6754b45596f9d9241689ec61b599640d586eb737bd665b03bb67dc4" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/trust_evidence/v0-draft", + "embedding_model_ref": "klickd-embed-trust_evidence-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "trust", + "attestation", + "sbom", + "provenance", + "verification_artifact" + ], + "entity_classes": [ + "esco", + "nice" + ], + "priority": "evidence_handling", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "third_party_attributable_claim", + "data_subject_right_touch", + "chain_of_custody_break" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "chain_of_custody_break" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "third-party-attribution", + "action_class": "third_party_attributable_claim", + "level": "confirm", + "reason": "Claims attributable to a named third party require confirmation." + }, + { + "id": "data-subject-right-touch", + "action_class": "data_subject_right_touch", + "level": "confirm", + "reason": "Escalation to legal counsel required when touching a data-subject right." + }, + { + "id": "chain-of-custody-break", + "action_class": "chain_of_custody_break", + "level": "block", + "reason": "Chain-of-custody breaks blocked; floor not lowerable." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/trust_evidence are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/ux-researcher.klickd b/packages/@klickd/core/x-klickd-skills/ux-researcher.klickd new file mode 100644 index 0000000..c397895 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/ux-researcher.klickd @@ -0,0 +1,393 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "research", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B21). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/ux_researcher", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b21", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/ux_researcher", + "frameworks": [ + "esco", + "sfia", + "onet", + "digcomp" + ], + "competency_ids": [ + "esco:S1.2", + "esco:S2", + "esco:S5.6", + "sfia:URCH", + "sfia:HCEV", + "onet:15-1255.00", + "digcomp:1.2" + ], + "gate_summaries": [ + { + "id": "participant-consent-skip", + "level": "block" + }, + { + "id": "participant-recontact", + "level": "confirm" + }, + { + "id": "raw-pii-export", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/research" + ], + "target_user": "UX researcher running mixed-method discovery (interviews, usability testing, surveys, diary studies). Participant consent, bias mitigation, evidence-grounded reporting.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://publications.jrc.ec.europa.eu/repository/handle/JRC128415/", + "canonical_url": "https://publications.jrc.ec.europa.eu/repository/handle/JRC128415" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S1.2", + "scheme": "esco", + "prefLabel": "supporting interpersonal communication" + }, + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT — software analysis" + }, + { + "competency_ref": "sfia:URCH", + "scheme": "sfia", + "prefLabel": "User research" + }, + { + "competency_ref": "sfia:HCEV", + "scheme": "sfia", + "prefLabel": "User experience evaluation" + }, + { + "competency_ref": "onet:15-1255.00", + "scheme": "onet", + "prefLabel": "Web and Digital Interface Designers" + }, + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information, and digital content" + } + ], + "competencies": [ + { + "competency_ref": "esco:S1.2", + "scheme": "esco", + "prefLabel": "supporting interpersonal communication" + }, + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT — software analysis" + }, + { + "competency_ref": "sfia:URCH", + "scheme": "sfia", + "prefLabel": "User research" + }, + { + "competency_ref": "sfia:HCEV", + "scheme": "sfia", + "prefLabel": "User experience evaluation" + }, + { + "competency_ref": "onet:15-1255.00", + "scheme": "onet", + "prefLabel": "Web and Digital Interface Designers" + }, + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information, and digital content" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.ux_researcher", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.ux_researcher.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.ux_researcher.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.ux_researcher", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/ux_researcher", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:337382b228ec0470b2298961ba9c3cba", + "attestation_hash": "sha256:c63fed8809f03b22359f81345b144655f325d99ae7a0de7651b69af883e1f143" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/ux_researcher/v0-draft", + "embedding_model_ref": "klickd-embed-ux_researcher-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "ux_research", + "interview", + "usability_test", + "synthesis", + "jtbd" + ], + "entity_classes": [ + "esco", + "sfia", + "onet" + ], + "priority": "research_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "skip_participant_consent", + "participant_recontact_write", + "raw_pii_export" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "skip_participant_consent", + "raw_pii_export" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "participant-consent-skip", + "action_class": "skip_participant_consent", + "level": "block", + "reason": "Research without recorded participant consent is blocked." + }, + { + "id": "participant-recontact", + "action_class": "participant_recontact_write", + "level": "confirm", + "reason": "Re-contacting a participant requires explicit confirmation against consent terms." + }, + { + "id": "raw-pii-export", + "action_class": "raw_pii_export", + "level": "block", + "reason": "Exporting raw participant PII outside the research perimeter is blocked." + } + ] + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/ux_researcher are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/video-production-pipeline.klickd b/packages/@klickd/core/x-klickd-skills/video-production-pipeline.klickd new file mode 100644 index 0000000..0c27ab5 --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/video-production-pipeline.klickd @@ -0,0 +1,554 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "creative", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B19). Pro tier; compact_index loading strategy declared. Authored from a read-only audit of an open-source video pipeline (MoneyPrinterTurbo); no upstream code or assets bundled." + }, + "x_klickd_pack": { + "pack": "x.klickd/video_production_pipeline", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b19", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/video_production_pipeline", + "frameworks": [ + "esco", + "sfia", + "digcomp", + "onet" + ], + "competency_ids": [ + "esco:S1.0", + "esco:S5.6.1", + "sfia:DESN", + "sfia:PROG", + "digcomp:3.1", + "digcomp:3.3", + "onet:27-3041.00" + ], + "gate_summaries": [ + { + "id": "auto-publish-social", + "level": "block" + }, + { + "id": "real-person-likeness-or-voice", + "level": "block" + }, + { + "id": "copyrighted-asset-use", + "level": "block" + }, + { + "id": "paid-api-spend-over-threshold", + "level": "confirm" + }, + { + "id": "product-performance-claim-without-evidence", + "level": "block" + }, + { + "id": "risky-provider-use", + "level": "block" + }, + { + "id": "stock-media-license-write", + "level": "confirm" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1300, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/media_planner", + "x.klickd/creator", + "x.klickd/research", + "x.klickd/legal" + ], + "target_user": "Advanced creator / marketing engineer producing demo and marketing videos for a software product (e.g. a .klickd skill). Owns script, storyboard, shot list, voice-over, subtitles, render plan, provenance, rights, QA, benchmark reproducibility. Not a broadcast editor; not auto-publishing.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + } + ], + "citation_only_references": [ + { + "id": "ffmpeg", + "ref": "FFmpeg multimedia framework", + "url": "https://ffmpeg.org/" + }, + { + "id": "srt", + "ref": "SubRip Text subtitle format", + "url": "https://en.wikipedia.org/wiki/SubRip" + }, + { + "id": "moneyprinterturbo", + "ref": "MoneyPrinterTurbo (read-only audit reference)", + "url": "https://github.com/harry0703/MoneyPrinterTurbo" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "digcomp", + "version": "2.2" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "digcomp:3.1", + "scheme": "digcomp", + "prefLabel": "Developing digital content" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "creativity and innovation" + }, + { + "competency_ref": "esco:S5.6.1", + "scheme": "esco", + "prefLabel": "ICT software development" + }, + { + "competency_ref": "sfia:DESN", + "scheme": "sfia", + "prefLabel": "Systems design" + }, + { + "competency_ref": "sfia:PROG", + "scheme": "sfia", + "prefLabel": "Programming/software development" + }, + { + "competency_ref": "digcomp:3.1", + "scheme": "digcomp", + "prefLabel": "Developing digital content" + }, + { + "competency_ref": "digcomp:3.3", + "scheme": "digcomp", + "prefLabel": "Copyright and licences" + }, + { + "competency_ref": "onet:27-3041.00", + "scheme": "onet", + "prefLabel": "Editors" + } + ], + "competencies": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "creativity and innovation" + }, + { + "competency_ref": "esco:S5.6.1", + "scheme": "esco", + "prefLabel": "ICT software development" + }, + { + "competency_ref": "sfia:DESN", + "scheme": "sfia", + "prefLabel": "Systems design" + }, + { + "competency_ref": "sfia:PROG", + "scheme": "sfia", + "prefLabel": "Programming/software development" + }, + { + "competency_ref": "digcomp:3.1", + "scheme": "digcomp", + "prefLabel": "Developing digital content" + }, + { + "competency_ref": "digcomp:3.3", + "scheme": "digcomp", + "prefLabel": "Copyright and licences" + }, + { + "competency_ref": "onet:27-3041.00", + "scheme": "onet", + "prefLabel": "Editors" + } + ], + "competency_deltas": [ + "media-pipeline-orchestration", + "tts-and-forced-alignment", + "subtitle-rendering", + "structured-llm-output-resilience", + "multi-provider-llm-dispatch", + "stock-media-api-orchestration", + "ffmpeg-and-moviepy-safety", + "media-provenance-tracking" + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.video_production_pipeline", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.video_production_pipeline.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.video_production_pipeline.evidence", + "policy": "pointer_only_chain_of_custody" + }, + { + "id": "rights", + "scope": "memory.x_klickd.video_production_pipeline.rights", + "policy": "pointer_only_attribution" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.video_production_pipeline", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/video_production_pipeline", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:79f77682b3cfe75b3a55207a4c0f2a5d", + "attestation_hash": "sha256:503e12d5ec8c5be3b0a7db062851749610734654879c08b5dc8260dd059dd035" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/video_production_pipeline/v0-draft", + "embedding_model_ref": "klickd-embed-video_production_pipeline-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "video", + "edit_decision_list", + "color_pipeline", + "delivery_spec" + ], + "entity_classes": [ + "esco", + "onet" + ], + "priority": "creative_practice", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "media_profile_compose_ref": "rfc-001#media_profile", + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "auto_publish_to_social", + "real_person_likeness_or_voice", + "copyrighted_asset_use", + "paid_api_spend_over_threshold", + "product_performance_claim_without_evidence", + "risky_provider_use", + "stock_media_license_write" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "auto_publish_to_social", + "real_person_likeness_or_voice", + "copyrighted_asset_use", + "product_performance_claim_without_evidence", + "risky_provider_use" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts", + "product_performance_rule": "Product-performance claims in the produced video MUST cite a reproducible benchmark pointer (RFC-003); unsupported claims blocked." + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ], + "no_undocumented_bundled_assets": true + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "auto-publish-social", + "action_class": "auto_publish_to_social", + "level": "block", + "reason": "Auto-publish to social blocked; floor not lowerable." + }, + { + "id": "real-person-likeness-or-voice", + "action_class": "real_person_likeness_or_voice", + "level": "block", + "reason": "Real-person likeness/voice requires evidenced consent." + }, + { + "id": "copyrighted-asset-use", + "action_class": "copyrighted_asset_use", + "level": "block", + "reason": "Copyrighted assets without recorded rights blocked." + }, + { + "id": "paid-api-spend-over-threshold", + "action_class": "paid_api_spend_over_threshold", + "level": "confirm", + "reason": "Paid API spend over carrier threshold." + }, + { + "id": "product-performance-claim-without-evidence", + "action_class": "product_performance_claim_without_evidence", + "level": "block", + "reason": "Claim needs reproducible benchmark pointer." + }, + { + "id": "risky-provider-use", + "action_class": "risky_provider_use", + "level": "block", + "reason": "Risky providers (e.g. g4f, pollinations) blocked unless explicit safety gate clears them." + }, + { + "id": "stock-media-license-write", + "action_class": "stock_media_license_write", + "level": "confirm", + "reason": "Stock-media licence write requires confirmation." + } + ] + }, + "pipeline_checkpoints": [ + { + "id": "script", + "stop_at": true, + "produces": [ + "script.json" + ] + }, + { + "id": "storyboard", + "stop_at": true, + "produces": [ + "storyboard.json" + ] + }, + { + "id": "shot_list", + "stop_at": true, + "produces": [ + "shots.json" + ] + }, + { + "id": "prompt_list", + "stop_at": true, + "produces": [ + "prompts.json" + ] + }, + { + "id": "voice_over", + "stop_at": true, + "produces": [ + "tts.wav", + "tts.timings.json" + ] + }, + { + "id": "subtitles", + "stop_at": true, + "produces": [ + "subs.srt" + ] + }, + { + "id": "render_plan", + "stop_at": true, + "produces": [ + "render_plan.json" + ] + }, + { + "id": "provenance", + "stop_at": true, + "produces": [ + "provenance.json" + ] + }, + { + "id": "qa", + "stop_at": true, + "produces": [ + "qa_report.json" + ] + } + ], + "router_cost": { + "tokens_estimate": 1300, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into a framework declared in frameworks[].", + "Citation-only references (FFmpeg, SRT, MoneyPrinterTurbo) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline PII; no bundled assets.", + "pipeline_checkpoints declare stop_at points for deterministic resume.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parents (user, media_planner, creator, research, legal) are referenced without redefinition.", + "Reviewer verifies risky-provider blocklist is not re-enabled silently by composition.", + "Reviewer verifies stock-media is OPTIONAL for product demos; primary visual layer is captured product footage.", + "Reviewer verifies product-performance claims cite a benchmark artefact pointer.", + "Reviewer verifies citation-only references are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/@klickd/core/x-klickd-skills/work-assistant.klickd b/packages/@klickd/core/x-klickd-skills/work-assistant.klickd new file mode 100644 index 0000000..157a33e --- /dev/null +++ b/packages/@klickd/core/x-klickd-skills/work-assistant.klickd @@ -0,0 +1,331 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "professional", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "lite", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact. Composes with x.klickd/work (P1); narrower day-to-day assistant scope.", + "renamed_from": "work-lite.klickd" + }, + "x_klickd_pack": { + "pack": "x.klickd/work_assistant", + "pack_version": "0.1.0-candidate-lite", + "spec_ref": "x.klickd/v4.1#a1", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "lite", + "parent_packs": [ + "x.klickd/user", + "x.klickd/work" + ], + "target_user": "Employed person or freelancer covering day-to-day deliverables, communication, and planning. Not a senior PM (that stays in full x.klickd/work).", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "lifecomp", + "version": "2020", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/lifecomp/2020/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/lifecomp_en" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "lifecomp", + "version": "2020" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S1", + "scheme": "esco", + "prefLabel": "communication, collaboration and creativity" + }, + { + "competency_ref": "lifecomp:P1", + "scheme": "lifecomp", + "prefLabel": "Self-regulation" + }, + { + "competency_ref": "lifecomp:S2", + "scheme": "lifecomp", + "prefLabel": "Collaboration" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S1.3", + "scheme": "esco", + "prefLabel": "managing oneself and personal development" + }, + { + "competency_ref": "esco:S1.4", + "scheme": "esco", + "prefLabel": "working with others" + }, + { + "competency_ref": "esco:S4", + "scheme": "esco", + "prefLabel": "management skills" + }, + { + "competency_ref": "lifecomp:S2", + "scheme": "lifecomp", + "prefLabel": "Collaboration" + }, + { + "competency_ref": "wef:active-learning", + "scheme": "wef", + "prefLabel": "Active learning and learning strategies" + }, + { + "competency_ref": "wef:leadership-social-influence", + "scheme": "wef", + "prefLabel": "Leadership and social influence" + } + ], + "competencies": [ + { + "competency_ref": "esco:S1.3", + "scheme": "esco", + "prefLabel": "managing oneself and personal development" + }, + { + "competency_ref": "esco:S1.4", + "scheme": "esco", + "prefLabel": "working with others" + }, + { + "competency_ref": "esco:S4", + "scheme": "esco", + "prefLabel": "management skills" + }, + { + "competency_ref": "wef:active-learning", + "scheme": "wef", + "prefLabel": "Active learning and learning strategies" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/4", + "level_label": "EQF level 4", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.work_assistant", + "memory_segments": [ + { + "id": "deliverables", + "scope": "memory.x_klickd.work_assistant.deliverables", + "policy": "pointer_only_summary" + }, + { + "id": "stakeholders", + "scope": "memory.x_klickd.work_assistant.stakeholders", + "policy": "pointer_only_no_pii_of_others" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.work_assistant", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/work_assistant", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:5674f0c94c1de54d9c4f583943de64ee", + "attestation_hash": "sha256:ffd3c88b9eab152655ed2044aa21c989e85f7f50154ecec07f2741fd6774863e" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/work_assistant/v0-draft", + "embedding_model_ref": "klickd-embed-work_assistant-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 5, + "max_facts_per_turn": 7, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "work_admin", + "scheduling", + "email_triage", + "documents" + ], + "entity_classes": [ + "esco", + "lifecomp" + ], + "priority": "workflow_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "stakeholder_message", + "deliverable_release", + "team_attribution" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "irreversible_action", + "third_party_attribution" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "senior_reviewer_for_stakeholder_facing_artefacts" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "stakeholder-message", + "action_class": "stakeholder_message", + "level": "confirm", + "reason": "Outgoing stakeholder communication requires explicit human authorisation." + }, + { + "id": "deliverable-release", + "action_class": "deliverable_release", + "level": "confirm", + "reason": "Deliverable release is hard to reverse once shared." + }, + { + "id": "team-attribution", + "action_class": "team_attribution", + "level": "confirm", + "reason": "Attribution to a named teammate requires consent." + } + ] + }, + "router_cost": { + "tokens_estimate": 800, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into the canonical framework registry (ESCO/LifeComp/WEF).", + "No host-side method, pedagogy, or scoring rubric inside the pack.", + "No PII of teammates or stakeholders; pointer-only.", + "Stakeholder-facing actions gated to confirm by default; raise_only true.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == lite and tokens_estimate <= 900" + ], + "review": [ + "Reviewer verifies x.klickd/work parent compose; no redefinition of P1 work pack defaults.", + "Reviewer verifies no entry-level deliverable bypasses the senior_reviewer escalation." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/README.md b/packages/pypi/klickd/README.md index bd89b1b..eb5d998 100644 --- a/packages/pypi/klickd/README.md +++ b/packages/pypi/klickd/README.md @@ -160,6 +160,30 @@ manifest = get_starter_skills_manifest() path = get_starter_skills_dir() # importlib.resources Traversable as str ``` +### x.klickd v4.1 skill packs (42 candidate packs — non-normative) + +The 42 x.klickd v4.1 candidate skill packs (8 Lite + 34 Pro) ship inside the +wheel and sdist as `klickd/x_klickd_skills/*.klickd` alongside the aggregated +download index `manifest.json`. They are **NON-NORMATIVE** and **NOT a v4.1 GA +release**, and they are JSON artifacts — **not** native skills in any assistant. +A pack is only "used" once `artifact_loaded` **and** `sha256_matches_manifest` +are both true. + +```python +import klickd + +len(klickd.list_xklickd_skill_packs()) # → 42 + +skill = klickd.load_xklickd_skill_pack("llm-agent-engineering") +# skill["artifact_loaded"] is True, skill["sha256_matches_manifest"] is True +# skill["tier"], skill["competency_ids"], skill["gates"], skill["evidence_policy"], ... + +raw = klickd.get_xklickd_skill_pack_bytes("x.klickd/work_assistant") # by file, pack id, or bare id +``` + +Full protocol and truth boundary: +[`docs/integrations/skill-loader-protocol.md`](https://github.com/Davincc77/klickdskill/blob/main/docs/integrations/skill-loader-protocol.md). + --- ## Cryptographic specification (v3.0) diff --git a/packages/pypi/klickd/pyproject.toml b/packages/pypi/klickd/pyproject.toml index c1ff850..d0cef7d 100644 --- a/packages/pypi/klickd/pyproject.toml +++ b/packages/pypi/klickd/pyproject.toml @@ -42,7 +42,8 @@ Documentation = "https://github.com/Davincc77/klickdskill/blob/main/SPEC.md" [tool.hatch.build.targets.wheel] packages = ["src/klickd"] -# Schema files under src/klickd/schemas/ and starter .klickd files under -# src/klickd/starter_skills/ are part of the package tree and are +# Schema files under src/klickd/schemas/, starter .klickd files under +# src/klickd/starter_skills/, and the 42 x.klickd v4.1 skill packs under +# src/klickd/x_klickd_skills/ are part of the package tree and are # auto-included by hatchling when packages = ["src/klickd"] selects the # parent directory. No explicit include rule is required. diff --git a/packages/pypi/klickd/src/klickd/__init__.py b/packages/pypi/klickd/src/klickd/__init__.py index c4ad762..471a84a 100644 --- a/packages/pypi/klickd/src/klickd/__init__.py +++ b/packages/pypi/klickd/src/klickd/__init__.py @@ -21,6 +21,13 @@ get_starter_skill_bytes, get_starter_skills_manifest, ) +from .x_klickd_skills_resources import ( + get_xklickd_skills_dir, + get_xklickd_skills_manifest, + list_xklickd_skill_packs, + get_xklickd_skill_pack_bytes, + load_xklickd_skill_pack, +) from ._types import ( KlickdPayload, KlickdEnvelope, @@ -50,6 +57,11 @@ "list_starter_skills", "get_starter_skill_bytes", "get_starter_skills_manifest", + "get_xklickd_skills_dir", + "get_xklickd_skills_manifest", + "list_xklickd_skill_packs", + "get_xklickd_skill_pack_bytes", + "load_xklickd_skill_pack", "KlickdError", "KlickdErrorCode", "HTTP_STATUS", diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/accounting-operator.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/accounting-operator.klickd new file mode 100644 index 0000000..8bcfbba --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/accounting-operator.klickd @@ -0,0 +1,364 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "accounting", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B29). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/accounting_operator", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b29", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/accounting_operator", + "frameworks": [ + "esco", + "onet", + "sfia" + ], + "competency_ids": [ + "esco:S4.0.2", + "esco:S4.7", + "onet:13-2011.00", + "onet:43-3031.00", + "sfia:FMIT" + ], + "gate_summaries": [ + { + "id": "ledger-back-dated-entry", + "level": "block" + }, + { + "id": "statutory-filing", + "level": "confirm" + }, + { + "id": "regulated-tax-advice", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1100, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/work", + "x.klickd/legal" + ], + "target_user": "Accounting operator (bookkeeper, accounts receivable/payable, junior controller) maintaining ledgers, reconciliations, statutory filings. NOT a tax advisor; NOT a chartered auditor.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.0.2", + "scheme": "esco", + "prefLabel": "controlling, monitoring activities, resources" + }, + { + "competency_ref": "esco:S4.7", + "scheme": "esco", + "prefLabel": "administration support" + }, + { + "competency_ref": "onet:13-2011.00", + "scheme": "onet", + "prefLabel": "Accountants and Auditors" + }, + { + "competency_ref": "onet:43-3031.00", + "scheme": "onet", + "prefLabel": "Bookkeeping, Accounting, and Auditing Clerks" + }, + { + "competency_ref": "sfia:FMIT", + "scheme": "sfia", + "prefLabel": "Financial management" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4.0.2", + "scheme": "esco", + "prefLabel": "controlling, monitoring activities, resources" + }, + { + "competency_ref": "esco:S4.7", + "scheme": "esco", + "prefLabel": "administration support" + }, + { + "competency_ref": "onet:13-2011.00", + "scheme": "onet", + "prefLabel": "Accountants and Auditors" + }, + { + "competency_ref": "onet:43-3031.00", + "scheme": "onet", + "prefLabel": "Bookkeeping, Accounting, and Auditing Clerks" + }, + { + "competency_ref": "sfia:FMIT", + "scheme": "sfia", + "prefLabel": "Financial management" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/5", + "level_label": "EQF level 5", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.accounting_operator", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.accounting_operator.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.accounting_operator.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.accounting_operator", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/accounting_operator", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:38869f92d12405171e53e3e29849a40e", + "attestation_hash": "sha256:77a3aecd5ee2381fe9efffc1e79cce2abc36e4744967169db583b0fe315661a6" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/accounting_operator/v0-draft", + "embedding_model_ref": "klickd-embed-accounting_operator-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "accounting", + "ledger", + "vat", + "month_end", + "audit_trail" + ], + "entity_classes": [ + "esco", + "sfia" + ], + "priority": "ledger_operation", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "back_dated_ledger_entry", + "statutory_filing_submission", + "regulated_tax_advice_output" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "back_dated_ledger_entry", + "regulated_tax_advice_output" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "ledger-back-dated-entry", + "action_class": "back_dated_ledger_entry", + "level": "block", + "reason": "Back-dated ledger entries outside a declared period are blocked." + }, + { + "id": "statutory-filing", + "action_class": "statutory_filing_submission", + "level": "confirm", + "reason": "Statutory filings require explicit human confirmation." + }, + { + "id": "regulated-tax-advice", + "action_class": "regulated_tax_advice_output", + "level": "block", + "reason": "Output resembling regulated tax advice is blocked; escalate to tax advisor." + } + ] + }, + "router_cost": { + "tokens_estimate": 1100, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/accounting_operator are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/api-integrator.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/api-integrator.klickd new file mode 100644 index 0000000..a82224c --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/api-integrator.klickd @@ -0,0 +1,381 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "software_engineering", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B23). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/api_integrator", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b23", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/api_integrator", + "frameworks": [ + "esco", + "sfia", + "onet", + "digcomp" + ], + "competency_ids": [ + "esco:S5.6", + "sfia:PROG", + "sfia:HSIN", + "sfia:METL", + "onet:15-1254.00", + "digcomp:3.4" + ], + "gate_summaries": [ + { + "id": "vendor-secret-handling", + "level": "block" + }, + { + "id": "retry-budget-override", + "level": "confirm" + }, + { + "id": "vendor-version-bump", + "level": "confirm" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/coding" + ], + "target_user": "Engineer integrating third-party APIs and building webhook / event consumers. Idempotency, retry budgets, secret hygiene, vendor change discipline.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://publications.jrc.ec.europa.eu/repository/handle/JRC128415/", + "canonical_url": "https://publications.jrc.ec.europa.eu/repository/handle/JRC128415" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT — software development" + }, + { + "competency_ref": "sfia:PROG", + "scheme": "sfia", + "prefLabel": "Programming/software development" + }, + { + "competency_ref": "sfia:HSIN", + "scheme": "sfia", + "prefLabel": "Systems integration and build" + }, + { + "competency_ref": "sfia:METL", + "scheme": "sfia", + "prefLabel": "Methods and tools" + }, + { + "competency_ref": "onet:15-1254.00", + "scheme": "onet", + "prefLabel": "Web Developers" + }, + { + "competency_ref": "digcomp:3.4", + "scheme": "digcomp", + "prefLabel": "Programming" + } + ], + "competencies": [ + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT — software development" + }, + { + "competency_ref": "sfia:PROG", + "scheme": "sfia", + "prefLabel": "Programming/software development" + }, + { + "competency_ref": "sfia:HSIN", + "scheme": "sfia", + "prefLabel": "Systems integration and build" + }, + { + "competency_ref": "sfia:METL", + "scheme": "sfia", + "prefLabel": "Methods and tools" + }, + { + "competency_ref": "onet:15-1254.00", + "scheme": "onet", + "prefLabel": "Web Developers" + }, + { + "competency_ref": "digcomp:3.4", + "scheme": "digcomp", + "prefLabel": "Programming" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.api_integrator", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.api_integrator.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.api_integrator.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.api_integrator", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/api_integrator", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:b7bbde86ab488da149599e75fd3a80c3", + "attestation_hash": "sha256:6fa4d58ca8b32001503ee90c13b8453e2e5d101e2404f4c02fc8453b96cf4561" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/api_integrator/v0-draft", + "embedding_model_ref": "klickd-embed-api_integrator-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 7, + "max_facts_per_turn": 9, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "api", + "webhook", + "retry", + "idempotency", + "schema_drift" + ], + "entity_classes": [ + "esco", + "sfia", + "onet" + ], + "priority": "integration_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "secret_in_source_or_log", + "retry_budget_override", + "vendor_major_version_bump" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "secret_in_source_or_log" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "vendor-secret-handling", + "action_class": "secret_in_source_or_log", + "level": "block", + "reason": "Vendor secrets in source or log surface are blocked." + }, + { + "id": "retry-budget-override", + "action_class": "retry_budget_override", + "level": "confirm", + "reason": "Overriding declared retry budget requires explicit confirmation." + }, + { + "id": "vendor-version-bump", + "action_class": "vendor_major_version_bump", + "level": "confirm", + "reason": "Major-version vendor SDK bumps require confirmation against a contract test." + } + ] + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/api_integrator are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/artist.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/artist.klickd new file mode 100644 index 0000000..4b3213e --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/artist.klickd @@ -0,0 +1,305 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "creative", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "lite", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact. Lot A artist pack, distinct from x.klickd/creator (P1)." + }, + "x_klickd_pack": { + "pack": "x.klickd/artist", + "pack_version": "0.1.0-candidate-lite", + "spec_ref": "x.klickd/v4.1#a10", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "lite", + "parent_packs": [ + "x.klickd/user", + "x.klickd/creator" + ], + "target_user": "Independent visual / musical / performing artist focused on practice rather than production-line creator workflow.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "lifecomp", + "version": "2020", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/lifecomp/2020/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/lifecomp_en" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "lifecomp", + "version": "2020" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "creativity and innovation" + }, + { + "competency_ref": "lifecomp:P3", + "scheme": "lifecomp", + "prefLabel": "Well-being" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "creativity and innovation" + }, + { + "competency_ref": "esco:S1.5", + "scheme": "esco", + "prefLabel": "performing artistic work" + }, + { + "competency_ref": "lifecomp:P3", + "scheme": "lifecomp", + "prefLabel": "Well-being" + }, + { + "competency_ref": "digcomp:3.1", + "scheme": "digcomp", + "prefLabel": "Developing digital content" + } + ], + "competencies": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "creativity and innovation" + }, + { + "competency_ref": "esco:S1.5", + "scheme": "esco", + "prefLabel": "performing artistic work" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/5", + "level_label": "EQF level 5", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.artist", + "memory_segments": [ + { + "id": "works", + "scope": "memory.x_klickd.artist.works", + "policy": "pointer_only_attribution" + }, + { + "id": "ai-training-consent", + "scope": "memory.x_klickd.artist.consent", + "policy": "explicit_opt_in_required" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.artist", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/artist", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:5607a96ccfb90c24663dbf3a3b88d9a6", + "attestation_hash": "sha256:9453db73e1f98ca8ceec5852791d193832271a15e90c9514f5efc66148bf4ff2" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/artist/v0-draft", + "embedding_model_ref": "klickd-embed-artist-2026-v0-placeholder", + "dim": 384, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 4, + "max_facts_per_turn": 6, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "creator", + "visual_arts", + "portfolio", + "originality" + ], + "entity_classes": [ + "esco", + "lifecomp" + ], + "priority": "creative_practice", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "work_attribution", + "ai_training_use", + "third_party_likeness" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "ai_training_use_without_opt_in" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "human_carrier_only" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "ai_training_consent_default": "opt_out", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "ai-training-use", + "action_class": "ai_training_use", + "level": "block", + "reason": "AI-training use of carrier's work is opt-out by default; explicit opt-in required." + }, + { + "id": "work-attribution", + "action_class": "work_attribution", + "level": "confirm", + "reason": "Attribution of a work requires explicit confirmation by carrier." + }, + { + "id": "third-party-likeness", + "action_class": "third_party_likeness", + "level": "confirm", + "reason": "Use of a recognisable third-party likeness requires consent and confirmation." + } + ] + }, + "router_cost": { + "tokens_estimate": 750, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into ESCO, LifeComp, or DigComp.", + "AI-training-use is opt-out by default; explicit opt-in required to lower.", + "Pointer-only evidence for works; no inline work bytes.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == lite and tokens_estimate <= 900", + "ai_training_consent_default == opt_out" + ], + "review": [ + "Reviewer verifies opt-out default is preserved.", + "Reviewer verifies third_party_likeness gate stays at confirm or above." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/consumer-rights.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/consumer-rights.klickd new file mode 100644 index 0000000..0e94334 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/consumer-rights.klickd @@ -0,0 +1,301 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "legal", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "lite", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact. Lot A consumer-rights pack composing x.klickd/user and x.klickd/legal (P0)." + }, + "x_klickd_pack": { + "pack": "x.klickd/consumer_rights", + "pack_version": "0.1.0-candidate-lite", + "spec_ref": "x.klickd/v4.1#a7", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "lite", + "parent_packs": [ + "x.klickd/user", + "x.klickd/legal" + ], + "target_user": "Consumer carrier dealing with returns, warranty, distance-selling, GDPR data-subject rights. Not litigation.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + } + ], + "citation_only_references": [ + { + "id": "eu-consumer-rights-directive", + "ref": "Directive 2011/83/EU", + "url": "https://eur-lex.europa.eu/eli/dir/2011/83/oj" + }, + { + "id": "gdpr-art-12-22", + "ref": "Regulation (EU) 2016/679 Art. 12-22", + "url": "https://eur-lex.europa.eu/eli/reg/2016/679/oj" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "digcomp", + "version": "2.2" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.7", + "scheme": "esco", + "prefLabel": "administration" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "digcomp:4.2", + "scheme": "digcomp", + "prefLabel": "Protecting personal data and privacy" + } + ], + "competencies": [ + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "digcomp:4.2", + "scheme": "digcomp", + "prefLabel": "Protecting personal data and privacy" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/4", + "level_label": "EQF level 4", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.consumer_rights", + "memory_segments": [ + { + "id": "disputes", + "scope": "memory.x_klickd.consumer_rights.disputes", + "policy": "pointer_only_no_third_party_text" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.consumer_rights", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/consumer_rights", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:9a9fb73fa76bacedb09e5a853152d335", + "attestation_hash": "sha256:1e0f9f135f49a1c743fe4405740a255abdc587fac74ae6e411420e96a608671e" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/consumer_rights/v0-draft", + "embedding_model_ref": "klickd-embed-consumer_rights-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 5, + "max_facts_per_turn": 6, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "consumer", + "eu_law", + "redress", + "complaint", + "warranty" + ], + "entity_classes": [ + "esco", + "eu_law_ref" + ], + "priority": "rights_lookup", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "legal_dispute_escalation", + "contract_assertion", + "third_party_communication" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "litigation_action" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "licensed_lawyer_required_after_first_written_reply" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "third-party-comms", + "action_class": "third_party_communication", + "level": "confirm", + "reason": "Outgoing communication to a vendor / counterparty requires explicit confirmation." + }, + { + "id": "legal-assertion", + "action_class": "contract_assertion", + "level": "confirm", + "reason": "Asserting a legal right requires grounding to the specific clause / directive." + }, + { + "id": "litigation-action", + "action_class": "litigation_action", + "level": "block", + "reason": "Litigation steps require licensed counsel; this pack cannot authorise them." + } + ] + }, + "router_cost": { + "tokens_estimate": 700, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into ESCO or DigComp.", + "EU directives are cited (citation_only_references), not registered as frameworks[] schemes.", + "Litigation actions blocked; mandatory escalation to licensed lawyer.", + "Pointer-only evidence; no inline third-party contract text.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == lite and tokens_estimate <= 900" + ], + "review": [ + "Reviewer verifies EU AI Act / GDPR are citation-only, not in frameworks[].", + "Reviewer verifies litigation_action gate stays block." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/contract-review.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/contract-review.klickd new file mode 100644 index 0000000..dac085f --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/contract-review.klickd @@ -0,0 +1,338 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "legal", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B8). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/contract_review", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b8", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/contract_review", + "frameworks": [ + "esco", + "onet" + ], + "competency_ids": [ + "esco:S4.6", + "esco:S4.6.3", + "onet:23-1011.00" + ], + "gate_summaries": [ + { + "id": "clause-flag-send", + "level": "confirm" + }, + { + "id": "liability-redline", + "level": "block" + }, + { + "id": "confidential-text-inline", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/legal" + ], + "target_user": "Legal-adjacent reviewer (in-house counsel, contract manager, founder) reading commercial contracts. Clause spotting, risk flagging, escalation. Not legal advice.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "onet", + "version": "28.0" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S4.6.3", + "scheme": "esco", + "prefLabel": "contract law and commercial law" + }, + { + "competency_ref": "onet:23-1011.00", + "scheme": "onet", + "prefLabel": "Lawyers" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S4.6.3", + "scheme": "esco", + "prefLabel": "contract law and commercial law" + }, + { + "competency_ref": "onet:23-1011.00", + "scheme": "onet", + "prefLabel": "Lawyers" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.contract_review", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.contract_review.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.contract_review.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.contract_review", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/contract_review", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:221e7aa3a54a2d8953921c03076f2564", + "attestation_hash": "sha256:749185ac2b1c0353e15891b0d1aa6de022fa97b01a5e8332e390e5a57e02d4ae" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/contract_review/v0-draft", + "embedding_model_ref": "klickd-embed-contract_review-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "none", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "contract", + "liability_clause", + "indemnity", + "redline", + "term_extraction" + ], + "entity_classes": [ + "esco", + "eu_law_ref" + ], + "priority": "legal_review", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "clause_flag_send_to_counterparty", + "redline_liability_indemnity_termination", + "confidential_contract_text_inline" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "redline_liability_indemnity_termination", + "confidential_contract_text_inline" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "clause-flag-send", + "action_class": "clause_flag_send_to_counterparty", + "level": "confirm", + "reason": "Clause flags sent to counterparty require explicit confirmation." + }, + { + "id": "liability-redline", + "action_class": "redline_liability_indemnity_termination", + "level": "block", + "reason": "Redlines on liability/indemnity/termination require licensed lawyer escalation; floor not lowerable." + }, + { + "id": "confidential-text-inline", + "action_class": "confidential_contract_text_inline", + "level": "block", + "reason": "Inline confidential contract text blocked unless carrier asserts rights." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/contract_review are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/customer-support-operator.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/customer-support-operator.klickd new file mode 100644 index 0000000..3cf606c --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/customer-support-operator.klickd @@ -0,0 +1,391 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "customer_support", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B27). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/customer_support_operator", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b27", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/customer_support_operator", + "frameworks": [ + "esco", + "onet", + "lifecomp", + "wef" + ], + "competency_ids": [ + "esco:S3", + "esco:S1.2", + "esco:S4.0.1", + "onet:43-4051.00", + "lifecomp:S1", + "lifecomp:S2", + "wef:active-learning" + ], + "gate_summaries": [ + { + "id": "pii-share-cross-ticket", + "level": "block" + }, + { + "id": "refund-floor-override", + "level": "confirm" + }, + { + "id": "auto-close-without-confirm", + "level": "confirm" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1100, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/work" + ], + "target_user": "Customer-support / success operator running tier-1/2 triage, response, escalation. Empathy, claim grounding, GDPR-aware data handling. NOT social media community management at scale.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "lifecomp", + "version": "2020", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/lifecomp/2020/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/lifecomp_en" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S3", + "scheme": "esco", + "prefLabel": "communicating, collaborating, advising, mediating" + }, + { + "competency_ref": "esco:S1.2", + "scheme": "esco", + "prefLabel": "supporting interpersonal communication" + }, + { + "competency_ref": "esco:S4.0.1", + "scheme": "esco", + "prefLabel": "managing activities, resources, requirements" + }, + { + "competency_ref": "onet:43-4051.00", + "scheme": "onet", + "prefLabel": "Customer Service Representatives" + }, + { + "competency_ref": "lifecomp:S1", + "scheme": "lifecomp", + "prefLabel": "Empathy" + }, + { + "competency_ref": "lifecomp:S2", + "scheme": "lifecomp", + "prefLabel": "Collaboration" + }, + { + "competency_ref": "wef:active-learning", + "scheme": "wef", + "prefLabel": "Active learning and learning strategies" + } + ], + "competencies": [ + { + "competency_ref": "esco:S3", + "scheme": "esco", + "prefLabel": "communicating, collaborating, advising, mediating" + }, + { + "competency_ref": "esco:S1.2", + "scheme": "esco", + "prefLabel": "supporting interpersonal communication" + }, + { + "competency_ref": "esco:S4.0.1", + "scheme": "esco", + "prefLabel": "managing activities, resources, requirements" + }, + { + "competency_ref": "onet:43-4051.00", + "scheme": "onet", + "prefLabel": "Customer Service Representatives" + }, + { + "competency_ref": "lifecomp:S1", + "scheme": "lifecomp", + "prefLabel": "Empathy" + }, + { + "competency_ref": "lifecomp:S2", + "scheme": "lifecomp", + "prefLabel": "Collaboration" + }, + { + "competency_ref": "wef:active-learning", + "scheme": "wef", + "prefLabel": "Active learning and learning strategies" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/4", + "level_label": "EQF level 4", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.customer_support_operator", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.customer_support_operator.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.customer_support_operator.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.customer_support_operator", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/customer_support_operator", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:5e1eb28df87681b224070c7cc9692a0b", + "attestation_hash": "sha256:6e1a6ccbdc767e03fcc41074a57da3c0dcb0162041d1a6cddd4b74da7791de1e" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/customer_support_operator/v0-draft", + "embedding_model_ref": "klickd-embed-customer_support_operator-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "support", + "ticket", + "macro", + "csat", + "escalation" + ], + "entity_classes": [ + "esco", + "sfia" + ], + "priority": "support_operation", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "share_pii_across_ticket", + "refund_floor_override", + "auto_close_without_customer_confirm" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "share_pii_across_ticket" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "pii-share-cross-ticket", + "action_class": "share_pii_across_ticket", + "level": "block", + "reason": "Sharing one customer's PII into another ticket is blocked." + }, + { + "id": "refund-floor-override", + "action_class": "refund_floor_override", + "level": "confirm", + "reason": "Refund-floor overrides require explicit confirmation." + }, + { + "id": "auto-close-without-confirm", + "action_class": "auto_close_without_customer_confirm", + "level": "confirm", + "reason": "Auto-closing a ticket without customer confirmation requires confirmation." + } + ] + }, + "router_cost": { + "tokens_estimate": 1100, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/customer_support_operator are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/data-analyst.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/data-analyst.klickd new file mode 100644 index 0000000..56ba9b3 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/data-analyst.klickd @@ -0,0 +1,393 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "data_analysis", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B22). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/data_analyst", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b22", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/data_analyst", + "frameworks": [ + "esco", + "sfia", + "onet", + "wef" + ], + "competency_ids": [ + "esco:S5.5", + "esco:S2.0", + "sfia:DTAN", + "sfia:INAN", + "onet:15-2051.00", + "wef:analytical-thinking", + "wef:ai-and-big-data" + ], + "gate_summaries": [ + { + "id": "production-query", + "level": "confirm" + }, + { + "id": "deanonymisation-skip", + "level": "block" + }, + { + "id": "metric-definition-override", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/research" + ], + "target_user": "Data analyst building dashboards, reports, and ad-hoc analyses. Statistical literacy, query discipline, reproducibility. NOT a data scientist building ML models (that's a separate scope).", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S5.5", + "scheme": "esco", + "prefLabel": "developing, programming and using software for data analysis" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "sfia:DTAN", + "scheme": "sfia", + "prefLabel": "Data analytics" + }, + { + "competency_ref": "sfia:INAN", + "scheme": "sfia", + "prefLabel": "Information analysis" + }, + { + "competency_ref": "onet:15-2051.00", + "scheme": "onet", + "prefLabel": "Data Scientists" + }, + { + "competency_ref": "wef:analytical-thinking", + "scheme": "wef", + "prefLabel": "Analytical thinking" + }, + { + "competency_ref": "wef:ai-and-big-data", + "scheme": "wef", + "prefLabel": "AI and big data" + } + ], + "competencies": [ + { + "competency_ref": "esco:S5.5", + "scheme": "esco", + "prefLabel": "developing, programming and using software for data analysis" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "sfia:DTAN", + "scheme": "sfia", + "prefLabel": "Data analytics" + }, + { + "competency_ref": "sfia:INAN", + "scheme": "sfia", + "prefLabel": "Information analysis" + }, + { + "competency_ref": "onet:15-2051.00", + "scheme": "onet", + "prefLabel": "Data Scientists" + }, + { + "competency_ref": "wef:analytical-thinking", + "scheme": "wef", + "prefLabel": "Analytical thinking" + }, + { + "competency_ref": "wef:ai-and-big-data", + "scheme": "wef", + "prefLabel": "AI and big data" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.data_analyst", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.data_analyst.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.data_analyst.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.data_analyst", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/data_analyst", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:3220dcaaa9a78c592b918b05184a0069", + "attestation_hash": "sha256:babe0507f2426600ff82c2e16245d26cd4052acbd57776695e06813b2001b58d" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/data_analyst/v0-draft", + "embedding_model_ref": "klickd-embed-data_analyst-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 7, + "max_facts_per_turn": 9, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "sql", + "metric_definition", + "deanonymisation_guard", + "dashboard" + ], + "entity_classes": [ + "esco", + "sfia", + "onet", + "wef" + ], + "priority": "analytic_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "production_dataset_write", + "skip_deanonymisation_guard", + "metric_definition_silent_change" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "skip_deanonymisation_guard", + "metric_definition_silent_change" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "production-query", + "action_class": "production_dataset_write", + "level": "confirm", + "reason": "Writes against a production dataset require explicit confirmation." + }, + { + "id": "deanonymisation-skip", + "action_class": "skip_deanonymisation_guard", + "level": "block", + "reason": "Skipping de-anonymisation guards is blocked; joins that re-identify subjects must escalate." + }, + { + "id": "metric-definition-override", + "action_class": "metric_definition_silent_change", + "level": "block", + "reason": "Silent metric-definition changes are blocked; metrics must be versioned." + } + ] + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/data_analyst are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/devops-operator.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/devops-operator.klickd new file mode 100644 index 0000000..ad43678 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/devops-operator.klickd @@ -0,0 +1,394 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "operations", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B24). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/devops_operator", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b24", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/devops_operator", + "frameworks": [ + "esco", + "sfia", + "onet", + "nice" + ], + "competency_ids": [ + "esco:S5.6", + "esco:S5.0", + "sfia:ITOP", + "sfia:SCAD", + "sfia:AVMT", + "onet:15-1244.00", + "nice:OM-NET" + ], + "gate_summaries": [ + { + "id": "production-deploy", + "level": "confirm" + }, + { + "id": "alert-mute-prolonged", + "level": "block" + }, + { + "id": "iac-drift-ignore", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/coding", + "x.klickd/security" + ], + "target_user": "DevOps / SRE operator running CI/CD, observability, incident-readiness. Distinct from release_engineer (which focuses on supply-chain artefacts); this pack focuses on operating systems day-to-day.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "nice", + "version": "NIST SP 800-181r1", + "iri_prefix": "https://csrc.nist.gov/projects/cybersecurity-workforce-framework/", + "canonical_url": "https://niccs.cisa.gov/workforce-development/nice-framework" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT — software deployment" + }, + { + "competency_ref": "esco:S5.0", + "scheme": "esco", + "prefLabel": "ICT — generic" + }, + { + "competency_ref": "sfia:ITOP", + "scheme": "sfia", + "prefLabel": "IT infrastructure" + }, + { + "competency_ref": "sfia:SCAD", + "scheme": "sfia", + "prefLabel": "Systems and software life cycle engineering" + }, + { + "competency_ref": "sfia:AVMT", + "scheme": "sfia", + "prefLabel": "Availability management" + }, + { + "competency_ref": "onet:15-1244.00", + "scheme": "onet", + "prefLabel": "Network and Computer Systems Administrators" + }, + { + "competency_ref": "nice:OM-NET", + "scheme": "nice", + "prefLabel": "Operate and Maintain — Network Operations" + } + ], + "competencies": [ + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT — software deployment" + }, + { + "competency_ref": "esco:S5.0", + "scheme": "esco", + "prefLabel": "ICT — generic" + }, + { + "competency_ref": "sfia:ITOP", + "scheme": "sfia", + "prefLabel": "IT infrastructure" + }, + { + "competency_ref": "sfia:SCAD", + "scheme": "sfia", + "prefLabel": "Systems and software life cycle engineering" + }, + { + "competency_ref": "sfia:AVMT", + "scheme": "sfia", + "prefLabel": "Availability management" + }, + { + "competency_ref": "onet:15-1244.00", + "scheme": "onet", + "prefLabel": "Network and Computer Systems Administrators" + }, + { + "competency_ref": "nice:OM-NET", + "scheme": "nice", + "prefLabel": "Operate and Maintain — Network Operations" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.devops_operator", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.devops_operator.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.devops_operator.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.devops_operator", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/devops_operator", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:db77f7f03be3a1b03d70ff11df439e86", + "attestation_hash": "sha256:d9f6a194d4025c1d583b455d78b4febbc51ee3f969b69f4e80ba6a9ac445db68" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/devops_operator/v0-draft", + "embedding_model_ref": "klickd-embed-devops_operator-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 7, + "max_facts_per_turn": 9, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "devops", + "incident", + "deploy", + "rollback", + "observability" + ], + "entity_classes": [ + "esco", + "sfia", + "onet" + ], + "priority": "ops_operation", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "production_deploy_write", + "prolonged_alert_mute", + "infrastructure_drift_silent_apply" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "prolonged_alert_mute", + "infrastructure_drift_silent_apply" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "production-deploy", + "action_class": "production_deploy_write", + "level": "confirm", + "reason": "Production deploy writes require explicit confirmation." + }, + { + "id": "alert-mute-prolonged", + "action_class": "prolonged_alert_mute", + "level": "block", + "reason": "Prolonged alert mutes (beyond declared maintenance window) are blocked." + }, + { + "id": "iac-drift-ignore", + "action_class": "infrastructure_drift_silent_apply", + "level": "block", + "reason": "Silently applying drift to infrastructure-as-code state is blocked." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/devops_operator are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/drone-operator.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/drone-operator.klickd new file mode 100644 index 0000000..68fde43 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/drone-operator.klickd @@ -0,0 +1,336 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "operations", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B15). Pro tier; compact_index loading strategy declared.", + "renamed_from": "drone.klickd" + }, + "x_klickd_pack": { + "pack": "x.klickd/drone_operator", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b15", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/drone_operator", + "frameworks": [ + "esco" + ], + "competency_ids": [ + "esco:S6", + "esco:S6.4", + "esco:S4.6" + ], + "gate_summaries": [ + { + "id": "no-fly-zone-override", + "level": "block" + }, + { + "id": "first-flight-in-area", + "level": "confirm" + }, + { + "id": "minor-flight-write", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/security", + "x.klickd/legal" + ], + "target_user": "Civil drone (UAV) operator. Pre-flight discipline, airspace literacy, no-fly zones, incident reporting. Not military; not commercial heavy-lift.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + } + ], + "citation_only_references": [ + { + "id": "eu-2019-947", + "ref": "EU Regulation 2019/947 (UAS rules)", + "url": "https://eur-lex.europa.eu/eli/reg_impl/2019/947/oj" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S6", + "scheme": "esco", + "prefLabel": "transport, transportation" + }, + { + "competency_ref": "esco:S6.4", + "scheme": "esco", + "prefLabel": "operating aerial vehicles" + }, + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + } + ], + "competencies": [ + { + "competency_ref": "esco:S6", + "scheme": "esco", + "prefLabel": "transport, transportation" + }, + { + "competency_ref": "esco:S6.4", + "scheme": "esco", + "prefLabel": "operating aerial vehicles" + }, + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.drone_operator", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.drone_operator.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.drone_operator.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.drone_operator", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/drone_operator", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:e53a157f506d5b4999213d325322d711", + "attestation_hash": "sha256:b5fcb42af348bce61c800965ed1a4fd888d7f6671153d894105666971224a68f" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/drone_operator/v0-draft", + "embedding_model_ref": "klickd-embed-drone_operator-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 5, + "max_facts_per_turn": 7, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "drone", + "easa", + "flight_plan", + "no_fly_zone", + "preflight" + ], + "entity_classes": [ + "esco", + "easa_ref" + ], + "priority": "field_operation", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "no_fly_zone_override", + "first_flight_in_area", + "flight_write_by_minor_without_guardian" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "no_fly_zone_override", + "flight_write_by_minor_without_guardian" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "no-fly-zone-override", + "action_class": "no_fly_zone_override", + "level": "block", + "reason": "No-fly-zone overrides blocked; floor not lowerable." + }, + { + "id": "first-flight-in-area", + "action_class": "first_flight_in_area", + "level": "confirm", + "reason": "First flight in a new area requires explicit confirmation." + }, + { + "id": "minor-flight-write", + "action_class": "flight_write_by_minor_without_guardian", + "level": "block", + "reason": "Flight writes by minors without guardian blocked; floor not lowerable." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/drone_operator are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/edge-ai-operator.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/edge-ai-operator.klickd new file mode 100644 index 0000000..5faf222 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/edge-ai-operator.klickd @@ -0,0 +1,404 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "edge_ai", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B34). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/edge_ai_operator", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b34", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/edge_ai_operator", + "frameworks": [ + "esco", + "sfia", + "onet", + "wef" + ], + "competency_ids": [ + "esco:S5.6.1", + "esco:S5.5", + "sfia:PROG", + "sfia:HSIN", + "sfia:HCEV", + "onet:17-2199.10", + "wef:ai-and-big-data", + "wef:technology-design-programming" + ], + "gate_summaries": [ + { + "id": "field-ota-without-rollback", + "level": "block" + }, + { + "id": "model-quant-silent-accuracy-drop", + "level": "block" + }, + { + "id": "safety-critical-deploy", + "level": "confirm" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/coding", + "x.klickd/security" + ], + "target_user": "Engineer deploying and operating AI models on edge devices (mobile, embedded, robotics). Latency, power, model-quantisation hygiene, on-device evaluation. Distinct from llm_agent_engineering (cloud LLM agents).", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S5.6.1", + "scheme": "esco", + "prefLabel": "developing AI and machine learning systems" + }, + { + "competency_ref": "esco:S5.5", + "scheme": "esco", + "prefLabel": "developing, programming and using software" + }, + { + "competency_ref": "sfia:PROG", + "scheme": "sfia", + "prefLabel": "Programming/software development" + }, + { + "competency_ref": "sfia:HSIN", + "scheme": "sfia", + "prefLabel": "Systems integration and build" + }, + { + "competency_ref": "sfia:HCEV", + "scheme": "sfia", + "prefLabel": "User experience evaluation" + }, + { + "competency_ref": "onet:17-2199.10", + "scheme": "onet", + "prefLabel": "Robotics Engineers" + }, + { + "competency_ref": "wef:ai-and-big-data", + "scheme": "wef", + "prefLabel": "AI and big data" + }, + { + "competency_ref": "wef:technology-design-programming", + "scheme": "wef", + "prefLabel": "Technology design and programming" + } + ], + "competencies": [ + { + "competency_ref": "esco:S5.6.1", + "scheme": "esco", + "prefLabel": "developing AI and machine learning systems" + }, + { + "competency_ref": "esco:S5.5", + "scheme": "esco", + "prefLabel": "developing, programming and using software" + }, + { + "competency_ref": "sfia:PROG", + "scheme": "sfia", + "prefLabel": "Programming/software development" + }, + { + "competency_ref": "sfia:HSIN", + "scheme": "sfia", + "prefLabel": "Systems integration and build" + }, + { + "competency_ref": "sfia:HCEV", + "scheme": "sfia", + "prefLabel": "User experience evaluation" + }, + { + "competency_ref": "onet:17-2199.10", + "scheme": "onet", + "prefLabel": "Robotics Engineers" + }, + { + "competency_ref": "wef:ai-and-big-data", + "scheme": "wef", + "prefLabel": "AI and big data" + }, + { + "competency_ref": "wef:technology-design-programming", + "scheme": "wef", + "prefLabel": "Technology design and programming" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.edge_ai_operator", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.edge_ai_operator.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.edge_ai_operator.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.edge_ai_operator", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/edge_ai_operator", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:17676a2ed3d1917072e808aa72efe0ad", + "attestation_hash": "sha256:44aa19eb9953994ab873ca36570a62ba252634e4796a6a2734f612e669838f90" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/edge_ai_operator/v0-draft", + "embedding_model_ref": "klickd-embed-edge_ai_operator-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "edge_inference", + "model_pinning", + "latency_budget", + "device_fleet" + ], + "entity_classes": [ + "esco", + "sfia", + "onet" + ], + "priority": "ops_operation", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "ota_deploy_without_rollback", + "quantisation_silent_accuracy_drop", + "safety_critical_edge_deploy" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "ota_deploy_without_rollback", + "quantisation_silent_accuracy_drop" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "field-ota-without-rollback", + "action_class": "ota_deploy_without_rollback", + "level": "block", + "reason": "OTA deploys without a rollback path are blocked." + }, + { + "id": "model-quant-silent-accuracy-drop", + "action_class": "quantisation_silent_accuracy_drop", + "level": "block", + "reason": "Quantisation that drops accuracy below declared floor without escalation is blocked." + }, + { + "id": "safety-critical-deploy", + "action_class": "safety_critical_edge_deploy", + "level": "confirm", + "reason": "Safety-critical edge deploys (medical / vehicular / industrial) require explicit confirmation." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/edge_ai_operator are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/eu-ai-act.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/eu-ai-act.klickd new file mode 100644 index 0000000..10075bf --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/eu-ai-act.klickd @@ -0,0 +1,338 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "legal", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B6). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/eu_ai_act", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b6", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/eu_ai_act", + "frameworks": [ + "esco" + ], + "competency_ids": [ + "esco:S4.6", + "esco:S4.6.1", + "esco:S2.0" + ], + "gate_summaries": [ + { + "id": "compliance-attestation", + "level": "confirm" + }, + { + "id": "risk-class-downgrade", + "level": "block" + }, + { + "id": "counsel-escalation-skip", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/legal" + ], + "target_user": "Compliance officer / DPO / engineer mapping a system to the EU AI Act. Risk class, obligations, transparency, post-market monitoring.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + } + ], + "citation_only_references": [ + { + "id": "eu-ai-act", + "ref": "Regulation (EU) 2024/1689", + "url": "https://eur-lex.europa.eu/eli/reg/2024/1689/oj" + }, + { + "id": "enisa-ai-threat", + "ref": "ENISA AI Threat Landscape", + "url": "https://www.enisa.europa.eu/topics/cybersecurity-threats/threats-and-trends" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S4.6.1", + "scheme": "esco", + "prefLabel": "regulatory compliance" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S4.6.1", + "scheme": "esco", + "prefLabel": "regulatory compliance" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.eu_ai_act", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.eu_ai_act.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.eu_ai_act.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.eu_ai_act", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/eu_ai_act", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:75e8377715968519d9d5e50288fa9f4b", + "attestation_hash": "sha256:ca20bedbe2452370fe2b0876ba86639b62732be6bc47f9a3bcecfac406a4241d" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/eu_ai_act/v0-draft", + "embedding_model_ref": "klickd-embed-eu_ai_act-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "none", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "eu_ai_act", + "risk_class", + "transparency_obligation", + "logging" + ], + "entity_classes": [ + "esco", + "eu_law_ref" + ], + "priority": "compliance_lookup", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "compliance_attestation", + "risk_class_below_evidence", + "skip_counsel_for_definitive_decision" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "risk_class_below_evidence", + "skip_counsel_for_definitive_decision" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "compliance-attestation", + "action_class": "compliance_attestation", + "level": "confirm", + "reason": "Compliance attestations require explicit confirmation." + }, + { + "id": "risk-class-downgrade", + "action_class": "risk_class_below_evidence", + "level": "block", + "reason": "Risk-class downgrade below evidence blocked; floor not lowerable." + }, + { + "id": "counsel-escalation-skip", + "action_class": "skip_counsel_for_definitive_decision", + "level": "block", + "reason": "Definitive risk-class decisions require qualified counsel; skip blocked." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/eu_ai_act are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/evidence-desk.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/evidence-desk.klickd new file mode 100644 index 0000000..ad9e3f6 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/evidence-desk.klickd @@ -0,0 +1,376 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "trust_and_safety", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B10). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/evidence_desk", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b10", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/evidence_desk", + "frameworks": [ + "esco", + "digcomp" + ], + "competency_ids": [ + "esco:S2.5", + "esco:S1.5", + "esco:S1.5.1", + "digcomp:1.2", + "digcomp:1.3", + "digcomp:4.2" + ], + "gate_summaries": [ + { + "id": "source-identity-reveal", + "level": "block" + }, + { + "id": "public-attribution", + "level": "confirm" + }, + { + "id": "editor-counsel-skip", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/research", + "x.klickd/trust_evidence" + ], + "target_user": "Operator running an evidence-intake / triage desk (journalism investigations, OSINT, civic accountability). Submission triage, source protection, claim grounding, chain-of-custody.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "digcomp", + "version": "2.2" + } + ], + "transversal_refs": [ + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S2.5", + "scheme": "esco", + "prefLabel": "investigating and reporting" + }, + { + "competency_ref": "esco:S1.5", + "scheme": "esco", + "prefLabel": "performing artistic work" + }, + { + "competency_ref": "esco:S1.5.1", + "scheme": "esco", + "prefLabel": "investigative journalism" + }, + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "digcomp:1.3", + "scheme": "digcomp", + "prefLabel": "Managing data, information and digital content" + }, + { + "competency_ref": "digcomp:4.2", + "scheme": "digcomp", + "prefLabel": "Protecting personal data and privacy" + } + ], + "competencies": [ + { + "competency_ref": "esco:S2.5", + "scheme": "esco", + "prefLabel": "investigating and reporting" + }, + { + "competency_ref": "esco:S1.5", + "scheme": "esco", + "prefLabel": "performing artistic work" + }, + { + "competency_ref": "esco:S1.5.1", + "scheme": "esco", + "prefLabel": "investigative journalism" + }, + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "digcomp:1.3", + "scheme": "digcomp", + "prefLabel": "Managing data, information and digital content" + }, + { + "competency_ref": "digcomp:4.2", + "scheme": "digcomp", + "prefLabel": "Protecting personal data and privacy" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.evidence_desk", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.evidence_desk.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.evidence_desk.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.evidence_desk", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/evidence_desk", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:baa7bc1f2a89289e53952878605fbe68", + "attestation_hash": "sha256:9162170c2bd6e956d76df35fac05639e9a42d639ba4ea2b28e586007d12f1981" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/evidence_desk/v0-draft", + "embedding_model_ref": "klickd-embed-evidence_desk-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "evidence", + "chain_of_custody", + "attestation", + "verification_artifact" + ], + "entity_classes": [ + "esco", + "sfia" + ], + "priority": "evidence_handling", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "source_identity_reveal", + "public_attribution_write", + "skip_editor_counsel_before_public_release" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "source_identity_reveal", + "skip_editor_counsel_before_public_release" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "source-identity-reveal", + "action_class": "source_identity_reveal", + "level": "block", + "reason": "Source identity reveal blocked; floor not lowerable." + }, + { + "id": "public-attribution", + "action_class": "public_attribution_write", + "level": "confirm", + "reason": "Public attribution writes require explicit confirmation." + }, + { + "id": "editor-counsel-skip", + "action_class": "skip_editor_counsel_before_public_release", + "level": "block", + "reason": "Editor / counsel escalation skip blocked before public release." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/evidence_desk are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/finance-analyst.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/finance-analyst.klickd new file mode 100644 index 0000000..c119742 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/finance-analyst.klickd @@ -0,0 +1,382 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "finance", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B28). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/finance_analyst", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b28", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/finance_analyst", + "frameworks": [ + "esco", + "sfia", + "onet", + "wef" + ], + "competency_ids": [ + "esco:S4.0", + "esco:S4.0.2", + "sfia:FMIT", + "sfia:METL", + "onet:13-2051.00", + "wef:analytical-thinking" + ], + "gate_summaries": [ + { + "id": "forecast-publish-external", + "level": "confirm" + }, + { + "id": "model-assumption-silent-change", + "level": "block" + }, + { + "id": "regulated-investment-advice", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/work" + ], + "target_user": "Corporate / FP&A finance analyst building forecasts, budgets, variance analyses for a company. NOT personal financial advice; NOT regulated investment advice.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.0", + "scheme": "esco", + "prefLabel": "management" + }, + { + "competency_ref": "esco:S4.0.2", + "scheme": "esco", + "prefLabel": "controlling, monitoring activities, resources" + }, + { + "competency_ref": "sfia:FMIT", + "scheme": "sfia", + "prefLabel": "Financial management" + }, + { + "competency_ref": "sfia:METL", + "scheme": "sfia", + "prefLabel": "Methods and tools" + }, + { + "competency_ref": "onet:13-2051.00", + "scheme": "onet", + "prefLabel": "Financial and Investment Analysts" + }, + { + "competency_ref": "wef:analytical-thinking", + "scheme": "wef", + "prefLabel": "Analytical thinking" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4.0", + "scheme": "esco", + "prefLabel": "management" + }, + { + "competency_ref": "esco:S4.0.2", + "scheme": "esco", + "prefLabel": "controlling, monitoring activities, resources" + }, + { + "competency_ref": "sfia:FMIT", + "scheme": "sfia", + "prefLabel": "Financial management" + }, + { + "competency_ref": "sfia:METL", + "scheme": "sfia", + "prefLabel": "Methods and tools" + }, + { + "competency_ref": "onet:13-2051.00", + "scheme": "onet", + "prefLabel": "Financial and Investment Analysts" + }, + { + "competency_ref": "wef:analytical-thinking", + "scheme": "wef", + "prefLabel": "Analytical thinking" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.finance_analyst", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.finance_analyst.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.finance_analyst.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.finance_analyst", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/finance_analyst", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:8905b2ce9b4cb7c7a036a83c49facec3", + "attestation_hash": "sha256:fcef7d627c8b43c8b7b999044a0cb602805cf817ff2fc662dd18c4c63ed382bf" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/finance_analyst/v0-draft", + "embedding_model_ref": "klickd-embed-finance_analyst-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 7, + "max_facts_per_turn": 9, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "finance", + "valuation", + "scenario", + "kpi", + "forecast" + ], + "entity_classes": [ + "esco", + "sfia", + "onet" + ], + "priority": "analytic_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "external_forecast_publication", + "model_assumption_silent_change", + "regulated_investment_advice_output" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "model_assumption_silent_change", + "regulated_investment_advice_output" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "forecast-publish-external", + "action_class": "external_forecast_publication", + "level": "confirm", + "reason": "Publishing a forecast externally (investor / press) requires confirmation." + }, + { + "id": "model-assumption-silent-change", + "action_class": "model_assumption_silent_change", + "level": "block", + "reason": "Silent changes to forecast-model assumptions are blocked; assumptions must be versioned." + }, + { + "id": "regulated-investment-advice", + "action_class": "regulated_investment_advice_output", + "level": "block", + "reason": "Output resembling regulated investment advice is blocked; escalate to licensed advisor." + } + ] + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/finance_analyst are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/game-design.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/game-design.klickd new file mode 100644 index 0000000..1be322e --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/game-design.klickd @@ -0,0 +1,397 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "creative", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B17). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/game_design", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b17", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/game_design", + "frameworks": [ + "esco", + "sfia", + "onet", + "wef" + ], + "competency_ids": [ + "esco:S1.0", + "esco:S5.6.3", + "sfia:DESN", + "sfia:RFEN", + "onet:15-1255.00", + "wef:creativity-originality-initiative" + ], + "gate_summaries": [ + { + "id": "monetisation-affecting-minors", + "level": "confirm" + }, + { + "id": "accessibility-review-disable", + "level": "block" + }, + { + "id": "rating-self-class-disable", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/creator", + "x.klickd/coding" + ], + "target_user": "Game designer / systems designer. Mechanic / dynamic / aesthetic literacy, playtesting discipline, accessibility, rating literacy. Distinct from x.klickd/game_literacy by author-vs-reader axis.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + } + ], + "citation_only_references": [ + { + "id": "pegi", + "ref": "PEGI Pan-European Game Information", + "url": "https://pegi.info/" + }, + { + "id": "esrb", + "ref": "ESRB Entertainment Software Rating Board", + "url": "https://www.esrb.org/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "sfia", + "version": "8" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "creativity and innovation" + }, + { + "competency_ref": "esco:S5.6.3", + "scheme": "esco", + "prefLabel": "ICT game development" + }, + { + "competency_ref": "sfia:DESN", + "scheme": "sfia", + "prefLabel": "Systems design" + }, + { + "competency_ref": "sfia:RFEN", + "scheme": "sfia", + "prefLabel": "Requirements engineering" + }, + { + "competency_ref": "onet:15-1255.00", + "scheme": "onet", + "prefLabel": "Web and Digital Interface Designers" + }, + { + "competency_ref": "wef:creativity-originality-initiative", + "scheme": "wef", + "prefLabel": "Creativity, originality and initiative" + } + ], + "competencies": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "creativity and innovation" + }, + { + "competency_ref": "esco:S5.6.3", + "scheme": "esco", + "prefLabel": "ICT game development" + }, + { + "competency_ref": "sfia:DESN", + "scheme": "sfia", + "prefLabel": "Systems design" + }, + { + "competency_ref": "sfia:RFEN", + "scheme": "sfia", + "prefLabel": "Requirements engineering" + }, + { + "competency_ref": "onet:15-1255.00", + "scheme": "onet", + "prefLabel": "Web and Digital Interface Designers" + }, + { + "competency_ref": "wef:creativity-originality-initiative", + "scheme": "wef", + "prefLabel": "Creativity, originality and initiative" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.game_design", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.game_design.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.game_design.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.game_design", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/game_design", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:f274dd8b814db6b641a282aeb56188d9", + "attestation_hash": "sha256:ff608554fdb92f37cad714bd83405c6fb23fd47bb36e5d1917770664ff9f4889" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/game_design/v0-draft", + "embedding_model_ref": "klickd-embed-game_design-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 5, + "max_facts_per_turn": 7, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "game_design", + "loop_design", + "monetisation_pattern", + "balance" + ], + "entity_classes": [ + "esco", + "onet" + ], + "priority": "creative_practice", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "monetisation_design_affecting_minors", + "disable_accessibility_review", + "disable_rating_self_classification" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "disable_accessibility_review", + "disable_rating_self_classification" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "monetisation-affecting-minors", + "action_class": "monetisation_design_affecting_minors", + "level": "confirm", + "reason": "Monetisation design affecting minors requires explicit confirmation." + }, + { + "id": "accessibility-review-disable", + "action_class": "disable_accessibility_review", + "level": "block", + "reason": "Accessibility review disables blocked; floor not lowerable." + }, + { + "id": "rating-self-class-disable", + "action_class": "disable_rating_self_classification", + "level": "block", + "reason": "Rating self-classification disables blocked; floor not lowerable." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/game_design are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/game-literacy.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/game-literacy.klickd new file mode 100644 index 0000000..45ae0ab --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/game-literacy.klickd @@ -0,0 +1,297 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "media_literacy", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "lite", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact. Lot A game-literacy pack, distinct from x.klickd/gaming (P1) and x.klickd/game_design (B17)." + }, + "x_klickd_pack": { + "pack": "x.klickd/game_literacy", + "pack_version": "0.1.0-candidate-lite", + "spec_ref": "x.klickd/v4.1#a12", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "lite", + "parent_packs": [ + "x.klickd/user", + "x.klickd/gaming" + ], + "target_user": "General-public carrier learning to read games as media: genres, rules, mechanics, time-budget hygiene. Not competitive play; not game development.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "digcomp", + "version": "2.2" + } + ], + "transversal_refs": [ + { + "competency_ref": "wef:complex-problem-solving", + "scheme": "wef", + "prefLabel": "Complex problem solving" + }, + { + "competency_ref": "digcomp:4.3", + "scheme": "digcomp", + "prefLabel": "Protecting health and well-being" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "creativity and innovation" + }, + { + "competency_ref": "wef:complex-problem-solving", + "scheme": "wef", + "prefLabel": "Complex problem solving" + }, + { + "competency_ref": "digcomp:4.3", + "scheme": "digcomp", + "prefLabel": "Protecting health and well-being" + }, + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + } + ], + "competencies": [ + { + "competency_ref": "wef:complex-problem-solving", + "scheme": "wef", + "prefLabel": "Complex problem solving" + }, + { + "competency_ref": "digcomp:4.3", + "scheme": "digcomp", + "prefLabel": "Protecting health and well-being" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/3", + "level_label": "EQF level 3", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.game_literacy", + "memory_segments": [ + { + "id": "play-log", + "scope": "memory.x_klickd.game_literacy.play_log", + "policy": "pointer_only_summary" + }, + { + "id": "time-budget", + "scope": "memory.x_klickd.game_literacy.time_budget", + "policy": "self_declared" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.game_literacy", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/game_literacy", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:52fee9581a77631f14f6af64e3d1f3cc", + "attestation_hash": "sha256:e6556f50c2073708281df17798a265b1c3b4a7415b295915f3c59da99a4dad3b" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/game_literacy/v0-draft", + "embedding_model_ref": "klickd-embed-game_literacy-2026-v0-placeholder", + "dim": 384, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 4, + "max_facts_per_turn": 5, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "gaming", + "spend_control", + "design_pattern", + "minor_safety" + ], + "entity_classes": [ + "esco", + "digcomp" + ], + "priority": "literacy_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier_with_guardian_if_minor", + "scope": [ + "in_game_purchase", + "time_budget_override" + ] + } + }, + "human_veto": { + "owner": "human_carrier_with_guardian_if_minor", + "raise_only": true, + "non_lowerable_floor": [ + "in_game_purchase_minor" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier_with_guardian_if_minor", + "agent_role": "advisory", + "escalation": "guardian_if_minor" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "in-game-purchase", + "action_class": "in_game_purchase", + "level": "confirm", + "reason": "In-game purchases require explicit confirmation." + }, + { + "id": "time-budget", + "action_class": "time_budget_override", + "level": "confirm", + "reason": "Time-budget overrides require confirmation; carrier MAY set the limit, pack does not lower it." + } + ] + }, + "router_cost": { + "tokens_estimate": 720, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into ESCO, WEF, or DigComp.", + "Minor carriers default to human_carrier_with_guardian.", + "Time-budget posture declared; pack does not lower carrier-set limit.", + "Pointer-only evidence; no inline screenshots.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == lite and tokens_estimate <= 900" + ], + "review": [ + "Reviewer verifies in-game-purchase gate stays confirm or stricter for minors.", + "Reviewer verifies time_budget is self-declared, not pack-imposed." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/gdpr-readiness.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/gdpr-readiness.klickd new file mode 100644 index 0000000..322ee25 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/gdpr-readiness.klickd @@ -0,0 +1,344 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "legal", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B7). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/gdpr_readiness", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b7", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/gdpr_readiness", + "frameworks": [ + "esco" + ], + "competency_ids": [ + "esco:S4.6", + "esco:S4.6.2", + "esco:S2.0" + ], + "gate_summaries": [ + { + "id": "dpia-write", + "level": "confirm" + }, + { + "id": "transfer-mechanism-skip", + "level": "block" + }, + { + "id": "dpo-escalation-skip", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/legal" + ], + "target_user": "DPO / privacy engineer running a GDPR-readiness assessment. Art. 30 records, DPIA, data-subject rights, transfer mechanisms.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + } + ], + "citation_only_references": [ + { + "id": "gdpr", + "ref": "Regulation (EU) 2016/679 (GDPR)", + "url": "https://eur-lex.europa.eu/eli/reg/2016/679/oj" + }, + { + "id": "edpb-guidelines", + "ref": "European Data Protection Board guidelines", + "url": "https://www.edpb.europa.eu/our-work-tools/general-guidance_en" + }, + { + "id": "enisa-handbook", + "ref": "ENISA Handbook on Security of Personal Data Processing", + "url": "https://www.enisa.europa.eu/publications/handbook-on-security-of-personal-data-processing" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S4.6.2", + "scheme": "esco", + "prefLabel": "data protection" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S4.6.2", + "scheme": "esco", + "prefLabel": "data protection" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.gdpr_readiness", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.gdpr_readiness.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.gdpr_readiness.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.gdpr_readiness", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/gdpr_readiness", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:f60ded9822763832d01d12696990c1d6", + "attestation_hash": "sha256:0579e05d267e431ffc9943b680a1518e251c6606168984c9ae4816f2a15982c1" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/gdpr_readiness/v0-draft", + "embedding_model_ref": "klickd-embed-gdpr_readiness-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "none", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "gdpr", + "art17_erasure", + "dsar", + "lawful_basis", + "ropa" + ], + "entity_classes": [ + "esco", + "eu_law_ref" + ], + "priority": "compliance_lookup", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "dpia_write", + "skip_transfer_mechanism_check", + "skip_dpo_escalation" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "skip_transfer_mechanism_check", + "skip_dpo_escalation" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "dpia-write", + "action_class": "dpia_write", + "level": "confirm", + "reason": "DPIA / Art. 30 writes require explicit confirmation." + }, + { + "id": "transfer-mechanism-skip", + "action_class": "skip_transfer_mechanism_check", + "level": "block", + "reason": "Transfer-mechanism check skip blocked for non-EU processors." + }, + { + "id": "dpo-escalation-skip", + "action_class": "skip_dpo_escalation", + "level": "block", + "reason": "DPO escalation skip blocked for ambiguous lawful basis or retention." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/gdpr_readiness are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/healthcare-ai-safety-reviewer.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/healthcare-ai-safety-reviewer.klickd new file mode 100644 index 0000000..b0f96b7 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/healthcare-ai-safety-reviewer.klickd @@ -0,0 +1,382 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "healthcare_ai", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B33). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/healthcare_ai_safety_reviewer", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b33", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/healthcare_ai_safety_reviewer", + "frameworks": [ + "esco", + "enisa", + "nice" + ], + "competency_ids": [ + "esco:S4.6", + "esco:S5.6", + "esco:S2.0", + "enisa:CRM", + "nice:OV-SPP" + ], + "gate_summaries": [ + { + "id": "clinical-claim-without-trial", + "level": "block" + }, + { + "id": "mdr-classification-downgrade", + "level": "block" + }, + { + "id": "patient-pii-export", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1300, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/research", + "x.klickd/legal", + "x.klickd/security" + ], + "target_user": "Reviewer auditing an AI system intended for a healthcare setting (clinical decision support, triage assistant, scribe). Maps risk under EU AI Act + MDR. NOT a clinician; NOT a notified body.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "enisa", + "version": "ECSF 1.0", + "iri_prefix": "https://www.enisa.europa.eu/topics/skills-and-competences/ecsf/", + "canonical_url": "https://www.enisa.europa.eu/topics/skills-and-competences/ecsf" + }, + { + "scheme": "nice", + "version": "NIST SP 800-181r1", + "iri_prefix": "https://csrc.nist.gov/projects/cybersecurity-workforce-framework/", + "canonical_url": "https://niccs.cisa.gov/workforce-development/nice-framework" + } + ], + "citation_only_references": [ + { + "id": "eu-ai-act", + "ref": "EU AI Act (Regulation (EU) 2024/1689)", + "url": "https://eur-lex.europa.eu/eli/reg/2024/1689/oj" + }, + { + "id": "mdr", + "ref": "EU Medical Device Regulation (Regulation (EU) 2017/745)", + "url": "https://eur-lex.europa.eu/eli/reg/2017/745/oj" + }, + { + "id": "who-ethics-ai-health", + "ref": "WHO Ethics and Governance of AI for Health", + "url": "https://www.who.int/publications/i/item/9789240029200" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT — software analysis" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "enisa:CRM", + "scheme": "enisa", + "prefLabel": "Cybersecurity Risk Manager" + }, + { + "competency_ref": "nice:OV-SPP", + "scheme": "nice", + "prefLabel": "Oversee and Govern — Strategic Planning and Policy" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT — software analysis" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "enisa:CRM", + "scheme": "enisa", + "prefLabel": "Cybersecurity Risk Manager" + }, + { + "competency_ref": "nice:OV-SPP", + "scheme": "nice", + "prefLabel": "Oversee and Govern — Strategic Planning and Policy" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/7", + "level_label": "EQF level 7", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.healthcare_ai_safety_reviewer", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.healthcare_ai_safety_reviewer.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.healthcare_ai_safety_reviewer.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.healthcare_ai_safety_reviewer", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/healthcare_ai_safety_reviewer", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:7ce036b1e17d0aa0fe774596c955c053", + "attestation_hash": "sha256:259703bf7a62c029f1be4df2e007743d28c718fe69f733a8b662b2d07d4d2b6f" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/healthcare_ai_safety_reviewer/v0-draft", + "embedding_model_ref": "klickd-embed-healthcare_ai_safety_reviewer-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 5, + "max_facts_per_turn": 7, + "freshness_weighting": "none", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "healthcare_ai", + "clinical_risk", + "device_class", + "mdr_ivdr" + ], + "entity_classes": [ + "esco", + "eu_law_ref" + ], + "priority": "safety_review", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "clinical_efficacy_claim_without_evidence", + "mdr_risk_class_downgrade_without_evidence", + "patient_pii_export" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "clinical_efficacy_claim_without_evidence", + "mdr_risk_class_downgrade_without_evidence", + "patient_pii_export" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "clinical-claim-without-trial", + "action_class": "clinical_efficacy_claim_without_evidence", + "level": "block", + "reason": "Clinical efficacy claims without trial / regulatory evidence are blocked." + }, + { + "id": "mdr-classification-downgrade", + "action_class": "mdr_risk_class_downgrade_without_evidence", + "level": "block", + "reason": "Downgrading MDR / AI Act risk class without evidence is blocked." + }, + { + "id": "patient-pii-export", + "action_class": "patient_pii_export", + "level": "block", + "reason": "Exporting patient PII outside declared lawful basis is blocked." + } + ] + }, + "router_cost": { + "tokens_estimate": 1300, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/healthcare_ai_safety_reviewer are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/identity-access-management.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/identity-access-management.klickd new file mode 100644 index 0000000..4b171e8 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/identity-access-management.klickd @@ -0,0 +1,380 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "security", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B3). Pro tier; compact_index loading strategy declared. Scoped to identity & access (NICE Identity Management + ENISA + CIS controls 5/6). Endpoint-hardening (CIS control 9 etc.) is intentionally out of scope.", + "renamed_from": "iam-endpoint.klickd" + }, + "x_klickd_pack": { + "pack": "x.klickd/identity_access_management", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b3", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/identity_access_management", + "frameworks": [ + "nice", + "enisa", + "cis" + ], + "competency_ids": [ + "nice:identity-management", + "nice:defensive-cybersecurity", + "enisa:cyber-incident-responder", + "enisa:cybersecurity-implementer", + "cis:control-5", + "cis:control-6" + ], + "gate_summaries": [ + { + "id": "iam-write", + "level": "confirm" + }, + { + "id": "mfa-downgrade", + "level": "block" + }, + { + "id": "session-token-inline", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/security" + ], + "target_user": "Identity & access engineer covering account/access management, MFA, hardware-token discipline, and session hygiene. Endpoint-hardening competencies (EDR/MDM/email-and-web protections) are out of scope for this pack; they live in x.klickd/security and possibly a future endpoint-hardening pack.", + "frameworks": [ + { + "scheme": "nice", + "version": "r1", + "iri_prefix": "https://niccs.cisa.gov/workforce-development/nice-framework/", + "canonical_url": "https://niccs.cisa.gov/workforce-development/nice-framework" + }, + { + "scheme": "enisa", + "version": "1.0", + "iri_prefix": "https://www.enisa.europa.eu/topics/skills-and-competences/skills-development/european-cybersecurity-skills-framework/", + "canonical_url": "https://www.enisa.europa.eu/topics/skills-and-competences/skills-development/european-cybersecurity-skills-framework" + }, + { + "scheme": "cis", + "version": "v8", + "iri_prefix": "https://www.cisecurity.org/controls/v8/", + "canonical_url": "https://www.cisecurity.org/controls/cis-controls-list" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "nice", + "version": "r1" + }, + { + "scheme": "enisa", + "version": "1.0" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S1", + "scheme": "esco", + "prefLabel": "communication, collaboration and creativity" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "nice:identity-management", + "scheme": "nice", + "prefLabel": "Identity Management" + }, + { + "competency_ref": "nice:defensive-cybersecurity", + "scheme": "nice", + "prefLabel": "Defensive Cybersecurity" + }, + { + "competency_ref": "enisa:cyber-incident-responder", + "scheme": "enisa", + "prefLabel": "Cyber Incident Responder" + }, + { + "competency_ref": "enisa:cybersecurity-implementer", + "scheme": "enisa", + "prefLabel": "Cybersecurity Implementer" + }, + { + "competency_ref": "cis:control-5", + "scheme": "cis", + "prefLabel": "Account Management" + }, + { + "competency_ref": "cis:control-6", + "scheme": "cis", + "prefLabel": "Access Control Management" + } + ], + "competencies": [ + { + "competency_ref": "nice:identity-management", + "scheme": "nice", + "prefLabel": "Identity Management" + }, + { + "competency_ref": "nice:defensive-cybersecurity", + "scheme": "nice", + "prefLabel": "Defensive Cybersecurity" + }, + { + "competency_ref": "enisa:cyber-incident-responder", + "scheme": "enisa", + "prefLabel": "Cyber Incident Responder" + }, + { + "competency_ref": "enisa:cybersecurity-implementer", + "scheme": "enisa", + "prefLabel": "Cybersecurity Implementer" + }, + { + "competency_ref": "cis:control-5", + "scheme": "cis", + "prefLabel": "Account Management" + }, + { + "competency_ref": "cis:control-6", + "scheme": "cis", + "prefLabel": "Access Control Management" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.identity_access_management", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.identity_access_management.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.identity_access_management.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.identity_access_management", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/identity_access_management", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:07aa3f55803e07ff80ca6c58f943962c", + "attestation_hash": "sha256:8f0eae4f9464762ab6f8478045324f06eb0e87d7aae237a08fbeff0460068440" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/identity_access_management/v0-draft", + "embedding_model_ref": "klickd-embed-identity_access_management-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "iam", + "rbac", + "abac", + "session_lifecycle", + "key_rotation" + ], + "entity_classes": [ + "esco", + "sfia", + "nice" + ], + "priority": "security_operation", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "iam_write", + "mfa_downgrade", + "session_token_inline" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "mfa_downgrade", + "session_token_inline" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "iam-write", + "action_class": "iam_write", + "level": "confirm", + "reason": "IAM writes affect blast radius; confirm required." + }, + { + "id": "mfa-downgrade", + "action_class": "mfa_downgrade", + "level": "block", + "reason": "MFA / hardware-token requirement downgrade blocked; floor not lowerable." + }, + { + "id": "session-token-inline", + "action_class": "session_token_inline", + "level": "block", + "reason": "Session tokens never inline." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/identity_access_management are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/learning-designer.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/learning-designer.klickd new file mode 100644 index 0000000..ff775a3 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/learning-designer.klickd @@ -0,0 +1,391 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "education", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B31). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/learning_designer", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b31", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/learning_designer", + "frameworks": [ + "esco", + "digcomp", + "onet", + "lifecomp" + ], + "competency_ids": [ + "esco:S1.6", + "esco:S2.0", + "digcomp:3.1", + "digcomp:5.3", + "onet:25-9031.00", + "lifecomp:L1", + "lifecomp:L3" + ], + "gate_summaries": [ + { + "id": "accessibility-skip", + "level": "block" + }, + { + "id": "minor-learner-pii", + "level": "block" + }, + { + "id": "high-stakes-assessment", + "level": "confirm" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/research" + ], + "target_user": "Learning experience designer / instructional designer building curricula, courses, assessments. Constructive alignment, accessibility, evidence-grounded outcomes. NOT a host-side tutor (that's host_skill).", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://publications.jrc.ec.europa.eu/repository/handle/JRC128415/", + "canonical_url": "https://publications.jrc.ec.europa.eu/repository/handle/JRC128415" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "lifecomp", + "version": "2020", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/lifecomp/2020/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/lifecomp_en" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S1.6", + "scheme": "esco", + "prefLabel": "training, coaching, teaching" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "digcomp:3.1", + "scheme": "digcomp", + "prefLabel": "Developing digital content" + }, + { + "competency_ref": "digcomp:5.3", + "scheme": "digcomp", + "prefLabel": "Creatively using digital technologies" + }, + { + "competency_ref": "onet:25-9031.00", + "scheme": "onet", + "prefLabel": "Instructional Coordinators" + }, + { + "competency_ref": "lifecomp:L1", + "scheme": "lifecomp", + "prefLabel": "Growth mindset" + }, + { + "competency_ref": "lifecomp:L3", + "scheme": "lifecomp", + "prefLabel": "Managing learning" + } + ], + "competencies": [ + { + "competency_ref": "esco:S1.6", + "scheme": "esco", + "prefLabel": "training, coaching, teaching" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "digcomp:3.1", + "scheme": "digcomp", + "prefLabel": "Developing digital content" + }, + { + "competency_ref": "digcomp:5.3", + "scheme": "digcomp", + "prefLabel": "Creatively using digital technologies" + }, + { + "competency_ref": "onet:25-9031.00", + "scheme": "onet", + "prefLabel": "Instructional Coordinators" + }, + { + "competency_ref": "lifecomp:L1", + "scheme": "lifecomp", + "prefLabel": "Growth mindset" + }, + { + "competency_ref": "lifecomp:L3", + "scheme": "lifecomp", + "prefLabel": "Managing learning" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/7", + "level_label": "EQF level 7", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.learning_designer", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.learning_designer.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.learning_designer.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.learning_designer", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/learning_designer", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:a834db6ff63350a74dfb519ea3e537ba", + "attestation_hash": "sha256:fe82dcf3012ca6f6f6f271247dc52f7ba48d9c40d88ab6064bf3fe34ec57589d" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/learning_designer/v0-draft", + "embedding_model_ref": "klickd-embed-learning_designer-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "instructional_design", + "learning_objective", + "assessment", + "scaffold" + ], + "entity_classes": [ + "esco", + "eqf" + ], + "priority": "design_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "skip_accessibility_review", + "minor_learner_pii_write", + "high_stakes_assessment_publish" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "skip_accessibility_review", + "minor_learner_pii_write" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "accessibility-skip", + "action_class": "skip_accessibility_review", + "level": "block", + "reason": "Skipping accessibility review on a published learning artefact is blocked." + }, + { + "id": "minor-learner-pii", + "action_class": "minor_learner_pii_write", + "level": "block", + "reason": "Inline PII of minor learners is blocked." + }, + { + "id": "high-stakes-assessment", + "action_class": "high_stakes_assessment_publish", + "level": "confirm", + "reason": "Publishing a high-stakes assessment requires confirmation against the validity evidence." + } + ] + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/learning_designer are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/literature-review.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/literature-review.klickd new file mode 100644 index 0000000..4038339 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/literature-review.klickd @@ -0,0 +1,348 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "research", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B13). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/literature_review", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b13", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/literature_review", + "frameworks": [ + "esco", + "digcomp" + ], + "competency_ids": [ + "esco:S2.5", + "esco:S2.5.1", + "digcomp:1.2", + "digcomp:1.3" + ], + "gate_summaries": [ + { + "id": "inclusion-exclusion-write", + "level": "confirm" + }, + { + "id": "risk-of-bias-solo", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/research" + ], + "target_user": "Researcher / postgraduate carrier running a systematic-or-narrative literature review. Search strategy, inclusion criteria, risk-of-bias assessment, citation hygiene.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + } + ], + "citation_only_references": [ + { + "id": "prisma-2020", + "ref": "PRISMA 2020", + "url": "http://www.prisma-statement.org/PRISMAStatement/PRISMAStatement" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "digcomp", + "version": "2.2" + } + ], + "transversal_refs": [ + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S2.5", + "scheme": "esco", + "prefLabel": "investigating and reporting" + }, + { + "competency_ref": "esco:S2.5.1", + "scheme": "esco", + "prefLabel": "literature review" + }, + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "digcomp:1.3", + "scheme": "digcomp", + "prefLabel": "Managing data, information and digital content" + } + ], + "competencies": [ + { + "competency_ref": "esco:S2.5", + "scheme": "esco", + "prefLabel": "investigating and reporting" + }, + { + "competency_ref": "esco:S2.5.1", + "scheme": "esco", + "prefLabel": "literature review" + }, + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "digcomp:1.3", + "scheme": "digcomp", + "prefLabel": "Managing data, information and digital content" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.literature_review", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.literature_review.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.literature_review.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.literature_review", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/literature_review", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:250160a379ff99a0f02a0a5a723a642f", + "attestation_hash": "sha256:ac834224f9b4b91f0b44bfb781416924f89e63ba9ca4b2056831efb260aaadc5" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/literature_review/v0-draft", + "embedding_model_ref": "klickd-embed-literature_review-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 7, + "max_facts_per_turn": 9, + "freshness_weighting": "none", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "literature", + "systematic_review", + "prisma", + "citation" + ], + "entity_classes": [ + "esco", + "onet" + ], + "priority": "research_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "inclusion_exclusion_write", + "risk_of_bias_solo_assessment" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "risk_of_bias_solo_assessment" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "inclusion-exclusion-write", + "action_class": "inclusion_exclusion_write", + "level": "confirm", + "reason": "Inclusion / exclusion writes require explicit confirmation." + }, + { + "id": "risk-of-bias-solo", + "action_class": "risk_of_bias_solo_assessment", + "level": "block", + "reason": "Risk-of-bias solo assessment blocked; second reviewer required." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/literature_review are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/llm-agent-engineering.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/llm-agent-engineering.klickd new file mode 100644 index 0000000..290ff57 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/llm-agent-engineering.klickd @@ -0,0 +1,398 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "software_engineering", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B2). Pro tier; compact_index loading strategy declared.", + "renamed_from": "ai-agent-builder.klickd" + }, + "x_klickd_pack": { + "pack": "x.klickd/llm_agent_engineering", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b2", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/llm_agent_engineering", + "frameworks": [ + "esco", + "sfia", + "onet", + "wef" + ], + "competency_ids": [ + "esco:S5.6.1", + "sfia:PROG", + "sfia:ARCH", + "sfia:METL", + "onet:15-1252.00", + "wef:ai-and-big-data", + "wef:programming" + ], + "gate_summaries": [ + { + "id": "agent-deployment", + "level": "confirm" + }, + { + "id": "eval-gating-disable", + "level": "block" + }, + { + "id": "cost-budget-override", + "level": "confirm" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/coding", + "x.klickd/llm_agent_security" + ], + "target_user": "Developer building production LLM agents. Tool design, eval harness, observability, cost discipline.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "sfia", + "version": "8" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S5.6.1", + "scheme": "esco", + "prefLabel": "developing AI and machine learning systems" + }, + { + "competency_ref": "sfia:PROG", + "scheme": "sfia", + "prefLabel": "Programming/software development" + }, + { + "competency_ref": "sfia:ARCH", + "scheme": "sfia", + "prefLabel": "Solution architecture" + }, + { + "competency_ref": "sfia:METL", + "scheme": "sfia", + "prefLabel": "Methods and tools" + }, + { + "competency_ref": "onet:15-1252.00", + "scheme": "onet", + "prefLabel": "Software Developers" + }, + { + "competency_ref": "wef:ai-and-big-data", + "scheme": "wef", + "prefLabel": "AI and big data" + }, + { + "competency_ref": "wef:programming", + "scheme": "wef", + "prefLabel": "Programming" + } + ], + "competencies": [ + { + "competency_ref": "esco:S5.6.1", + "scheme": "esco", + "prefLabel": "developing AI and machine learning systems" + }, + { + "competency_ref": "sfia:PROG", + "scheme": "sfia", + "prefLabel": "Programming/software development" + }, + { + "competency_ref": "sfia:ARCH", + "scheme": "sfia", + "prefLabel": "Solution architecture" + }, + { + "competency_ref": "sfia:METL", + "scheme": "sfia", + "prefLabel": "Methods and tools" + }, + { + "competency_ref": "onet:15-1252.00", + "scheme": "onet", + "prefLabel": "Software Developers" + }, + { + "competency_ref": "wef:ai-and-big-data", + "scheme": "wef", + "prefLabel": "AI and big data" + }, + { + "competency_ref": "wef:programming", + "scheme": "wef", + "prefLabel": "Programming" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.llm_agent_engineering", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.llm_agent_engineering.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.llm_agent_engineering.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.llm_agent_engineering", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/llm_agent_engineering", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:c9702fb4d102ff3ba0e1dc325e1aee5e", + "attestation_hash": "sha256:400756ab3a65fe8fb53a347114b49e8fb140659ee7a3d62d74dbba247f67a873" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/llm_agent_engineering/v0-draft", + "embedding_model_ref": "klickd-embed-llm_agent_engineering-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 7, + "max_facts_per_turn": 9, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "agent", + "tool_use", + "router", + "eval_harness", + "regression" + ], + "entity_classes": [ + "esco", + "sfia", + "onet" + ], + "priority": "engineering_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "agent_deployment", + "disable_eval_gating_on_model_bump", + "cost_budget_override" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "disable_eval_gating_on_model_bump" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "agent-deployment", + "action_class": "agent_deployment", + "level": "confirm", + "reason": "Agent deployments are hard to reverse." + }, + { + "id": "eval-gating-disable", + "action_class": "disable_eval_gating_on_model_bump", + "level": "block", + "reason": "Eval gating disables blocked on model version bumps; floor not lowerable." + }, + { + "id": "cost-budget-override", + "action_class": "cost_budget_override", + "level": "confirm", + "reason": "Cost budget overrides require explicit attestation." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/llm_agent_engineering are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/llm-agent-security.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/llm-agent-security.klickd new file mode 100644 index 0000000..b732593 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/llm-agent-security.klickd @@ -0,0 +1,420 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "security", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B1). Pro tier; compact_index loading strategy declared.", + "renamed_from": "agent-security.klickd" + }, + "x_klickd_pack": { + "pack": "x.klickd/llm_agent_security", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b1", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/llm_agent_security", + "frameworks": [ + "nice", + "enisa", + "cis", + "esco" + ], + "competency_ids": [ + "nice:adversary-emulation", + "nice:secure-software-assessment", + "nice:vulnerability-assessment", + "enisa:cybersecurity-risk-manager", + "enisa:penetration-tester", + "cis:control-16", + "cis:control-18", + "esco:S5.6" + ], + "gate_summaries": [ + { + "id": "agent-deployment", + "level": "confirm" + }, + { + "id": "prompt-injection-screen-disable", + "level": "block" + }, + { + "id": "memory-write-guard-disable", + "level": "block" + }, + { + "id": "responsible-disclosure", + "level": "confirm" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/security", + "x.klickd/coding" + ], + "target_user": "Engineer / SRE / red-teamer building or operating LLM agents and MCP / tool-using systems. Prompt-injection literacy, tool-use sandboxing, eval discipline.", + "frameworks": [ + { + "scheme": "nice", + "version": "r1", + "iri_prefix": "https://niccs.cisa.gov/workforce-development/nice-framework/", + "canonical_url": "https://niccs.cisa.gov/workforce-development/nice-framework" + }, + { + "scheme": "enisa", + "version": "1.0", + "iri_prefix": "https://www.enisa.europa.eu/topics/skills-and-competences/skills-development/european-cybersecurity-skills-framework/", + "canonical_url": "https://www.enisa.europa.eu/topics/skills-and-competences/skills-development/european-cybersecurity-skills-framework" + }, + { + "scheme": "cis", + "version": "v8", + "iri_prefix": "https://www.cisecurity.org/controls/v8/", + "canonical_url": "https://www.cisecurity.org/controls/cis-controls-list" + }, + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "nice", + "version": "r1" + }, + { + "scheme": "enisa", + "version": "1.0" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "nice:adversary-emulation", + "scheme": "nice", + "prefLabel": "Adversary Emulation" + }, + { + "competency_ref": "nice:secure-software-assessment", + "scheme": "nice", + "prefLabel": "Secure Software Assessment" + }, + { + "competency_ref": "nice:vulnerability-assessment", + "scheme": "nice", + "prefLabel": "Vulnerability Assessment" + }, + { + "competency_ref": "enisa:cybersecurity-risk-manager", + "scheme": "enisa", + "prefLabel": "Cybersecurity Risk Manager" + }, + { + "competency_ref": "enisa:penetration-tester", + "scheme": "enisa", + "prefLabel": "Penetration Tester" + }, + { + "competency_ref": "cis:control-16", + "scheme": "cis", + "prefLabel": "Application Software Security" + }, + { + "competency_ref": "cis:control-18", + "scheme": "cis", + "prefLabel": "Penetration Testing" + }, + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT security" + } + ], + "competencies": [ + { + "competency_ref": "nice:adversary-emulation", + "scheme": "nice", + "prefLabel": "Adversary Emulation" + }, + { + "competency_ref": "nice:secure-software-assessment", + "scheme": "nice", + "prefLabel": "Secure Software Assessment" + }, + { + "competency_ref": "nice:vulnerability-assessment", + "scheme": "nice", + "prefLabel": "Vulnerability Assessment" + }, + { + "competency_ref": "enisa:cybersecurity-risk-manager", + "scheme": "enisa", + "prefLabel": "Cybersecurity Risk Manager" + }, + { + "competency_ref": "enisa:penetration-tester", + "scheme": "enisa", + "prefLabel": "Penetration Tester" + }, + { + "competency_ref": "cis:control-16", + "scheme": "cis", + "prefLabel": "Application Software Security" + }, + { + "competency_ref": "cis:control-18", + "scheme": "cis", + "prefLabel": "Penetration Testing" + }, + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT security" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.llm_agent_security", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.llm_agent_security.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.llm_agent_security.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.llm_agent_security", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/llm_agent_security", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:1c1d4fda631d9a0a5c96e8254beb8193", + "attestation_hash": "sha256:a84abb41a8690e74bdae73e7237557559b9334f940a07bdbae110d0a8886d5b8" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/llm_agent_security/v0-draft", + "embedding_model_ref": "klickd-embed-llm_agent_security-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 7, + "max_facts_per_turn": 9, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "prompt_injection", + "jailbreak", + "exfiltration", + "owasp_llm" + ], + "entity_classes": [ + "esco", + "nice", + "enisa_ref" + ], + "priority": "security_operation", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "agent_capability_deployment", + "disable_prompt_injection_screen", + "disable_memory_write_guard", + "vuln_disclosure" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "disable_prompt_injection_screen", + "disable_memory_write_guard" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "agent-deployment", + "action_class": "agent_capability_deployment", + "level": "confirm", + "reason": "Agent capability changes are hard to reverse once shipped." + }, + { + "id": "prompt-injection-screen-disable", + "action_class": "disable_prompt_injection_screen", + "level": "block", + "reason": "Default disables blocked; floor not lowerable by this pack." + }, + { + "id": "memory-write-guard-disable", + "action_class": "disable_memory_write_guard", + "level": "block", + "reason": "Memory-write guard disables blocked; floor not lowerable." + }, + { + "id": "responsible-disclosure", + "action_class": "vuln_disclosure", + "level": "confirm", + "reason": "Vulnerability disclosure must follow declared responsible-disclosure path." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/llm_agent_security are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/manifest.json b/packages/pypi/klickd/src/klickd/x_klickd_skills/manifest.json new file mode 100644 index 0000000..73d85a0 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/manifest.json @@ -0,0 +1,402 @@ +{ + "manifest_version": "1.0", + "kind": "x_klickd_v4_1_download_index", + "non_normative": true, + "claims_v41_ga": false, + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "generated_at": "2026-05-28T01:00:00Z", + "hash_algo": "sha256", + "raw_url_template": "https://raw.githubusercontent.com/Davincc77/klickdskill/main/{relative_path}", + "note": "Aggregated download index for the public x.klickd v4.1 candidate skill catalog. NON-NORMATIVE. NOT GA. Each entry's `relative_path` substituted into `raw_url_template` yields a raw GitHub URL serving the byte-identical .klickd JSON whose SHA-256 is `sha256_file`. The per-tier manifests under `lite/` and `pro/` remain authoritative; this index is a convenience surface for the public site so it can link to 42 distinct raw URLs from a single hard-coded entry point.", + "tiers": { + "lite": { + "expected_count": 8, + "actual_count": 8 + }, + "pro": { + "expected_count": 34, + "actual_count": 34 + } + }, + "total_count": 42, + "packs": [ + { + "tier": "lite", + "pack": "x.klickd/artist", + "file": "artist.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/lite/artist.klickd", + "bytes": 9308, + "sha256_file": "56dbd966942475354e4f2daac48c3aeabfedbf3ff48f6248c443cdf8fe82b5c8", + "status": "candidate_mapped" + }, + { + "tier": "lite", + "pack": "x.klickd/consumer_rights", + "file": "consumer-rights.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/lite/consumer-rights.klickd", + "bytes": 9353, + "sha256_file": "16f77c9b7cb0801f198407f063c1b8395b98f6f729a14597ede8a15ae766ebbc", + "status": "candidate_mapped" + }, + { + "tier": "lite", + "pack": "x.klickd/game_literacy", + "file": "game-literacy.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/lite/game-literacy.klickd", + "bytes": 9325, + "sha256_file": "6e3158a2bde1024f54db53d149e525b820c4c167a71124416c8f4e8df38a3632", + "status": "candidate_mapped" + }, + { + "tier": "lite", + "pack": "x.klickd/media_planner", + "file": "media-planner.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/lite/media-planner.klickd", + "bytes": 9719, + "sha256_file": "a399ef56eb140d5adf272ffe3578448085f082154647811853e3d52e58b3a33e", + "status": "candidate_mapped" + }, + { + "tier": "lite", + "pack": "x.klickd/parent_gaming", + "file": "parent-gaming.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/lite/parent-gaming.klickd", + "bytes": 10149, + "sha256_file": "f2016892ac731f284d37d207a9464dcb93551b6934ff86f09d05fcd9d1a0ce52", + "status": "candidate_mapped" + }, + { + "tier": "lite", + "pack": "x.klickd/social_literacy", + "file": "social-literacy.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/lite/social-literacy.klickd", + "bytes": 9745, + "sha256_file": "5da46abae45a40adf562d1119bd4240c60d14b7c2b798e8e47aed4122834d9dc", + "status": "candidate_mapped" + }, + { + "tier": "lite", + "pack": "x.klickd/streaming_creator", + "file": "streaming-creator.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/lite/streaming-creator.klickd", + "bytes": 9332, + "sha256_file": "83a47a7370650c9870d28566344a11e52298a9e0a581003dc0ea8009558ac8ce", + "status": "candidate_mapped" + }, + { + "tier": "lite", + "pack": "x.klickd/work_assistant", + "file": "work-assistant.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/lite/work-assistant.klickd", + "bytes": 10312, + "sha256_file": "7918922d04e406c406f1d8a1a6aeaa3f82fb2a9c5697a547f001cfac85063bcb", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/accounting_operator", + "file": "accounting-operator.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/accounting-operator.klickd", + "bytes": 11371, + "sha256_file": "0464b9d8bd284e7c498a60064f8f923e148f2ac3e0e39fd7c0f479174c8ad243", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/api_integrator", + "file": "api-integrator.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/api-integrator.klickd", + "bytes": 11707, + "sha256_file": "875536c647ff1905f2e54a7997977b7d4087b7153b8b9a7c3270aef301af6dab", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/contract_review", + "file": "contract-review.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/contract-review.klickd", + "bytes": 10615, + "sha256_file": "4be316d9bbb758e9d98dcf81ac25ef1fc9a8e24d9cb6462055d66660f104ba41", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/customer_support_operator", + "file": "customer-support-operator.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/customer-support-operator.klickd", + "bytes": 12349, + "sha256_file": "9e6c755f8d975110bd8fd5bfdb1d87773f1a571968bf27933357b7bcc13516e9", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/data_analyst", + "file": "data-analyst.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/data-analyst.klickd", + "bytes": 12175, + "sha256_file": "8ae8fe5e3b55d4402e0da93738e97d23c41d3daeb93c6bdc41301486a2f6cd4f", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/devops_operator", + "file": "devops-operator.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/devops-operator.klickd", + "bytes": 12201, + "sha256_file": "bfad80b1110461f683c7000b9af1104ccdcd33a10c3059e3898dabea3f1d6fb4", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/drone_operator", + "file": "drone-operator.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/drone-operator.klickd", + "bytes": 10450, + "sha256_file": "d4017d93c8b8ac765e59914b61116bd90bd68944c4a2b47e031dafc7d562ec23", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/edge_ai_operator", + "file": "edge-ai-operator.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/edge-ai-operator.klickd", + "bytes": 12705, + "sha256_file": "295cd879168320e5af7d19a0c82a1bd0f8be52fbf9f16ec80c9db7f33b3cef6e", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/eu_ai_act", + "file": "eu-ai-act.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/eu-ai-act.klickd", + "bytes": 10507, + "sha256_file": "4df66de2930e3f4d726c08a1e0d15e64c6929f4cbbd6a593d69b9f88c5a9de93", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/evidence_desk", + "file": "evidence-desk.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/evidence-desk.klickd", + "bytes": 11765, + "sha256_file": "a1cc35277960a95ebbe12ca12c00d9d70ce71dc58cae99b642653835b90d14dd", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/finance_analyst", + "file": "finance-analyst.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/finance-analyst.klickd", + "bytes": 11950, + "sha256_file": "dbf02eac4910f73b35f818bd20545cd41f6a391ca06adf59f9470aa421afb326", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/game_design", + "file": "game-design.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/game-design.klickd", + "bytes": 12342, + "sha256_file": "0894cec1f3f54b770a16fd3f07e16817ee57e574bdb2ca0837b8653362f3abb3", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/gdpr_readiness", + "file": "gdpr-readiness.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/gdpr-readiness.klickd", + "bytes": 10671, + "sha256_file": "d5c4cb7b707fc3f028424f34149cb95300fae583f9a261dfc161914da43bbc40", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/healthcare_ai_safety_reviewer", + "file": "healthcare-ai-safety-reviewer.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/healthcare-ai-safety-reviewer.klickd", + "bytes": 12293, + "sha256_file": "183965179ebcdb7ef0f67866aa9c7364aaad1bd02996b4d0c696580ee2c6f789", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/identity_access_management", + "file": "identity-access-management.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/identity-access-management.klickd", + "bytes": 12310, + "sha256_file": "d9112c7f82733e77bc382c4ca314c2bf3112c63ca03455a7efd037b6c33cd74d", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/learning_designer", + "file": "learning-designer.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/learning-designer.klickd", + "bytes": 12206, + "sha256_file": "f7b1f5d39ee4f05261b4735a32475dee2583556681124c59b0250335729188f9", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/literature_review", + "file": "literature-review.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/literature-review.klickd", + "bytes": 10906, + "sha256_file": "104865d2750605d9261fd27208b0e19e2908861e9e5672ed453d383701a770f1", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/llm_agent_engineering", + "file": "llm-agent-engineering.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/llm-agent-engineering.klickd", + "bytes": 12164, + "sha256_file": "1649234c2859b8309c404f71f5c0db714805655cdbb714b7bdb9394644fb49f8", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/llm_agent_security", + "file": "llm-agent-security.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/llm-agent-security.klickd", + "bytes": 13319, + "sha256_file": "baed596a642f68086cabc1a76d09ba6d987231a057c8fb66f1aabb84dd137098", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/mission_control", + "file": "mission-control.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/mission-control.klickd", + "bytes": 11861, + "sha256_file": "2c2d02b4ecec40f022c4c7da0cdb3f082e588dfe11d3f14d1692dbbdba7e8ba2", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/policy_analyst", + "file": "policy-analyst.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/policy-analyst.klickd", + "bytes": 11275, + "sha256_file": "f348f1d1a73797979a51005586dcd9f1069a17fab173dab7df742290127c73a7", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/privacy_product", + "file": "privacy-product.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/privacy-product.klickd", + "bytes": 10728, + "sha256_file": "5a35d4a214a98f945f048c6647528df5ce2188aaa3d0913b7c6a1af2305eff00", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/product_manager", + "file": "product-manager.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/product-manager.klickd", + "bytes": 12231, + "sha256_file": "dbf2365508df3ae9acbbb6e002e3c44fb2a81e9166d0003cacb94a3714fdaeda", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/project_operator", + "file": "project-operator.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/project-operator.klickd", + "bytes": 11164, + "sha256_file": "5d019adfc08bcf518780bbe3e18a428682374397475a8bf6282d1e474ae6d5ce", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/release_engineer", + "file": "release-engineer.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/release-engineer.klickd", + "bytes": 12865, + "sha256_file": "c96329cff482f39d52a13b628bd027cd5854f15d40ce58c945fb58aec52aef9e", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/rights_guard", + "file": "rights-guard.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/rights-guard.klickd", + "bytes": 10347, + "sha256_file": "3efa2982479b6ba3544092d848fb52b91dc7687031c4a481181547d9728703b3", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/sales_operator", + "file": "sales-operator.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/sales-operator.klickd", + "bytes": 12186, + "sha256_file": "1bdc2c5895e07b909dda9bd04040917004727bed00198962c006a43a0be13060", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/second_brain", + "file": "second-brain.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/second-brain.klickd", + "bytes": 11153, + "sha256_file": "06504aa5dddc1b53634310210fff4374e68e0a2b959ae9dfa191b29995153bdb", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/security_incident_response", + "file": "security-incident-response.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/security-incident-response.klickd", + "bytes": 12682, + "sha256_file": "1315833cf73b3d04e00fe73006e985b0a7af7d266c457e18f61204cca09dcc7a", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/sustainability_analyst", + "file": "sustainability-analyst.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/sustainability-analyst.klickd", + "bytes": 12667, + "sha256_file": "445a7f1111e6474ca87bc717d0f50d6af5016863fe3fd87083502d77eeffcf1f", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/technical_writer", + "file": "technical-writer.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/technical-writer.klickd", + "bytes": 12150, + "sha256_file": "473c44c67a889c783872494f262feb16bdb1377a74dd5b4d605fe340ecebecc9", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/trust_evidence", + "file": "trust-evidence.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/trust-evidence.klickd", + "bytes": 11317, + "sha256_file": "57f4ac349438d3c3305e03ecf9a09a44d20e289550f8afa292267666bcc150ad", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/ux_researcher", + "file": "ux-researcher.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/ux-researcher.klickd", + "bytes": 12109, + "sha256_file": "d91afbf120c6175c4d23d175265697b7a0a7bd4f11dd60fc08bb053c8113e13e", + "status": "candidate_mapped" + }, + { + "tier": "pro", + "pack": "x.klickd/video_production_pipeline", + "file": "video-production-pipeline.klickd", + "relative_path": "examples/v4.1/x-klickd-skills/pro/video-production-pipeline.klickd", + "bytes": 16908, + "sha256_file": "d6da8f7569953f7c6fb4f0ce02cb2649187bcbf52ae3f4d32a35c8fe885498a8", + "status": "candidate_mapped" + } + ] +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/media-planner.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/media-planner.klickd new file mode 100644 index 0000000..386a234 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/media-planner.klickd @@ -0,0 +1,312 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "creative", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "lite", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact. Composes with x.klickd/creator (P1); narrower planning / publishing scope for end-user creators.", + "renamed_from": "media-lite.klickd" + }, + "x_klickd_pack": { + "pack": "x.klickd/media_planner", + "pack_version": "0.1.0-candidate-lite", + "spec_ref": "x.klickd/v4.1#a4", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "lite", + "parent_packs": [ + "x.klickd/user", + "x.klickd/creator" + ], + "target_user": "End-user creator: hobbyist editor, occasional newsletter author, light social-media poster. Not a journalist; not a full editorial role.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "digcomp", + "version": "2.2" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S1", + "scheme": "esco", + "prefLabel": "communication, collaboration and creativity" + }, + { + "competency_ref": "digcomp:3.1", + "scheme": "digcomp", + "prefLabel": "Developing digital content" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "creativity and innovation" + }, + { + "competency_ref": "digcomp:3.1", + "scheme": "digcomp", + "prefLabel": "Developing digital content" + }, + { + "competency_ref": "digcomp:3.2", + "scheme": "digcomp", + "prefLabel": "Integrating and re-elaborating digital content" + }, + { + "competency_ref": "digcomp:3.3", + "scheme": "digcomp", + "prefLabel": "Copyright and licences" + }, + { + "competency_ref": "digcomp:2.2", + "scheme": "digcomp", + "prefLabel": "Sharing through digital technologies" + } + ], + "competencies": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "creativity and innovation" + }, + { + "competency_ref": "digcomp:3.1", + "scheme": "digcomp", + "prefLabel": "Developing digital content" + }, + { + "competency_ref": "digcomp:3.3", + "scheme": "digcomp", + "prefLabel": "Copyright and licences" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/4", + "level_label": "EQF level 4", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.media_planner", + "memory_segments": [ + { + "id": "drafts", + "scope": "memory.x_klickd.media_planner.drafts", + "policy": "pointer_only_summary" + }, + { + "id": "rights", + "scope": "memory.x_klickd.media_planner.rights", + "policy": "pointer_only_attribution" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.media_planner", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/media_planner", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:057abe1e1239dee682ee525b04e2cd2c", + "attestation_hash": "sha256:d5e67a7380ecdc90265d7b2dc40564ec5a12de1cafd95527c0c910193bed7eb6" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/media_planner/v0-draft", + "embedding_model_ref": "klickd-embed-media_planner-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 5, + "max_facts_per_turn": 7, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "media", + "audience", + "campaign", + "channel_mix", + "kpi" + ], + "entity_classes": [ + "esco" + ], + "priority": "planning_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "media_profile_compose_ref": "rfc-001#media_profile", + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "public_post", + "third_party_identifiable_content", + "minor_in_frame" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "minor_in_frame", + "third_party_identifiable_content" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "human_carrier_only" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "third-party-identifiable", + "action_class": "third_party_identifiable_content", + "level": "confirm", + "reason": "Content identifying a third party requires explicit consent and confirmation." + }, + { + "id": "minor-in-frame", + "action_class": "minor_in_frame", + "level": "block", + "reason": "Minors-in-frame require guardian consent; floor cannot be lowered by this pack." + }, + { + "id": "copyright-claim", + "action_class": "copyright_claim", + "level": "confirm", + "reason": "Copyright / licence claims must be grounded against the actual licence text (RFC-002 §8b)." + } + ] + }, + "router_cost": { + "tokens_estimate": 750, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into ESCO or DigComp.", + "RFC-001 media_profile is composed by reference, not redefined inline.", + "Minor-in-frame gate is block and non-lowerable by this pack.", + "Pointer-only evidence; no inline media bytes.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == lite and tokens_estimate <= 900", + "media_profile_compose_ref points to RFC-001 §media_profile" + ], + "review": [ + "Reviewer verifies copyright/licence claims have RFC-002 §8b grounding shape.", + "Reviewer verifies minor-in-frame floor is not lowered." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/mission-control.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/mission-control.klickd new file mode 100644 index 0000000..e47821f --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/mission-control.klickd @@ -0,0 +1,374 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "operations", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B16). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/mission_control", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b16", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/mission_control", + "frameworks": [ + "esco", + "nice", + "enisa", + "wef" + ], + "competency_ids": [ + "esco:S4.1", + "esco:S4.1.2", + "nice:incident-response", + "enisa:cyber-incident-responder", + "wef:complex-problem-solving" + ], + "gate_summaries": [ + { + "id": "status-declaration", + "level": "confirm" + }, + { + "id": "escalation-bypass", + "level": "block" + }, + { + "id": "confidential-channel-inline", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/mission", + "x.klickd/security" + ], + "target_user": "Operator running a time-critical multi-system mission. Incident command, status declaration, comms discipline, escalation ladder.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "nice", + "version": "r1", + "iri_prefix": "https://niccs.cisa.gov/workforce-development/nice-framework/", + "canonical_url": "https://niccs.cisa.gov/workforce-development/nice-framework" + }, + { + "scheme": "enisa", + "version": "1.0", + "iri_prefix": "https://www.enisa.europa.eu/topics/skills-and-competences/skills-development/european-cybersecurity-skills-framework/", + "canonical_url": "https://www.enisa.europa.eu/topics/skills-and-competences/skills-development/european-cybersecurity-skills-framework" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "nice", + "version": "r1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.1", + "scheme": "esco", + "prefLabel": "project management" + }, + { + "competency_ref": "esco:S4.1.2", + "scheme": "esco", + "prefLabel": "operations management" + }, + { + "competency_ref": "nice:incident-response", + "scheme": "nice", + "prefLabel": "Incident Response" + }, + { + "competency_ref": "enisa:cyber-incident-responder", + "scheme": "enisa", + "prefLabel": "Cyber Incident Responder" + }, + { + "competency_ref": "wef:complex-problem-solving", + "scheme": "wef", + "prefLabel": "Complex problem solving" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4.1", + "scheme": "esco", + "prefLabel": "project management" + }, + { + "competency_ref": "esco:S4.1.2", + "scheme": "esco", + "prefLabel": "operations management" + }, + { + "competency_ref": "nice:incident-response", + "scheme": "nice", + "prefLabel": "Incident Response" + }, + { + "competency_ref": "enisa:cyber-incident-responder", + "scheme": "enisa", + "prefLabel": "Cyber Incident Responder" + }, + { + "competency_ref": "wef:complex-problem-solving", + "scheme": "wef", + "prefLabel": "Complex problem solving" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.mission_control", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.mission_control.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.mission_control.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.mission_control", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/mission_control", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:48f4749d4eaeffeed878e48f21f3f348", + "attestation_hash": "sha256:439c831eb711463a02abf283d75e5d3f6ed2c8224fbaccb994da6b2f3f7c4f28" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/mission_control/v0-draft", + "embedding_model_ref": "klickd-embed-mission_control-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "mission_control", + "task_routing", + "agent_orchestration", + "audit" + ], + "entity_classes": [ + "esco", + "sfia" + ], + "priority": "orchestration_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "status_up_or_down_declaration", + "escalation_step_bypass", + "confidential_channel_content_inline" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "escalation_step_bypass", + "confidential_channel_content_inline" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "status-declaration", + "action_class": "status_up_or_down_declaration", + "level": "confirm", + "reason": "Status declarations affect downstream consumers; confirm required." + }, + { + "id": "escalation-bypass", + "action_class": "escalation_step_bypass", + "level": "block", + "reason": "Escalation step bypass blocked; floor not lowerable." + }, + { + "id": "confidential-channel-inline", + "action_class": "confidential_channel_content_inline", + "level": "block", + "reason": "Inline confidential channel content blocked." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/mission_control are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/parent-gaming.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/parent-gaming.klickd new file mode 100644 index 0000000..351125d --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/parent-gaming.klickd @@ -0,0 +1,325 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "family_support", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "lite", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact. Lot A parent-gaming pack: carries the PARENT carrier's state; does NOT carry the child's state." + }, + "x_klickd_pack": { + "pack": "x.klickd/parent_gaming", + "pack_version": "0.1.0-candidate-lite", + "spec_ref": "x.klickd/v4.1#a13", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "lite", + "parent_packs": [ + "x.klickd/user", + "x.klickd/gaming", + "x.klickd/security" + ], + "target_user": "Parent / guardian carrier supporting a minor's gaming. Rating literacy (PEGI / ESRB / USK), screen-time discipline, online-safety hygiene. Carries the parent carrier's state only; does NOT carry the child's state.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + }, + { + "scheme": "lifecomp", + "version": "2020", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/lifecomp/2020/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/lifecomp_en" + } + ], + "citation_only_references": [ + { + "id": "pegi", + "ref": "PEGI Pan-European Game Information", + "url": "https://pegi.info/" + }, + { + "id": "esrb", + "ref": "ESRB Entertainment Software Rating Board", + "url": "https://www.esrb.org/" + }, + { + "id": "usk", + "ref": "USK Unterhaltungssoftware Selbstkontrolle", + "url": "https://usk.de/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "digcomp", + "version": "2.2" + }, + { + "scheme": "lifecomp", + "version": "2020" + } + ], + "transversal_refs": [ + { + "competency_ref": "digcomp:4.1", + "scheme": "digcomp", + "prefLabel": "Protecting devices" + }, + { + "competency_ref": "lifecomp:S1", + "scheme": "lifecomp", + "prefLabel": "Empathy" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S2.1", + "scheme": "esco", + "prefLabel": "providing educational support" + }, + { + "competency_ref": "digcomp:4.1", + "scheme": "digcomp", + "prefLabel": "Protecting devices" + }, + { + "competency_ref": "digcomp:4.2", + "scheme": "digcomp", + "prefLabel": "Protecting personal data and privacy" + }, + { + "competency_ref": "digcomp:4.3", + "scheme": "digcomp", + "prefLabel": "Protecting health and well-being" + }, + { + "competency_ref": "lifecomp:S1", + "scheme": "lifecomp", + "prefLabel": "Empathy" + } + ], + "competencies": [ + { + "competency_ref": "digcomp:4.1", + "scheme": "digcomp", + "prefLabel": "Protecting devices" + }, + { + "competency_ref": "digcomp:4.2", + "scheme": "digcomp", + "prefLabel": "Protecting personal data and privacy" + }, + { + "competency_ref": "digcomp:4.3", + "scheme": "digcomp", + "prefLabel": "Protecting health and well-being" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/4", + "level_label": "EQF level 4", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.parent_gaming", + "memory_segments": [ + { + "id": "rating-notes", + "scope": "memory.x_klickd.parent_gaming.rating_notes", + "policy": "pointer_only_no_child_pii" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.parent_gaming", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/parent_gaming", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:7cfed4e277597a8b89b2627c3fb5c45e", + "attestation_hash": "sha256:a0f2a94fabf0eaa9a5d647451943d2399313d6a2b4620f48ad3236a41f416ecf" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/parent_gaming/v0-draft", + "embedding_model_ref": "klickd-embed-parent_gaming-2026-v0-placeholder", + "dim": 384, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 4, + "max_facts_per_turn": 5, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "parenting", + "child_safety", + "screen_time", + "age_rating" + ], + "entity_classes": [ + "esco", + "lifecomp", + "digcomp" + ], + "priority": "guardian_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "child_facing_recommendation", + "child_pii_write" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "child_pii_write", + "override_child_carrier_guardian_posture" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "human_carrier_only", + "minor_carrier_compose_rule": "this_pack_cannot_override_human_carrier_with_guardian_posture_on_child_carrier_file" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr", + "de" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "child-pii-write", + "action_class": "child_pii_write", + "level": "block", + "reason": "Writing PII about a child to this carrier's file is blocked; floor non-lowerable." + }, + { + "id": "child-carrier-override", + "action_class": "override_child_carrier_guardian_posture", + "level": "block", + "reason": "Cannot lower the human_carrier_with_guardian posture on a child's own carrier file." + } + ] + }, + "router_cost": { + "tokens_estimate": 800, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into ESCO, DigComp, or LifeComp.", + "PEGI/ESRB/USK are citation-only, not frameworks[] schemes.", + "child_pii_write gate is block and non-lowerable.", + "Pack carries parent state only; explicit rule that it cannot override child's guardian posture.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == lite and tokens_estimate <= 900", + "block on child_pii_write present" + ], + "review": [ + "Reviewer verifies minor_carrier_compose_rule is preserved.", + "Reviewer verifies no child PII shape is required by the pack." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/policy-analyst.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/policy-analyst.klickd new file mode 100644 index 0000000..f6b62a2 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/policy-analyst.klickd @@ -0,0 +1,364 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "research", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B11). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/policy_analyst", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b11", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/policy_analyst", + "frameworks": [ + "esco", + "wef", + "onet" + ], + "competency_ids": [ + "esco:S4.6", + "esco:S4.6.4", + "esco:S2.5", + "wef:analytical-thinking", + "wef:systems-thinking", + "onet:19-3094.00" + ], + "gate_summaries": [ + { + "id": "named-attribution", + "level": "confirm" + }, + { + "id": "regulated-submission", + "level": "confirm" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/research", + "x.klickd/legal" + ], + "target_user": "Public-policy analyst. Legislative tracking, stakeholder mapping, comparative-jurisdiction analysis, briefing-note discipline.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "wef", + "version": "2023" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S4.6.4", + "scheme": "esco", + "prefLabel": "public administration" + }, + { + "competency_ref": "esco:S2.5", + "scheme": "esco", + "prefLabel": "investigating and reporting" + }, + { + "competency_ref": "wef:analytical-thinking", + "scheme": "wef", + "prefLabel": "Analytical thinking" + }, + { + "competency_ref": "wef:systems-thinking", + "scheme": "wef", + "prefLabel": "Systems thinking" + }, + { + "competency_ref": "onet:19-3094.00", + "scheme": "onet", + "prefLabel": "Political Scientists" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S4.6.4", + "scheme": "esco", + "prefLabel": "public administration" + }, + { + "competency_ref": "esco:S2.5", + "scheme": "esco", + "prefLabel": "investigating and reporting" + }, + { + "competency_ref": "wef:analytical-thinking", + "scheme": "wef", + "prefLabel": "Analytical thinking" + }, + { + "competency_ref": "wef:systems-thinking", + "scheme": "wef", + "prefLabel": "Systems thinking" + }, + { + "competency_ref": "onet:19-3094.00", + "scheme": "onet", + "prefLabel": "Political Scientists" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.policy_analyst", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.policy_analyst.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.policy_analyst.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.policy_analyst", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/policy_analyst", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:1b34594337e191a57deda4e9a0bebd43", + "attestation_hash": "sha256:edd86b567c26d66a03d3a760445db2a62330538a542c2f166dc3ba58adc0cdd3" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/policy_analyst/v0-draft", + "embedding_model_ref": "klickd-embed-policy_analyst-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "policy", + "impact_assessment", + "stakeholder_map", + "scenario" + ], + "entity_classes": [ + "esco", + "eu_law_ref" + ], + "priority": "policy_analysis", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "named_legislator_or_institution_attribution", + "regulated_submission_informed_by_analysis" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "named-attribution", + "action_class": "named_legislator_or_institution_attribution", + "level": "confirm", + "reason": "Attribution to a named legislator or institution requires confirmation." + }, + { + "id": "regulated-submission", + "action_class": "regulated_submission_informed_by_analysis", + "level": "confirm", + "reason": "Analyses informing regulated submissions require counsel escalation." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/policy_analyst are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/privacy-product.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/privacy-product.klickd new file mode 100644 index 0000000..5be3842 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/privacy-product.klickd @@ -0,0 +1,343 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "legal", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B9). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/privacy_product", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b9", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/privacy_product", + "frameworks": [ + "esco", + "digcomp" + ], + "competency_ids": [ + "esco:S5.6.2", + "esco:S4.6.2", + "digcomp:4.2" + ], + "gate_summaries": [ + { + "id": "data-flow-cross-processor", + "level": "confirm" + }, + { + "id": "dpo-escalation-skip", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/legal", + "x.klickd/coding" + ], + "target_user": "Product manager / engineer applying privacy-by-design to a product. Data flows, retention, lawful basis, consent UX, DSR surfaces.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + } + ], + "citation_only_references": [ + { + "id": "gdpr-art-25", + "ref": "GDPR Art. 25 (Data protection by design and by default)", + "url": "https://eur-lex.europa.eu/eli/reg/2016/679/oj" + }, + { + "id": "enisa-privacy-by-design", + "ref": "ENISA Privacy by Design", + "url": "https://www.enisa.europa.eu/topics/data-protection/privacy-by-design" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "digcomp", + "version": "2.2" + } + ], + "transversal_refs": [ + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S5.6.2", + "scheme": "esco", + "prefLabel": "ICT privacy engineering" + }, + { + "competency_ref": "esco:S4.6.2", + "scheme": "esco", + "prefLabel": "data protection" + }, + { + "competency_ref": "digcomp:4.2", + "scheme": "digcomp", + "prefLabel": "Protecting personal data and privacy" + } + ], + "competencies": [ + { + "competency_ref": "esco:S5.6.2", + "scheme": "esco", + "prefLabel": "ICT privacy engineering" + }, + { + "competency_ref": "esco:S4.6.2", + "scheme": "esco", + "prefLabel": "data protection" + }, + { + "competency_ref": "digcomp:4.2", + "scheme": "digcomp", + "prefLabel": "Protecting personal data and privacy" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.privacy_product", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.privacy_product.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.privacy_product.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.privacy_product", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/privacy_product", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:0b0bad96adaf394a37ef89b4d0924afa", + "attestation_hash": "sha256:672a6015e1f6153fc94699845ebb91c8de243dbdce02fe93043c151b99971de8" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/privacy_product/v0-draft", + "embedding_model_ref": "klickd-embed-privacy_product-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "privacy_by_design", + "consent", + "dpia", + "data_minimisation" + ], + "entity_classes": [ + "esco", + "eu_law_ref" + ], + "priority": "design_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "data_flow_cross_processor", + "skip_dpo_escalation" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "skip_dpo_escalation" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "data-flow-cross-processor", + "action_class": "data_flow_cross_processor", + "level": "confirm", + "reason": "Data flows crossing a processor boundary require explicit confirmation." + }, + { + "id": "dpo-escalation-skip", + "action_class": "skip_dpo_escalation", + "level": "block", + "reason": "DPO escalation skip blocked when retention or lawful basis is ambiguous." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/privacy_product are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/product-manager.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/product-manager.klickd new file mode 100644 index 0000000..20b1897 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/product-manager.klickd @@ -0,0 +1,393 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "product_management", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B20). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/product_manager", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b20", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/product_manager", + "frameworks": [ + "esco", + "sfia", + "onet", + "wef" + ], + "competency_ids": [ + "esco:S4", + "esco:S4.0.1", + "sfia:PROD", + "sfia:RLMT", + "onet:11-2021.00", + "wef:leadership-social-influence", + "wef:analytical-thinking" + ], + "gate_summaries": [ + { + "id": "roadmap-commit", + "level": "confirm" + }, + { + "id": "feature-cut-on-evidence-skip", + "level": "block" + }, + { + "id": "pricing-change", + "level": "confirm" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/work", + "x.klickd/coding" + ], + "target_user": "Product manager driving roadmap, discovery, and delivery for a software product. Stakeholder alignment, prioritisation, evidence-based decisions. NOT a senior people-manager role.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4", + "scheme": "esco", + "prefLabel": "management skills" + }, + { + "competency_ref": "esco:S4.0.1", + "scheme": "esco", + "prefLabel": "managing activities, resources, requirements" + }, + { + "competency_ref": "sfia:PROD", + "scheme": "sfia", + "prefLabel": "Product management" + }, + { + "competency_ref": "sfia:RLMT", + "scheme": "sfia", + "prefLabel": "Stakeholder relationship management" + }, + { + "competency_ref": "onet:11-2021.00", + "scheme": "onet", + "prefLabel": "Marketing Managers" + }, + { + "competency_ref": "wef:leadership-social-influence", + "scheme": "wef", + "prefLabel": "Leadership and social influence" + }, + { + "competency_ref": "wef:analytical-thinking", + "scheme": "wef", + "prefLabel": "Analytical thinking" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4", + "scheme": "esco", + "prefLabel": "management skills" + }, + { + "competency_ref": "esco:S4.0.1", + "scheme": "esco", + "prefLabel": "managing activities, resources, requirements" + }, + { + "competency_ref": "sfia:PROD", + "scheme": "sfia", + "prefLabel": "Product management" + }, + { + "competency_ref": "sfia:RLMT", + "scheme": "sfia", + "prefLabel": "Stakeholder relationship management" + }, + { + "competency_ref": "onet:11-2021.00", + "scheme": "onet", + "prefLabel": "Marketing Managers" + }, + { + "competency_ref": "wef:leadership-social-influence", + "scheme": "wef", + "prefLabel": "Leadership and social influence" + }, + { + "competency_ref": "wef:analytical-thinking", + "scheme": "wef", + "prefLabel": "Analytical thinking" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.product_manager", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.product_manager.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.product_manager.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.product_manager", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/product_manager", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:2193273b6b3f084daa9ea494527b33ae", + "attestation_hash": "sha256:f7e76f47ab3549c62cc7a7dd587c64fdab0873bec7a6beda07562ab709ed1c3d" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/product_manager/v0-draft", + "embedding_model_ref": "klickd-embed-product_manager-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "product", + "discovery", + "roadmap", + "north_star", + "prioritisation" + ], + "entity_classes": [ + "esco", + "sfia", + "onet" + ], + "priority": "planning_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "roadmap_external_commit", + "skip_evidence_for_feature_decision", + "pricing_change_write" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "skip_evidence_for_feature_decision" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "roadmap-commit", + "action_class": "roadmap_external_commit", + "level": "confirm", + "reason": "Roadmap commitments to external stakeholders are hard to retract." + }, + { + "id": "feature-cut-on-evidence-skip", + "action_class": "skip_evidence_for_feature_decision", + "level": "block", + "reason": "Cutting or pursuing a feature without evidence is blocked; decisions must cite a research artefact." + }, + { + "id": "pricing-change", + "action_class": "pricing_change_write", + "level": "confirm", + "reason": "Pricing-change writes require explicit confirmation." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/product_manager are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/project-operator.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/project-operator.klickd new file mode 100644 index 0000000..2b8456d --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/project-operator.klickd @@ -0,0 +1,356 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "professional", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B14). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/project_operator", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b14", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/project_operator", + "frameworks": [ + "esco", + "wef", + "onet" + ], + "competency_ids": [ + "esco:S4.1", + "esco:S4.1.1", + "wef:resilience-stress-tolerance", + "wef:leadership-social-influence", + "onet:11-3071.04" + ], + "gate_summaries": [ + { + "id": "cross-org-stakeholder", + "level": "confirm" + }, + { + "id": "exit-condition-violation", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/work", + "x.klickd/mission" + ], + "target_user": "Senior operator running multi-stakeholder projects. Risk register, dependency tracking, escalation discipline, exit-condition declaration.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "wef", + "version": "2023" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.1", + "scheme": "esco", + "prefLabel": "project management" + }, + { + "competency_ref": "esco:S4.1.1", + "scheme": "esco", + "prefLabel": "risk management" + }, + { + "competency_ref": "wef:resilience-stress-tolerance", + "scheme": "wef", + "prefLabel": "Resilience, stress tolerance and flexibility" + }, + { + "competency_ref": "wef:leadership-social-influence", + "scheme": "wef", + "prefLabel": "Leadership and social influence" + }, + { + "competency_ref": "onet:11-3071.04", + "scheme": "onet", + "prefLabel": "Supply Chain Managers" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4.1", + "scheme": "esco", + "prefLabel": "project management" + }, + { + "competency_ref": "esco:S4.1.1", + "scheme": "esco", + "prefLabel": "risk management" + }, + { + "competency_ref": "wef:resilience-stress-tolerance", + "scheme": "wef", + "prefLabel": "Resilience, stress tolerance and flexibility" + }, + { + "competency_ref": "wef:leadership-social-influence", + "scheme": "wef", + "prefLabel": "Leadership and social influence" + }, + { + "competency_ref": "onet:11-3071.04", + "scheme": "onet", + "prefLabel": "Supply Chain Managers" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.project_operator", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.project_operator.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.project_operator.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.project_operator", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/project_operator", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:5653e1713ca9758d2ec943e0552b03eb", + "attestation_hash": "sha256:7b638d18a86cc17e2dc513d55876fa37ef6cddab2f79ea7c49909aa5fcadd971" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/project_operator/v0-draft", + "embedding_model_ref": "klickd-embed-project_operator-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "project", + "schedule", + "raci", + "risk_register", + "milestone" + ], + "entity_classes": [ + "esco", + "sfia" + ], + "priority": "delivery_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "cross_org_stakeholder_write", + "timeline_change_violates_exit_condition" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "timeline_change_violates_exit_condition" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "cross-org-stakeholder", + "action_class": "cross_org_stakeholder_write", + "level": "confirm", + "reason": "Cross-org stakeholder writes require explicit confirmation." + }, + { + "id": "exit-condition-violation", + "action_class": "timeline_change_violates_exit_condition", + "level": "block", + "reason": "Timeline changes that violate an exit condition blocked; floor not lowerable." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/project_operator are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/release-engineer.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/release-engineer.klickd new file mode 100644 index 0000000..9932e70 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/release-engineer.klickd @@ -0,0 +1,421 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "software_engineering", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B4). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/release_engineer", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b4", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/release_engineer", + "frameworks": [ + "esco", + "sfia", + "nice", + "cis" + ], + "competency_ids": [ + "esco:S5.7", + "sfia:RELM", + "sfia:CFMG", + "sfia:PORT", + "nice:software-development", + "nice:supply-chain-risk-management", + "cis:control-2", + "cis:control-11" + ], + "gate_summaries": [ + { + "id": "production-release", + "level": "confirm" + }, + { + "id": "artefact-signing-disable", + "level": "block" + }, + { + "id": "sbom-emission-disable", + "level": "block" + }, + { + "id": "rollback-path-undeclared", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/coding", + "x.klickd/security" + ], + "target_user": "Release engineer / build owner. Supply-chain hygiene, SBOM, reproducible builds, signing, rollback discipline.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "nice", + "version": "r1", + "iri_prefix": "https://niccs.cisa.gov/workforce-development/nice-framework/", + "canonical_url": "https://niccs.cisa.gov/workforce-development/nice-framework" + }, + { + "scheme": "cis", + "version": "v8", + "iri_prefix": "https://www.cisecurity.org/controls/v8/", + "canonical_url": "https://www.cisecurity.org/controls/cis-controls-list" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "sfia", + "version": "8" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S5.7", + "scheme": "esco", + "prefLabel": "software deployment" + }, + { + "competency_ref": "sfia:RELM", + "scheme": "sfia", + "prefLabel": "Release management" + }, + { + "competency_ref": "sfia:CFMG", + "scheme": "sfia", + "prefLabel": "Configuration management" + }, + { + "competency_ref": "sfia:PORT", + "scheme": "sfia", + "prefLabel": "Porting/software configuration" + }, + { + "competency_ref": "nice:software-development", + "scheme": "nice", + "prefLabel": "Software Development" + }, + { + "competency_ref": "nice:supply-chain-risk-management", + "scheme": "nice", + "prefLabel": "Supply Chain Risk Management" + }, + { + "competency_ref": "cis:control-2", + "scheme": "cis", + "prefLabel": "Inventory and Control of Software Assets" + }, + { + "competency_ref": "cis:control-11", + "scheme": "cis", + "prefLabel": "Data Recovery" + } + ], + "competencies": [ + { + "competency_ref": "esco:S5.7", + "scheme": "esco", + "prefLabel": "software deployment" + }, + { + "competency_ref": "sfia:RELM", + "scheme": "sfia", + "prefLabel": "Release management" + }, + { + "competency_ref": "sfia:CFMG", + "scheme": "sfia", + "prefLabel": "Configuration management" + }, + { + "competency_ref": "sfia:PORT", + "scheme": "sfia", + "prefLabel": "Porting/software configuration" + }, + { + "competency_ref": "nice:software-development", + "scheme": "nice", + "prefLabel": "Software Development" + }, + { + "competency_ref": "nice:supply-chain-risk-management", + "scheme": "nice", + "prefLabel": "Supply Chain Risk Management" + }, + { + "competency_ref": "cis:control-2", + "scheme": "cis", + "prefLabel": "Inventory and Control of Software Assets" + }, + { + "competency_ref": "cis:control-11", + "scheme": "cis", + "prefLabel": "Data Recovery" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.release_engineer", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.release_engineer.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.release_engineer.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.release_engineer", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/release_engineer", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:06092cdae084b1163250b48f9b63f265", + "attestation_hash": "sha256:d93ffe806ac0d7349759bcab35b148ced122f61dbe8bab927c892314fc46f093" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/release_engineer/v0-draft", + "embedding_model_ref": "klickd-embed-release_engineer-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "release", + "sbom", + "sign", + "rollback", + "supply_chain" + ], + "entity_classes": [ + "esco", + "sfia", + "nice" + ], + "priority": "ops_operation", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "production_release", + "disable_artefact_signing", + "disable_sbom_emission", + "release_without_rollback_path" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "disable_artefact_signing", + "disable_sbom_emission", + "release_without_rollback_path" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "production-release", + "action_class": "production_release", + "level": "confirm", + "reason": "Production releases require explicit confirmation." + }, + { + "id": "artefact-signing-disable", + "action_class": "disable_artefact_signing", + "level": "block", + "reason": "Artefact signing disables blocked; floor not lowerable." + }, + { + "id": "sbom-emission-disable", + "action_class": "disable_sbom_emission", + "level": "block", + "reason": "SBOM emission disables blocked; floor not lowerable." + }, + { + "id": "rollback-path-undeclared", + "action_class": "release_without_rollback_path", + "level": "block", + "reason": "Releases without declared rollback path blocked." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/release_engineer are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/rights-guard.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/rights-guard.klickd new file mode 100644 index 0000000..75bc836 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/rights-guard.klickd @@ -0,0 +1,333 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "legal", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B18). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/rights_guard", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b18", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/rights_guard", + "frameworks": [ + "esco" + ], + "competency_ids": [ + "esco:S4.6", + "esco:S4.6.5", + "esco:S1.0.1" + ], + "gate_summaries": [ + { + "id": "licence-classification", + "level": "confirm" + }, + { + "id": "commercial-redistribution", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/legal", + "x.klickd/creator" + ], + "target_user": "Rights / licensing manager. IP / copyright literacy, licence-compatibility analysis, attribution discipline, DMCA / EU Copyright Directive Art. 17 awareness.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + } + ], + "citation_only_references": [ + { + "id": "eu-copyright-2019-790", + "ref": "EU Copyright Directive 2019/790", + "url": "https://eur-lex.europa.eu/eli/dir/2019/790/oj" + }, + { + "id": "berne", + "ref": "Berne Convention", + "url": "https://www.wipo.int/treaties/en/ip/berne/" + }, + { + "id": "cc-4-0", + "ref": "Creative Commons 4.0", + "url": "https://creativecommons.org/licenses/by/4.0/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S4.6.5", + "scheme": "esco", + "prefLabel": "intellectual property law" + }, + { + "competency_ref": "esco:S1.0.1", + "scheme": "esco", + "prefLabel": "rights management" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "esco:S4.6.5", + "scheme": "esco", + "prefLabel": "intellectual property law" + }, + { + "competency_ref": "esco:S1.0.1", + "scheme": "esco", + "prefLabel": "rights management" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.rights_guard", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.rights_guard.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.rights_guard.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.rights_guard", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/rights_guard", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:9191180e1dc7e6dcd5ec66769424ae0c", + "attestation_hash": "sha256:4ccf40adac1975979b6bb7b046cf3851cb4cbc2842b3fbda5a146365706699a0" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/rights_guard/v0-draft", + "embedding_model_ref": "klickd-embed-rights_guard-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 5, + "max_facts_per_turn": 7, + "freshness_weighting": "none", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "rights", + "copyright", + "moral_rights", + "license", + "takedown" + ], + "entity_classes": [ + "esco", + "eu_law_ref" + ], + "priority": "rights_lookup", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "licence_classification_write", + "commercial_redistribution_decision" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "commercial_redistribution_decision" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "licence-classification", + "action_class": "licence_classification_write", + "level": "confirm", + "reason": "Licence classification writes require explicit confirmation." + }, + { + "id": "commercial-redistribution", + "action_class": "commercial_redistribution_decision", + "level": "block", + "reason": "Commercial redistribution decisions require qualified IP counsel; floor not lowerable." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/rights_guard are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/sales-operator.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/sales-operator.klickd new file mode 100644 index 0000000..47eb52a --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/sales-operator.klickd @@ -0,0 +1,382 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "sales", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B26). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/sales_operator", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b26", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/sales_operator", + "frameworks": [ + "esco", + "onet", + "wef", + "lifecomp" + ], + "competency_ids": [ + "esco:S3", + "esco:S4.0.1", + "onet:41-3091.00", + "onet:41-4011.00", + "wef:leadership-social-influence", + "lifecomp:S1" + ], + "gate_summaries": [ + { + "id": "outbound-cold-list", + "level": "block" + }, + { + "id": "claim-without-evidence", + "level": "block" + }, + { + "id": "discount-floor-override", + "level": "confirm" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1150, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/work" + ], + "target_user": "B2B / SaaS sales operator running discovery, qualification, demo, proposal, close. CRM discipline, claim grounding, no-overpromise discipline. Distinct from marketing.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + }, + { + "scheme": "lifecomp", + "version": "2020", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/lifecomp/2020/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/lifecomp_en" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S3", + "scheme": "esco", + "prefLabel": "communicating, collaborating, advising, mediating" + }, + { + "competency_ref": "esco:S4.0.1", + "scheme": "esco", + "prefLabel": "managing activities, resources, requirements" + }, + { + "competency_ref": "onet:41-3091.00", + "scheme": "onet", + "prefLabel": "Sales Representatives of Services" + }, + { + "competency_ref": "onet:41-4011.00", + "scheme": "onet", + "prefLabel": "Sales Representatives, Wholesale and Manufacturing — Technical and Scientific Products" + }, + { + "competency_ref": "wef:leadership-social-influence", + "scheme": "wef", + "prefLabel": "Leadership and social influence" + }, + { + "competency_ref": "lifecomp:S1", + "scheme": "lifecomp", + "prefLabel": "Empathy" + } + ], + "competencies": [ + { + "competency_ref": "esco:S3", + "scheme": "esco", + "prefLabel": "communicating, collaborating, advising, mediating" + }, + { + "competency_ref": "esco:S4.0.1", + "scheme": "esco", + "prefLabel": "managing activities, resources, requirements" + }, + { + "competency_ref": "onet:41-3091.00", + "scheme": "onet", + "prefLabel": "Sales Representatives of Services" + }, + { + "competency_ref": "onet:41-4011.00", + "scheme": "onet", + "prefLabel": "Sales Representatives, Wholesale and Manufacturing — Technical and Scientific Products" + }, + { + "competency_ref": "wef:leadership-social-influence", + "scheme": "wef", + "prefLabel": "Leadership and social influence" + }, + { + "competency_ref": "lifecomp:S1", + "scheme": "lifecomp", + "prefLabel": "Empathy" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/5", + "level_label": "EQF level 5", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.sales_operator", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.sales_operator.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.sales_operator.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.sales_operator", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/sales_operator", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:af40c4a4d7e203c26c71eb0b1a02b57d", + "attestation_hash": "sha256:22649c84a643dc69344bd0650492aa096c378e4da5bf490fcbfedcff244a349b" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/sales_operator/v0-draft", + "embedding_model_ref": "klickd-embed-sales_operator-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "sales", + "pipeline", + "discovery_call", + "objection", + "forecast" + ], + "entity_classes": [ + "esco", + "sfia", + "onet" + ], + "priority": "sales_operation", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "cold_outbound_to_unconsented_list", + "product_claim_without_evidence", + "discount_floor_override" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "cold_outbound_to_unconsented_list", + "product_claim_without_evidence" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "outbound-cold-list", + "action_class": "cold_outbound_to_unconsented_list", + "level": "block", + "reason": "Cold outbound to a list without lawful basis is blocked under GDPR/CAN-SPAM compliance." + }, + { + "id": "claim-without-evidence", + "action_class": "product_claim_without_evidence", + "level": "block", + "reason": "Product claims to a prospect without an evidence pointer are blocked." + }, + { + "id": "discount-floor-override", + "action_class": "discount_floor_override", + "level": "confirm", + "reason": "Discount-floor overrides require explicit confirmation." + } + ] + }, + "router_cost": { + "tokens_estimate": 1150, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/sales_operator are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/second-brain.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/second-brain.klickd new file mode 100644 index 0000000..3b2468f --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/second-brain.klickd @@ -0,0 +1,360 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "research", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B12). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/second_brain", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b12", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/second_brain", + "frameworks": [ + "esco", + "digcomp", + "lifecomp" + ], + "competency_ids": [ + "esco:S2.0", + "esco:S2.4", + "digcomp:1.3", + "digcomp:3.3", + "lifecomp:L3" + ], + "gate_summaries": [ + { + "id": "notes-export-third-party", + "level": "confirm" + }, + { + "id": "inline-note-content", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/research" + ], + "target_user": "Knowledge-worker carrier running a long-running notes / PKM practice. Capture discipline, citation hygiene, atomic notes, link integrity. Carries PKM state, not the notes.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + }, + { + "scheme": "lifecomp", + "version": "2020", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/lifecomp/2020/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/lifecomp_en" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "digcomp", + "version": "2.2" + } + ], + "transversal_refs": [ + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "esco:S2.4", + "scheme": "esco", + "prefLabel": "knowledge management" + }, + { + "competency_ref": "digcomp:1.3", + "scheme": "digcomp", + "prefLabel": "Managing data, information and digital content" + }, + { + "competency_ref": "digcomp:3.3", + "scheme": "digcomp", + "prefLabel": "Copyright and licences" + }, + { + "competency_ref": "lifecomp:L3", + "scheme": "lifecomp", + "prefLabel": "Managing learning" + } + ], + "competencies": [ + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "esco:S2.4", + "scheme": "esco", + "prefLabel": "knowledge management" + }, + { + "competency_ref": "digcomp:1.3", + "scheme": "digcomp", + "prefLabel": "Managing data, information and digital content" + }, + { + "competency_ref": "digcomp:3.3", + "scheme": "digcomp", + "prefLabel": "Copyright and licences" + }, + { + "competency_ref": "lifecomp:L3", + "scheme": "lifecomp", + "prefLabel": "Managing learning" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.second_brain", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.second_brain.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.second_brain.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.second_brain", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/second_brain", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:183a074c715748ba750cee6cbf5729bf", + "attestation_hash": "sha256:8156ab6b91c069dcd88d9563877b4a0d3b2937a75556fcd37dd1ead28f7d40d0" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/second_brain/v0-draft", + "embedding_model_ref": "klickd-embed-second_brain-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 8, + "max_facts_per_turn": 10, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "note", + "atomic_note", + "link", + "spaced_review", + "weekly_review" + ], + "entity_classes": [ + "esco", + "lifecomp" + ], + "priority": "personal_research", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "notes_export_to_third_party", + "inline_note_content" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "inline_note_content" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "notes-export-third-party", + "action_class": "notes_export_to_third_party", + "level": "confirm", + "reason": "Exporting notes to a third party requires explicit confirmation." + }, + { + "id": "inline-note-content", + "action_class": "inline_note_content", + "level": "block", + "reason": "Inline note content blocked; pack carries pointers only." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/second_brain are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/security-incident-response.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/security-incident-response.klickd new file mode 100644 index 0000000..400ebb3 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/security-incident-response.klickd @@ -0,0 +1,386 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "security", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B25). Pro tier; compact_index loading strategy declared. Disambiguation: B25 owns the incident lifecycle (detect / triage / contain / eradicate / recover / lessons-learned) on conventional infrastructure; B1 (llm_agent_security) owns LLM/agent-system prompt-injection and tool-sandbox literacy at design + eval time; B3 (identity_access_management) owns IAM / MFA / session hygiene at operate time. Composition is explicit via parent_packs; this pack MUST NOT lower any default from x.klickd/security or from B1/B3 when they are also loaded." + }, + "x_klickd_pack": { + "pack": "x.klickd/security_incident_response", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b25", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/security_incident_response", + "frameworks": [ + "nice", + "enisa", + "cis", + "esco" + ], + "competency_ids": [ + "nice:PR-CDA", + "nice:PR-INF", + "enisa:CIR", + "cis:17", + "cis:8", + "esco:S5.6.3" + ], + "gate_summaries": [ + { + "id": "public-disclosure-bypass", + "level": "block" + }, + { + "id": "evidence-chain-break", + "level": "block" + }, + { + "id": "containment-action", + "level": "confirm" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1300, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/security" + ], + "target_user": "Security incident responder running detection, triage, containment, eradication, recovery, and lessons-learned. Distinct from identity_access_management (B3) and llm_agent_security (B1) by incident-time scope.", + "frameworks": [ + { + "scheme": "nice", + "version": "NIST SP 800-181r1", + "iri_prefix": "https://csrc.nist.gov/projects/cybersecurity-workforce-framework/", + "canonical_url": "https://niccs.cisa.gov/workforce-development/nice-framework" + }, + { + "scheme": "enisa", + "version": "ECSF 1.0", + "iri_prefix": "https://www.enisa.europa.eu/topics/skills-and-competences/ecsf/", + "canonical_url": "https://www.enisa.europa.eu/topics/skills-and-competences/ecsf" + }, + { + "scheme": "cis", + "version": "v8", + "iri_prefix": "https://www.cisecurity.org/controls/v8/", + "canonical_url": "https://www.cisecurity.org/controls/v8" + }, + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "nice", + "version": "NIST SP 800-181r1" + }, + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "nice:PR-CDA", + "scheme": "nice", + "prefLabel": "Protect and Defend — Cyber Defense Analysis" + }, + { + "competency_ref": "nice:PR-INF", + "scheme": "nice", + "prefLabel": "Protect and Defend — Incident Response" + }, + { + "competency_ref": "enisa:CIR", + "scheme": "enisa", + "prefLabel": "Cyber Incident Responder" + }, + { + "competency_ref": "cis:17", + "scheme": "cis", + "prefLabel": "Incident Response Management" + }, + { + "competency_ref": "cis:8", + "scheme": "cis", + "prefLabel": "Audit Log Management" + }, + { + "competency_ref": "esco:S5.6.3", + "scheme": "esco", + "prefLabel": "addressing problems" + } + ], + "competencies": [ + { + "competency_ref": "nice:PR-CDA", + "scheme": "nice", + "prefLabel": "Protect and Defend — Cyber Defense Analysis" + }, + { + "competency_ref": "nice:PR-INF", + "scheme": "nice", + "prefLabel": "Protect and Defend — Incident Response" + }, + { + "competency_ref": "enisa:CIR", + "scheme": "enisa", + "prefLabel": "Cyber Incident Responder" + }, + { + "competency_ref": "cis:17", + "scheme": "cis", + "prefLabel": "Incident Response Management" + }, + { + "competency_ref": "cis:8", + "scheme": "cis", + "prefLabel": "Audit Log Management" + }, + { + "competency_ref": "esco:S5.6.3", + "scheme": "esco", + "prefLabel": "addressing problems" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.security_incident_response", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.security_incident_response.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.security_incident_response.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.security_incident_response", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/security_incident_response", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:bd1fdd7cb77fb8abaa6b7833cc28f1fc", + "attestation_hash": "sha256:d2de3b1e04f88f863e8cc9e4898c67b3c5e82464584ade2c16af145643cc1bbd" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/security_incident_response/v0-draft", + "embedding_model_ref": "klickd-embed-security_incident_response-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 7, + "max_facts_per_turn": 9, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "incident", + "containment", + "forensics", + "post_mortem", + "ttp" + ], + "entity_classes": [ + "esco", + "nice", + "enisa_ref" + ], + "priority": "security_operation", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "public_disclosure_without_legal", + "evidence_chain_of_custody_break", + "containment_action_write" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "public_disclosure_without_legal", + "evidence_chain_of_custody_break" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "public-disclosure-bypass", + "action_class": "public_disclosure_without_legal", + "level": "block", + "reason": "Public incident disclosure without legal/counsel sign-off is blocked." + }, + { + "id": "evidence-chain-break", + "action_class": "evidence_chain_of_custody_break", + "level": "block", + "reason": "Breaking chain-of-custody on incident evidence is blocked." + }, + { + "id": "containment-action", + "action_class": "containment_action_write", + "level": "confirm", + "reason": "Containment actions (isolate host, revoke key) require explicit confirmation." + } + ] + }, + "router_cost": { + "tokens_estimate": 1300, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/security_incident_response are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/social-literacy.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/social-literacy.klickd new file mode 100644 index 0000000..02e1262 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/social-literacy.klickd @@ -0,0 +1,313 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "media_literacy", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "lite", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact. Lot A social-literacy pack composing x.klickd/user.", + "renamed_from": "social.klickd" + }, + "x_klickd_pack": { + "pack": "x.klickd/social_literacy", + "pack_version": "0.1.0-candidate-lite", + "spec_ref": "x.klickd/v4.1#a9", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "lite", + "parent_packs": [ + "x.klickd/user" + ], + "target_user": "Carrier with active social-media use, interested in critical literacy, attention hygiene, disinformation resistance. Not growth-hacking; not marketing.", + "frameworks": [ + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + }, + { + "scheme": "lifecomp", + "version": "2020", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/lifecomp/2020/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/lifecomp_en" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "digcomp", + "version": "2.2" + }, + { + "scheme": "lifecomp", + "version": "2020" + } + ], + "transversal_refs": [ + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "lifecomp:P1", + "scheme": "lifecomp", + "prefLabel": "Self-regulation" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "digcomp:2.2", + "scheme": "digcomp", + "prefLabel": "Sharing through digital technologies" + }, + { + "competency_ref": "digcomp:2.4", + "scheme": "digcomp", + "prefLabel": "Collaborating through digital technologies" + }, + { + "competency_ref": "digcomp:4.3", + "scheme": "digcomp", + "prefLabel": "Protecting health and well-being" + }, + { + "competency_ref": "lifecomp:S1", + "scheme": "lifecomp", + "prefLabel": "Empathy" + }, + { + "competency_ref": "wef:active-learning", + "scheme": "wef", + "prefLabel": "Active learning and learning strategies" + } + ], + "competencies": [ + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "digcomp:2.2", + "scheme": "digcomp", + "prefLabel": "Sharing through digital technologies" + }, + { + "competency_ref": "digcomp:4.3", + "scheme": "digcomp", + "prefLabel": "Protecting health and well-being" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/4", + "level_label": "EQF level 4", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.social_literacy", + "memory_segments": [ + { + "id": "shares", + "scope": "memory.x_klickd.social_literacy.shares", + "policy": "pointer_only_summary" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.social_literacy", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/social_literacy", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:377a2c4e666e706217a2ce388bee306b", + "attestation_hash": "sha256:54a90718642ca3ebee3cc139983c53cc3f69b0051f2222bd0baa511b49de581e" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/social_literacy/v0-draft", + "embedding_model_ref": "klickd-embed-social_literacy-2026-v0-placeholder", + "dim": 384, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 5, + "max_facts_per_turn": 6, + "freshness_weighting": "exponential_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "social_media", + "verification", + "disinformation", + "consent" + ], + "entity_classes": [ + "digcomp", + "lifecomp" + ], + "priority": "literacy_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "third_party_naming", + "minor_naming", + "factual_claim_share" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "minor_naming" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier_with_guardian_if_minor", + "agent_role": "advisory", + "escalation": "guardian_if_minor" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "third-party-naming", + "action_class": "third_party_naming", + "level": "confirm", + "reason": "Naming a third party in a public post requires confirmation." + }, + { + "id": "minor-naming", + "action_class": "minor_naming", + "level": "block", + "reason": "Naming a minor in a public post is blocked by default; floor not lowerable." + }, + { + "id": "factual-claim-share", + "action_class": "factual_claim_share", + "level": "confirm", + "reason": "Sharing a factual claim requires grounding (RFC-002 §8b)." + } + ] + }, + "router_cost": { + "tokens_estimate": 720, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into DigComp, LifeComp, or WEF.", + "Minor-naming gate is block and non-lowerable.", + "Pointer-only evidence; no inline post bodies of others.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == lite and tokens_estimate <= 900" + ], + "review": [ + "Reviewer verifies factual-claim-share gate has RFC-002 §8b grounding shape.", + "Reviewer verifies minor-naming block is preserved." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/streaming-creator.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/streaming-creator.klickd new file mode 100644 index 0000000..764d2ea --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/streaming-creator.klickd @@ -0,0 +1,302 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "creative", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "lite", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact. Lot A entry-tier streaming-creator pack composing x.klickd/creator (P1).", + "renamed_from": "streamer-lite.klickd" + }, + "x_klickd_pack": { + "pack": "x.klickd/streaming_creator", + "pack_version": "0.1.0-candidate-lite", + "spec_ref": "x.klickd/v4.1#a11", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "lite", + "parent_packs": [ + "x.klickd/user", + "x.klickd/creator" + ], + "target_user": "Live-streaming carrier (gaming, IRL, study-with-me). Entry tier; not a full broadcasting professional.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "digcomp", + "version": "2.2" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S1.5", + "scheme": "esco", + "prefLabel": "performing artistic work" + }, + { + "competency_ref": "digcomp:4.3", + "scheme": "digcomp", + "prefLabel": "Protecting health and well-being" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S1.5", + "scheme": "esco", + "prefLabel": "performing artistic work" + }, + { + "competency_ref": "digcomp:2.2", + "scheme": "digcomp", + "prefLabel": "Sharing through digital technologies" + }, + { + "competency_ref": "digcomp:4.3", + "scheme": "digcomp", + "prefLabel": "Protecting health and well-being" + }, + { + "competency_ref": "digcomp:4.2", + "scheme": "digcomp", + "prefLabel": "Protecting personal data and privacy" + } + ], + "competencies": [ + { + "competency_ref": "esco:S1.5", + "scheme": "esco", + "prefLabel": "performing artistic work" + }, + { + "competency_ref": "digcomp:4.2", + "scheme": "digcomp", + "prefLabel": "Protecting personal data and privacy" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/4", + "level_label": "EQF level 4", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.streaming_creator", + "memory_segments": [ + { + "id": "clips", + "scope": "memory.x_klickd.streaming_creator.clips", + "policy": "pointer_only_no_third_party_likeness" + }, + { + "id": "guests", + "scope": "memory.x_klickd.streaming_creator.guests", + "policy": "explicit_consent_required" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.streaming_creator", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/streaming_creator", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:c40c9f7147948a03a2b5f5cb7202e39d", + "attestation_hash": "sha256:bd94b552a2fba17b59afc75c3cdfc23f0a47f16b03cb8bcd2609dd65ec0c8f59" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/streaming_creator/v0-draft", + "embedding_model_ref": "klickd-embed-streaming_creator-2026-v0-placeholder", + "dim": 384, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 5, + "max_facts_per_turn": 6, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "livestream", + "creator_economy", + "monetisation", + "compliance" + ], + "entity_classes": [ + "esco", + "digcomp" + ], + "priority": "creator_practice", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "media_profile_compose_ref": "rfc-001#media_profile", + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "location_reveal", + "minor_on_stream", + "chat_driven_dare" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "minor_on_stream", + "chat_driven_dare_unsafe" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier_with_guardian_if_minor", + "agent_role": "advisory", + "escalation": "guardian_if_minor" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "location-reveal", + "action_class": "location_reveal", + "level": "confirm", + "reason": "Revealing real-world location requires explicit confirmation." + }, + { + "id": "minor-on-stream", + "action_class": "minor_on_stream", + "level": "block", + "reason": "Minors on stream require guardian consent; floor not lowerable." + }, + { + "id": "chat-driven-dare", + "action_class": "chat_driven_dare_unsafe", + "level": "block", + "reason": "Chat-driven unsafe dares blocked by default; floor not lowerable." + } + ] + }, + "router_cost": { + "tokens_estimate": 780, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into ESCO or DigComp.", + "Minor-on-stream and unsafe-dare gates are block and non-lowerable.", + "RFC-001 media_profile composed by reference; not redefined inline.", + "Pointer-only evidence; no inline clips.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == lite and tokens_estimate <= 900", + "block on minor_on_stream present" + ], + "review": [ + "Reviewer verifies guest-consent shape is present.", + "Reviewer verifies media_profile_compose_ref points to RFC-001." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/sustainability-analyst.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/sustainability-analyst.klickd new file mode 100644 index 0000000..48f82b7 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/sustainability-analyst.klickd @@ -0,0 +1,404 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "sustainability", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B32). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/sustainability_analyst", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b32", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/sustainability_analyst", + "frameworks": [ + "esco", + "onet", + "wef" + ], + "competency_ids": [ + "esco:S4.8", + "esco:S2.0", + "esco:S4.0.2", + "onet:13-1199.05", + "onet:19-2041.03", + "wef:environmental-stewardship", + "wef:analytical-thinking" + ], + "gate_summaries": [ + { + "id": "scope-3-omission", + "level": "block" + }, + { + "id": "external-disclosure-claim", + "level": "confirm" + }, + { + "id": "greenwashing-language", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/research", + "x.klickd/legal" + ], + "target_user": "Sustainability / ESG analyst running emissions accounting, CSRD/ESRS readiness, supplier-questionnaire analysis, materiality assessments. NOT certified auditor.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + } + ], + "citation_only_references": [ + { + "id": "csrd", + "ref": "Corporate Sustainability Reporting Directive (Directive (EU) 2022/2464)", + "url": "https://eur-lex.europa.eu/eli/dir/2022/2464/oj" + }, + { + "id": "esrs", + "ref": "European Sustainability Reporting Standards (EFRAG)", + "url": "https://www.efrag.org/lab6" + }, + { + "id": "ghg-protocol", + "ref": "GHG Protocol Corporate Standard", + "url": "https://ghgprotocol.org/corporate-standard" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S4.8", + "scheme": "esco", + "prefLabel": "sustainability" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "esco:S4.0.2", + "scheme": "esco", + "prefLabel": "controlling, monitoring activities, resources" + }, + { + "competency_ref": "onet:13-1199.05", + "scheme": "onet", + "prefLabel": "Sustainability Specialists" + }, + { + "competency_ref": "onet:19-2041.03", + "scheme": "onet", + "prefLabel": "Industrial Ecologists" + }, + { + "competency_ref": "wef:environmental-stewardship", + "scheme": "wef", + "prefLabel": "Environmental stewardship" + }, + { + "competency_ref": "wef:analytical-thinking", + "scheme": "wef", + "prefLabel": "Analytical thinking" + } + ], + "competencies": [ + { + "competency_ref": "esco:S4.8", + "scheme": "esco", + "prefLabel": "sustainability" + }, + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "esco:S4.0.2", + "scheme": "esco", + "prefLabel": "controlling, monitoring activities, resources" + }, + { + "competency_ref": "onet:13-1199.05", + "scheme": "onet", + "prefLabel": "Sustainability Specialists" + }, + { + "competency_ref": "onet:19-2041.03", + "scheme": "onet", + "prefLabel": "Industrial Ecologists" + }, + { + "competency_ref": "wef:environmental-stewardship", + "scheme": "wef", + "prefLabel": "Environmental stewardship" + }, + { + "competency_ref": "wef:analytical-thinking", + "scheme": "wef", + "prefLabel": "Analytical thinking" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.sustainability_analyst", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.sustainability_analyst.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.sustainability_analyst.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.sustainability_analyst", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/sustainability_analyst", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:97a36c2a5d80fcc77658b203a3476b3f", + "attestation_hash": "sha256:607d018701c1500548c382519f7019758955154ebf501eb77cbadc977523d909" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/sustainability_analyst/v0-draft", + "embedding_model_ref": "klickd-embed-sustainability_analyst-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "sustainability", + "csrd", + "scope1", + "scope2", + "scope3", + "esg" + ], + "entity_classes": [ + "esco", + "eu_law_ref" + ], + "priority": "analytic_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "scope_three_material_omission", + "external_sustainability_claim", + "unsubstantiated_environmental_claim" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "scope_three_material_omission", + "unsubstantiated_environmental_claim" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "scope-3-omission", + "action_class": "scope_three_material_omission", + "level": "block", + "reason": "Omitting material Scope 3 categories from disclosed emissions is blocked." + }, + { + "id": "external-disclosure-claim", + "action_class": "external_sustainability_claim", + "level": "confirm", + "reason": "External sustainability claims require evidence and confirmation." + }, + { + "id": "greenwashing-language", + "action_class": "unsubstantiated_environmental_claim", + "level": "block", + "reason": "Unsubstantiated environmental claims (greenwashing) are blocked." + } + ] + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/sustainability_analyst are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/technical-writer.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/technical-writer.klickd new file mode 100644 index 0000000..3d88841 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/technical-writer.klickd @@ -0,0 +1,393 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "communication", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B30). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/technical_writer", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b30", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/technical_writer", + "frameworks": [ + "esco", + "sfia", + "onet", + "digcomp" + ], + "competency_ids": [ + "esco:S1.0", + "esco:S5.6", + "sfia:TECH", + "sfia:HCEV", + "onet:27-3042.00", + "digcomp:3.1", + "digcomp:3.3" + ], + "gate_summaries": [ + { + "id": "stale-source-of-truth", + "level": "block" + }, + { + "id": "third-party-attribution", + "level": "confirm" + }, + { + "id": "doc-licence-mismatch", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1100, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/coding", + "x.klickd/research" + ], + "target_user": "Technical writer producing API docs, runbooks, user guides, ADRs. Audience modelling, source-of-truth discipline, version-aware references.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://publications.jrc.ec.europa.eu/repository/handle/JRC128415/", + "canonical_url": "https://publications.jrc.ec.europa.eu/repository/handle/JRC128415" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "communication, collaboration and creativity" + }, + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT — software documentation" + }, + { + "competency_ref": "sfia:TECH", + "scheme": "sfia", + "prefLabel": "Technical specialism" + }, + { + "competency_ref": "sfia:HCEV", + "scheme": "sfia", + "prefLabel": "User experience evaluation" + }, + { + "competency_ref": "onet:27-3042.00", + "scheme": "onet", + "prefLabel": "Technical Writers" + }, + { + "competency_ref": "digcomp:3.1", + "scheme": "digcomp", + "prefLabel": "Developing digital content" + }, + { + "competency_ref": "digcomp:3.3", + "scheme": "digcomp", + "prefLabel": "Copyright and licences" + } + ], + "competencies": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "communication, collaboration and creativity" + }, + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT — software documentation" + }, + { + "competency_ref": "sfia:TECH", + "scheme": "sfia", + "prefLabel": "Technical specialism" + }, + { + "competency_ref": "sfia:HCEV", + "scheme": "sfia", + "prefLabel": "User experience evaluation" + }, + { + "competency_ref": "onet:27-3042.00", + "scheme": "onet", + "prefLabel": "Technical Writers" + }, + { + "competency_ref": "digcomp:3.1", + "scheme": "digcomp", + "prefLabel": "Developing digital content" + }, + { + "competency_ref": "digcomp:3.3", + "scheme": "digcomp", + "prefLabel": "Copyright and licences" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.technical_writer", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.technical_writer.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.technical_writer.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.technical_writer", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/technical_writer", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:83d00313bbf2182e1942229820f469a3", + "attestation_hash": "sha256:5ca5f4932b2353be4cf32250de2653e7affb934081ec4b48662bdea88993e291" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/technical_writer/v0-draft", + "embedding_model_ref": "klickd-embed-technical_writer-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "docs", + "style_guide", + "diataxis", + "release_notes", + "api_reference" + ], + "entity_classes": [ + "esco", + "sfia" + ], + "priority": "writing_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "publish_against_stale_source", + "third_party_attribution_write", + "doc_licence_mismatch" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "publish_against_stale_source", + "doc_licence_mismatch" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "stale-source-of-truth", + "action_class": "publish_against_stale_source", + "level": "block", + "reason": "Publishing docs that contradict the version-locked source-of-truth is blocked." + }, + { + "id": "third-party-attribution", + "action_class": "third_party_attribution_write", + "level": "confirm", + "reason": "Attributing a quoted statement to a third party requires confirmation." + }, + { + "id": "doc-licence-mismatch", + "action_class": "doc_licence_mismatch", + "level": "block", + "reason": "Publishing third-party content under a mismatched licence is blocked." + } + ] + }, + "router_cost": { + "tokens_estimate": 1100, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/technical_writer are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/trust-evidence.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/trust-evidence.klickd new file mode 100644 index 0000000..2152346 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/trust-evidence.klickd @@ -0,0 +1,364 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "trust_and_safety", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B5). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/trust_evidence", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b5", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/trust_evidence", + "frameworks": [ + "esco", + "digcomp" + ], + "competency_ids": [ + "esco:S2.0", + "esco:S2.5", + "esco:S4.6", + "digcomp:1.2", + "digcomp:1.3" + ], + "gate_summaries": [ + { + "id": "third-party-attribution", + "level": "confirm" + }, + { + "id": "data-subject-right-touch", + "level": "confirm" + }, + { + "id": "chain-of-custody-break", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/research" + ], + "target_user": "Trust & safety analyst / evidence-desk operator. Claim grounding, chain-of-custody, escalation discipline.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "digcomp", + "version": "2.2" + } + ], + "transversal_refs": [ + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "esco:S2.5", + "scheme": "esco", + "prefLabel": "investigating and reporting" + }, + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "digcomp:1.3", + "scheme": "digcomp", + "prefLabel": "Managing data, information and digital content" + } + ], + "competencies": [ + { + "competency_ref": "esco:S2.0", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "esco:S2.5", + "scheme": "esco", + "prefLabel": "investigating and reporting" + }, + { + "competency_ref": "esco:S4.6", + "scheme": "esco", + "prefLabel": "legal and compliance support" + }, + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information and digital content" + }, + { + "competency_ref": "digcomp:1.3", + "scheme": "digcomp", + "prefLabel": "Managing data, information and digital content" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.trust_evidence", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.trust_evidence.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.trust_evidence.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.trust_evidence", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/trust_evidence", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:5101c35112cd915e469e2a83714eb724", + "attestation_hash": "sha256:6e1fc58ba6754b45596f9d9241689ec61b599640d586eb737bd665b03bb67dc4" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/trust_evidence/v0-draft", + "embedding_model_ref": "klickd-embed-trust_evidence-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "trust", + "attestation", + "sbom", + "provenance", + "verification_artifact" + ], + "entity_classes": [ + "esco", + "nice" + ], + "priority": "evidence_handling", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "third_party_attributable_claim", + "data_subject_right_touch", + "chain_of_custody_break" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "chain_of_custody_break" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "third-party-attribution", + "action_class": "third_party_attributable_claim", + "level": "confirm", + "reason": "Claims attributable to a named third party require confirmation." + }, + { + "id": "data-subject-right-touch", + "action_class": "data_subject_right_touch", + "level": "confirm", + "reason": "Escalation to legal counsel required when touching a data-subject right." + }, + { + "id": "chain-of-custody-break", + "action_class": "chain_of_custody_break", + "level": "block", + "reason": "Chain-of-custody breaks blocked; floor not lowerable." + } + ] + }, + "router_cost": { + "tokens_estimate": 1250, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/trust_evidence are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/ux-researcher.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/ux-researcher.klickd new file mode 100644 index 0000000..c397895 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/ux-researcher.klickd @@ -0,0 +1,393 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "research", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B21). Pro tier; compact_index loading strategy declared." + }, + "x_klickd_pack": { + "pack": "x.klickd/ux_researcher", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b21", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies (mastery scales, evidence rules, framework subsets) lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/ux_researcher", + "frameworks": [ + "esco", + "sfia", + "onet", + "digcomp" + ], + "competency_ids": [ + "esco:S1.2", + "esco:S2", + "esco:S5.6", + "sfia:URCH", + "sfia:HCEV", + "onet:15-1255.00", + "digcomp:1.2" + ], + "gate_summaries": [ + { + "id": "participant-consent-skip", + "level": "block" + }, + { + "id": "participant-recontact", + "level": "confirm" + }, + { + "id": "raw-pii-export", + "level": "block" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/research" + ], + "target_user": "UX researcher running mixed-method discovery (interviews, usability testing, surveys, diary studies). Participant consent, bias mitigation, evidence-grounded reporting.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://publications.jrc.ec.europa.eu/repository/handle/JRC128415/", + "canonical_url": "https://publications.jrc.ec.europa.eu/repository/handle/JRC128415" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S1.2", + "scheme": "esco", + "prefLabel": "supporting interpersonal communication" + }, + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT — software analysis" + }, + { + "competency_ref": "sfia:URCH", + "scheme": "sfia", + "prefLabel": "User research" + }, + { + "competency_ref": "sfia:HCEV", + "scheme": "sfia", + "prefLabel": "User experience evaluation" + }, + { + "competency_ref": "onet:15-1255.00", + "scheme": "onet", + "prefLabel": "Web and Digital Interface Designers" + }, + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information, and digital content" + } + ], + "competencies": [ + { + "competency_ref": "esco:S1.2", + "scheme": "esco", + "prefLabel": "supporting interpersonal communication" + }, + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "esco:S5.6", + "scheme": "esco", + "prefLabel": "ICT — software analysis" + }, + { + "competency_ref": "sfia:URCH", + "scheme": "sfia", + "prefLabel": "User research" + }, + { + "competency_ref": "sfia:HCEV", + "scheme": "sfia", + "prefLabel": "User experience evaluation" + }, + { + "competency_ref": "onet:15-1255.00", + "scheme": "onet", + "prefLabel": "Web and Digital Interface Designers" + }, + { + "competency_ref": "digcomp:1.2", + "scheme": "digcomp", + "prefLabel": "Evaluating data, information, and digital content" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.ux_researcher", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.ux_researcher.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.ux_researcher.evidence", + "policy": "pointer_only_chain_of_custody" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.ux_researcher", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/ux_researcher", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:337382b228ec0470b2298961ba9c3cba", + "attestation_hash": "sha256:c63fed8809f03b22359f81345b144655f325d99ae7a0de7651b69af883e1f143" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/ux_researcher/v0-draft", + "embedding_model_ref": "klickd-embed-ux_researcher-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "ux_research", + "interview", + "usability_test", + "synthesis", + "jtbd" + ], + "entity_classes": [ + "esco", + "sfia", + "onet" + ], + "priority": "research_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "skip_participant_consent", + "participant_recontact_write", + "raw_pii_export" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "skip_participant_consent", + "raw_pii_export" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "participant-consent-skip", + "action_class": "skip_participant_consent", + "level": "block", + "reason": "Research without recorded participant consent is blocked." + }, + { + "id": "participant-recontact", + "action_class": "participant_recontact_write", + "level": "confirm", + "reason": "Re-contacting a participant requires explicit confirmation against consent terms." + }, + { + "id": "raw-pii-export", + "action_class": "raw_pii_export", + "level": "block", + "reason": "Exporting raw participant PII outside the research perimeter is blocked." + } + ] + }, + "router_cost": { + "tokens_estimate": 1200, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into an authoritative framework declared in frameworks[].", + "Citation-only references (where present) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block and stay block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline confidential or PII content.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parent packs are present without redefinition.", + "Reviewer verifies non_lowerable_floor matches the gate definitions.", + "Reviewer verifies citation-only references (if any) for x.klickd/ux_researcher are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/video-production-pipeline.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/video-production-pipeline.klickd new file mode 100644 index 0000000..0c27ab5 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/video-production-pipeline.klickd @@ -0,0 +1,554 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "creative", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "pro", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact (B19). Pro tier; compact_index loading strategy declared. Authored from a read-only audit of an open-source video pipeline (MoneyPrinterTurbo); no upstream code or assets bundled." + }, + "x_klickd_pack": { + "pack": "x.klickd/video_production_pipeline", + "pack_version": "0.1.0-candidate-pro", + "spec_ref": "x.klickd/v4.1#b19", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "pro", + "loading_strategy": { + "mode": "compact_index_plus_lazy_body", + "compact_index_in_prompt": true, + "full_body_on_demand": true, + "rationale": "Pro tier per x.klickd/v4.1 (Pro tier); full bodies lazy-loaded by decision_router (RFC-007)." + }, + "compact_index": { + "pack": "x.klickd/video_production_pipeline", + "frameworks": [ + "esco", + "sfia", + "digcomp", + "onet" + ], + "competency_ids": [ + "esco:S1.0", + "esco:S5.6.1", + "sfia:DESN", + "sfia:PROG", + "digcomp:3.1", + "digcomp:3.3", + "onet:27-3041.00" + ], + "gate_summaries": [ + { + "id": "auto-publish-social", + "level": "block" + }, + { + "id": "real-person-likeness-or-voice", + "level": "block" + }, + { + "id": "copyrighted-asset-use", + "level": "block" + }, + { + "id": "paid-api-spend-over-threshold", + "level": "confirm" + }, + { + "id": "product-performance-claim-without-evidence", + "level": "block" + }, + { + "id": "risky-provider-use", + "level": "block" + }, + { + "id": "stock-media-license-write", + "level": "confirm" + } + ], + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory" + }, + "router_cost": { + "tokens_estimate": 1300, + "baseline": "base_plus_one" + } + }, + "parent_packs": [ + "x.klickd/user", + "x.klickd/media_planner", + "x.klickd/creator", + "x.klickd/research", + "x.klickd/legal" + ], + "target_user": "Advanced creator / marketing engineer producing demo and marketing videos for a software product (e.g. a .klickd skill). Owns script, storyboard, shot list, voice-over, subtitles, render plan, provenance, rights, QA, benchmark reproducibility. Not a broadcast editor; not auto-publishing.", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "sfia", + "version": "8", + "iri_prefix": "https://sfia-online.org/en/sfia-8/", + "canonical_url": "https://sfia-online.org/en/sfia-8" + }, + { + "scheme": "digcomp", + "version": "2.2", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/digcomp/2.2/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/digcomp_en" + }, + { + "scheme": "onet", + "version": "28.0", + "iri_prefix": "https://www.onetonline.org/link/summary/", + "canonical_url": "https://www.onetonline.org/" + } + ], + "citation_only_references": [ + { + "id": "ffmpeg", + "ref": "FFmpeg multimedia framework", + "url": "https://ffmpeg.org/" + }, + { + "id": "srt", + "ref": "SubRip Text subtitle format", + "url": "https://en.wikipedia.org/wiki/SubRip" + }, + { + "id": "moneyprinterturbo", + "ref": "MoneyPrinterTurbo (read-only audit reference)", + "url": "https://github.com/harry0703/MoneyPrinterTurbo" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "digcomp", + "version": "2.2" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S2", + "scheme": "esco", + "prefLabel": "information skills" + }, + { + "competency_ref": "digcomp:3.1", + "scheme": "digcomp", + "prefLabel": "Developing digital content" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "creativity and innovation" + }, + { + "competency_ref": "esco:S5.6.1", + "scheme": "esco", + "prefLabel": "ICT software development" + }, + { + "competency_ref": "sfia:DESN", + "scheme": "sfia", + "prefLabel": "Systems design" + }, + { + "competency_ref": "sfia:PROG", + "scheme": "sfia", + "prefLabel": "Programming/software development" + }, + { + "competency_ref": "digcomp:3.1", + "scheme": "digcomp", + "prefLabel": "Developing digital content" + }, + { + "competency_ref": "digcomp:3.3", + "scheme": "digcomp", + "prefLabel": "Copyright and licences" + }, + { + "competency_ref": "onet:27-3041.00", + "scheme": "onet", + "prefLabel": "Editors" + } + ], + "competencies": [ + { + "competency_ref": "esco:S1.0", + "scheme": "esco", + "prefLabel": "creativity and innovation" + }, + { + "competency_ref": "esco:S5.6.1", + "scheme": "esco", + "prefLabel": "ICT software development" + }, + { + "competency_ref": "sfia:DESN", + "scheme": "sfia", + "prefLabel": "Systems design" + }, + { + "competency_ref": "sfia:PROG", + "scheme": "sfia", + "prefLabel": "Programming/software development" + }, + { + "competency_ref": "digcomp:3.1", + "scheme": "digcomp", + "prefLabel": "Developing digital content" + }, + { + "competency_ref": "digcomp:3.3", + "scheme": "digcomp", + "prefLabel": "Copyright and licences" + }, + { + "competency_ref": "onet:27-3041.00", + "scheme": "onet", + "prefLabel": "Editors" + } + ], + "competency_deltas": [ + "media-pipeline-orchestration", + "tts-and-forced-alignment", + "subtitle-rendering", + "structured-llm-output-resilience", + "multi-provider-llm-dispatch", + "stock-media-api-orchestration", + "ffmpeg-and-moviepy-safety", + "media-provenance-tracking" + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/6", + "level_label": "EQF level 6", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.video_production_pipeline", + "memory_segments": [ + { + "id": "operational", + "scope": "memory.x_klickd.video_production_pipeline.operational", + "policy": "pointer_only_summary" + }, + { + "id": "evidence", + "scope": "memory.x_klickd.video_production_pipeline.evidence", + "policy": "pointer_only_chain_of_custody" + }, + { + "id": "rights", + "scope": "memory.x_klickd.video_production_pipeline.rights", + "policy": "pointer_only_attribution" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.video_production_pipeline", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/video_production_pipeline", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:79f77682b3cfe75b3a55207a4c0f2a5d", + "attestation_hash": "sha256:503e12d5ec8c5be3b0a7db062851749610734654879c08b5dc8260dd059dd035" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/video_production_pipeline/v0-draft", + "embedding_model_ref": "klickd-embed-video_production_pipeline-2026-v0-placeholder", + "dim": 768, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 6, + "max_facts_per_turn": 8, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "video", + "edit_decision_list", + "color_pipeline", + "delivery_spec" + ], + "entity_classes": [ + "esco", + "onet" + ], + "priority": "creative_practice", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "media_profile_compose_ref": "rfc-001#media_profile", + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "low" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "auto_publish_to_social", + "real_person_likeness_or_voice", + "copyrighted_asset_use", + "paid_api_spend_over_threshold", + "product_performance_claim_without_evidence", + "risky_provider_use", + "stock_media_license_write" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "auto_publish_to_social", + "real_person_likeness_or_voice", + "copyrighted_asset_use", + "product_performance_claim_without_evidence", + "risky_provider_use" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "qualified_specialist_per_domain" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts", + "product_performance_rule": "Product-performance claims in the produced video MUST cite a reproducible benchmark pointer (RFC-003); unsupported claims blocked." + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ], + "no_undocumented_bundled_assets": true + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "auto-publish-social", + "action_class": "auto_publish_to_social", + "level": "block", + "reason": "Auto-publish to social blocked; floor not lowerable." + }, + { + "id": "real-person-likeness-or-voice", + "action_class": "real_person_likeness_or_voice", + "level": "block", + "reason": "Real-person likeness/voice requires evidenced consent." + }, + { + "id": "copyrighted-asset-use", + "action_class": "copyrighted_asset_use", + "level": "block", + "reason": "Copyrighted assets without recorded rights blocked." + }, + { + "id": "paid-api-spend-over-threshold", + "action_class": "paid_api_spend_over_threshold", + "level": "confirm", + "reason": "Paid API spend over carrier threshold." + }, + { + "id": "product-performance-claim-without-evidence", + "action_class": "product_performance_claim_without_evidence", + "level": "block", + "reason": "Claim needs reproducible benchmark pointer." + }, + { + "id": "risky-provider-use", + "action_class": "risky_provider_use", + "level": "block", + "reason": "Risky providers (e.g. g4f, pollinations) blocked unless explicit safety gate clears them." + }, + { + "id": "stock-media-license-write", + "action_class": "stock_media_license_write", + "level": "confirm", + "reason": "Stock-media licence write requires confirmation." + } + ] + }, + "pipeline_checkpoints": [ + { + "id": "script", + "stop_at": true, + "produces": [ + "script.json" + ] + }, + { + "id": "storyboard", + "stop_at": true, + "produces": [ + "storyboard.json" + ] + }, + { + "id": "shot_list", + "stop_at": true, + "produces": [ + "shots.json" + ] + }, + { + "id": "prompt_list", + "stop_at": true, + "produces": [ + "prompts.json" + ] + }, + { + "id": "voice_over", + "stop_at": true, + "produces": [ + "tts.wav", + "tts.timings.json" + ] + }, + { + "id": "subtitles", + "stop_at": true, + "produces": [ + "subs.srt" + ] + }, + { + "id": "render_plan", + "stop_at": true, + "produces": [ + "render_plan.json" + ] + }, + { + "id": "provenance", + "stop_at": true, + "produces": [ + "provenance.json" + ] + }, + { + "id": "qa", + "stop_at": true, + "produces": [ + "qa_report.json" + ] + } + ], + "router_cost": { + "tokens_estimate": 1300, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into a framework declared in frameworks[].", + "Citation-only references (FFmpeg, SRT, MoneyPrinterTurbo) are NOT registered as frameworks[] schemes.", + "All non_lowerable_floor gates are block under composition.", + "compact_index declares the same gates and router_cost as the full body.", + "Pointer-only evidence; no inline PII; no bundled assets.", + "pipeline_checkpoints declare stop_at points for deterministic resume.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == pro and tokens_estimate <= 1350", + "compact_index present with frameworks, competency_ids, gate_summaries, router_cost" + ], + "review": [ + "Reviewer verifies parents (user, media_planner, creator, research, legal) are referenced without redefinition.", + "Reviewer verifies risky-provider blocklist is not re-enabled silently by composition.", + "Reviewer verifies stock-media is OPTIONAL for product demos; primary visual layer is captured product footage.", + "Reviewer verifies product-performance claims cite a benchmark artefact pointer.", + "Reviewer verifies citation-only references are out of frameworks[]." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills/work-assistant.klickd b/packages/pypi/klickd/src/klickd/x_klickd_skills/work-assistant.klickd new file mode 100644 index 0000000..157a33e --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills/work-assistant.klickd @@ -0,0 +1,331 @@ +{ + "klickd_version": "4.0", + "payload_schema_version": "4.0.0-preview.1", + "domain_schema_version": "v4.1-x-klickd-candidate-1.0", + "created_at": "2026-05-27T00:00:00Z", + "encrypted": false, + "domain": "professional", + "profile_kind": "carrier_competency_pack", + "_pack_metadata": { + "kind": "x_klickd_candidate_skill_pack", + "size_tier": "lite", + "non_normative": true, + "claims_v41_ga": false, + "contains_real_pii": false, + "contains_secrets": false, + "status": "candidate_mapped", + "see_readme": "examples/v4.1/x-klickd-skills/README.md", + "note": "Non-normative x.klickd v4.1 candidate skill artefact. Composes with x.klickd/work (P1); narrower day-to-day assistant scope.", + "renamed_from": "work-lite.klickd" + }, + "x_klickd_pack": { + "pack": "x.klickd/work_assistant", + "pack_version": "0.1.0-candidate-lite", + "spec_ref": "x.klickd/v4.1#a1", + "publisher": { + "name": "klickd", + "ref": "https://klickd.app" + }, + "size_tier": "lite", + "parent_packs": [ + "x.klickd/user", + "x.klickd/work" + ], + "target_user": "Employed person or freelancer covering day-to-day deliverables, communication, and planning. Not a senior PM (that stays in full x.klickd/work).", + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1", + "iri_prefix": "http://data.europa.eu/esco/skill/", + "canonical_url": "https://esco.ec.europa.eu/en/classification/skill_main" + }, + { + "scheme": "lifecomp", + "version": "2020", + "iri_prefix": "https://joint-research-centre.ec.europa.eu/lifecomp/2020/", + "canonical_url": "https://joint-research-centre.ec.europa.eu/lifecomp_en" + }, + { + "scheme": "wef", + "version": "2023", + "iri_prefix": "https://www.weforum.org/reports/future-of-jobs-2023/skills/", + "canonical_url": "https://www.weforum.org/publications/the-future-of-jobs-report-2023/" + } + ], + "base_transversal_core": { + "frameworks": [ + { + "scheme": "esco", + "version": "v1.1.1" + }, + { + "scheme": "lifecomp", + "version": "2020" + } + ], + "transversal_refs": [ + { + "competency_ref": "esco:S1", + "scheme": "esco", + "prefLabel": "communication, collaboration and creativity" + }, + { + "competency_ref": "lifecomp:P1", + "scheme": "lifecomp", + "prefLabel": "Self-regulation" + }, + { + "competency_ref": "lifecomp:S2", + "scheme": "lifecomp", + "prefLabel": "Collaboration" + } + ] + }, + "competency_mappings": [ + { + "competency_ref": "esco:S1.3", + "scheme": "esco", + "prefLabel": "managing oneself and personal development" + }, + { + "competency_ref": "esco:S1.4", + "scheme": "esco", + "prefLabel": "working with others" + }, + { + "competency_ref": "esco:S4", + "scheme": "esco", + "prefLabel": "management skills" + }, + { + "competency_ref": "lifecomp:S2", + "scheme": "lifecomp", + "prefLabel": "Collaboration" + }, + { + "competency_ref": "wef:active-learning", + "scheme": "wef", + "prefLabel": "Active learning and learning strategies" + }, + { + "competency_ref": "wef:leadership-social-influence", + "scheme": "wef", + "prefLabel": "Leadership and social influence" + } + ], + "competencies": [ + { + "competency_ref": "esco:S1.3", + "scheme": "esco", + "prefLabel": "managing oneself and personal development" + }, + { + "competency_ref": "esco:S1.4", + "scheme": "esco", + "prefLabel": "working with others" + }, + { + "competency_ref": "esco:S4", + "scheme": "esco", + "prefLabel": "management skills" + }, + { + "competency_ref": "wef:active-learning", + "scheme": "wef", + "prefLabel": "Active learning and learning strategies" + } + ], + "levels": [ + { + "framework_ref": "https://europa.eu/europass/eqf/level/4", + "level_label": "EQF level 4", + "effective_at": "2026-05-27" + } + ], + "language_proficiency": [], + "mastery": [], + "memory_scope": "memory.x_klickd.work_assistant", + "memory_segments": [ + { + "id": "deliverables", + "scope": "memory.x_klickd.work_assistant.deliverables", + "policy": "pointer_only_summary" + }, + { + "id": "stakeholders", + "scope": "memory.x_klickd.work_assistant.stakeholders", + "policy": "pointer_only_no_pii_of_others" + } + ], + "structured_memory": { + "scope": "memory.x_klickd.work_assistant", + "policy": "pack_scoped_only", + "entries": [], + "compressed_memory": { + "version": "rfc-010-draft", + "_status": "draft_preview", + "_non_normative": true, + "_claims_v41_ga": false, + "_rfc_ref": "docs/rfcs/RFC-010-pack-memory-compression.md", + "derived_from": { + "pack": "x.klickd/work_assistant", + "slice_path": "structured_memory", + "extractor": { + "kind": "host_skill", + "host": "x.klickd.host.placeholder", + "agent_ref": "x.klickd/host/memory-extractor", + "version": "0.1.0-draft", + "deterministic_seed": "sha256:5674f0c94c1de54d9c4f583943de64ee", + "attestation_hash": "sha256:ffd3c88b9eab152655ed2044aa21c989e85f7f50154ecec07f2741fd6774863e" + } + }, + "fact_pointers": [], + "entity_links": [], + "graph_refs": [], + "vector_index": { + "uri": "klickd://vector-index/work_assistant/v0-draft", + "embedding_model_ref": "klickd-embed-work_assistant-2026-v0-placeholder", + "dim": 512, + "inline_embeddings_forbidden": true + }, + "retrieval_policy": { + "top_k": 5, + "max_facts_per_turn": 7, + "freshness_weighting": "linear_recency", + "host_side_only": true, + "require_gate": "memory_recall_injection" + }, + "_draft_retrieval_scope": { + "tags": [ + "work_admin", + "scheduling", + "email_triage", + "documents" + ], + "entity_classes": [ + "esco", + "lifecomp" + ], + "priority": "workflow_assist", + "_note": "Draft / non-normative extension surface. Carries the pack-role-specific retrieval scope so hosts can route memory recall by topic. NOT part of any current schema; see RFC-010 §5 for the normative-intent fragment." + }, + "erasure_cascade": { + "targets": [ + "fact_pointers", + "entity_links", + "graph_refs", + "vector_index" + ], + "on_evidence_deletion": "cascade_purge", + "on_user_request": "cascade_purge", + "verification_artifact_ref": null + }, + "gate_refs": [ + { + "gate_name": "compressed_memory_recall", + "action_class": "memory_recall_injection" + } + ] + } + }, + "gates": { + "verification_gates_default": { + "raise_only": true, + "claim_grounding_required": true, + "reversibility_threshold": "medium" + }, + "human_veto_policy": { + "owner": "human_carrier", + "scope": [ + "stakeholder_message", + "deliverable_release", + "team_attribution" + ] + } + }, + "human_veto": { + "owner": "human_carrier", + "raise_only": true, + "non_lowerable_floor": [ + "irreversible_action", + "third_party_attribution" + ] + }, + "human_authority": { + "final_decision_owner": "human_carrier", + "agent_role": "advisory", + "escalation": "senior_reviewer_for_stakeholder_facing_artefacts" + }, + "evidence_policy": { + "required_for_claims": true, + "pointer_only": true, + "attestation_shape_ref": "rfc-002#8b", + "verification_artifacts_ref": "rfc-003#verification_artifacts" + }, + "source_policy": { + "allow_inline_definitions": false, + "language_tags": [ + "en", + "fr" + ] + }, + "verification_gates": { + "version": 1, + "user_default": "silent", + "gates": [ + { + "id": "stakeholder-message", + "action_class": "stakeholder_message", + "level": "confirm", + "reason": "Outgoing stakeholder communication requires explicit human authorisation." + }, + { + "id": "deliverable-release", + "action_class": "deliverable_release", + "level": "confirm", + "reason": "Deliverable release is hard to reverse once shared." + }, + { + "id": "team-attribution", + "action_class": "team_attribution", + "level": "confirm", + "reason": "Attribution to a named teammate requires consent." + } + ] + }, + "router_cost": { + "tokens_estimate": 800, + "baseline": "base_plus_one" + }, + "acceptance_criteria": [ + "Every competency_ref resolves into the canonical framework registry (ESCO/LifeComp/WEF).", + "No host-side method, pedagogy, or scoring rubric inside the pack.", + "No PII of teammates or stakeholders; pointer-only.", + "Stakeholder-facing actions gated to confirm by default; raise_only true.", + "Round-trip safe with v4.0-only reader." + ], + "tests": { + "static": [ + "forbidden_fields literal frozen", + "no klickdapp.* or kai.* artefact reference", + "size_tier == lite and tokens_estimate <= 900" + ], + "review": [ + "Reviewer verifies x.klickd/work parent compose; no redefinition of P1 work pack defaults.", + "Reviewer verifies no entry-level deliverable bypasses the senior_reviewer escalation." + ] + }, + "forbidden_fields": [ + "pedagogy", + "teaching_method", + "socratic_steps", + "prompt_strategy", + "scoring_rubric", + "intervention_policy", + "tone_rules", + "system_prompt_overrides", + "knowledge.mastered", + "mastered_topics" + ] + } +} diff --git a/packages/pypi/klickd/src/klickd/x_klickd_skills_resources.py b/packages/pypi/klickd/src/klickd/x_klickd_skills_resources.py new file mode 100644 index 0000000..ab6b912 --- /dev/null +++ b/packages/pypi/klickd/src/klickd/x_klickd_skills_resources.py @@ -0,0 +1,128 @@ +# klickd — x.klickd v4.1 skill-pack helper +# SPDX-License-Identifier: CC0-1.0 +# +# The 42 x.klickd v4.1 candidate skill packs (8 Lite + 34 Pro) ship as +# package data under klickd/x_klickd_skills/, alongside the aggregated +# download index manifest.json. They are NON-NORMATIVE and NOT a v4.1 GA +# release (see examples/v4.1/x-klickd-skills/README.md in the source repo). +# +# These are JSON `.klickd` artifacts, not native skills in any assistant. +# A pack is only "used" once its bytes have been loaded and hash-verified +# against the manifest (or a host runtime has otherwise integrated it). +# load_xklickd_skill_pack() returns {"artifact_loaded": True, ...} only after +# that load + SHA-256 step has completed in-process. + +from __future__ import annotations + +import hashlib +import json +from importlib import resources +from importlib.resources.abc import Traversable +from typing import Any + + +_RESOURCE_PKG = "klickd.x_klickd_skills" + + +def _root() -> Traversable: + return resources.files(_RESOURCE_PKG) + + +def get_xklickd_skills_dir() -> str: + """Return the filesystem path to the bundled x.klickd skill-pack directory.""" + return str(_root()) + + +def get_xklickd_skills_manifest() -> dict[str, Any]: + """Return the bundled manifest.json (the 42-pack download index) as a dict.""" + raw = _root().joinpath("manifest.json").read_text(encoding="utf-8") + return json.loads(raw) + + +def list_xklickd_skill_packs() -> list[dict[str, Any]]: + """Return the 42 manifest pack entries (tier, pack id, file, bytes, sha256).""" + return get_xklickd_skills_manifest()["packs"] + + +def _manifest_entry_for(name: str) -> dict[str, Any] | None: + needle = name.strip() + norm = needle[:-7] if needle.endswith(".klickd") else needle + for pack in list_xklickd_skill_packs(): + if pack["file"] == needle or pack["pack"] == needle: + return pack + bare_pack = pack["pack"].split("/")[-1] + bare_file = pack["file"][:-7] if pack["file"].endswith(".klickd") else pack["file"] + if norm in (bare_pack, bare_file): + return pack + if bare_pack == norm.replace("-", "_") or bare_file == norm.replace("_", "-"): + return pack + return None + + +def get_xklickd_skill_pack_bytes(name: str) -> bytes: + """Return raw bytes of a bundled pack by file name, full pack id, or bare id.""" + entry = _manifest_entry_for(name) + if entry is None: + raise ValueError( + f"unknown x.klickd skill pack: {name!r} " + "(see list_xklickd_skill_packs())" + ) + file = entry["file"] + if "/" in file or "\\" in file or ".." in file: + raise ValueError(f"invalid x.klickd skill pack file: {file!r}") + return _root().joinpath(file).read_bytes() + + +def load_xklickd_skill_pack(name: str) -> dict[str, Any]: + """Load a pack, hash-verify it against the manifest, and return a summary. + + The returned ``artifact_loaded: True`` asserts only that the bytes were + read and hashed in-process — it does NOT mean any AI assistant has + natively adopted the pack. Always check ``sha256_matches_manifest``. + """ + entry = _manifest_entry_for(name) + if entry is None: + raise ValueError( + f"unknown x.klickd skill pack: {name!r} " + "(see list_xklickd_skill_packs())" + ) + data = get_xklickd_skill_pack_bytes(entry["file"]) + sha256 = hashlib.sha256(data).hexdigest() + payload = json.loads(data.decode("utf-8")) + pack = payload.get("x_klickd_pack") or {} + compact = pack.get("compact_index") or {} + + competency_ids = compact.get("competency_ids") + if not isinstance(competency_ids, list): + competency_ids = [ + c.get("competency_ref") + for c in pack.get("competencies", []) + if isinstance(c, dict) and c.get("competency_ref") + ] + + vgates = pack.get("verification_gates") + if isinstance(vgates, dict) and isinstance(vgates.get("gates"), list): + gates = vgates["gates"] + else: + gates = compact.get("gate_summaries", []) if isinstance(compact, dict) else [] + + return { + "artifact_loaded": True, + "id": entry["pack"], + "tier": entry.get("tier"), + "file": entry["file"], + "pack": pack.get("pack"), + "pack_version": pack.get("pack_version"), + "bytes": len(data), + "sha256": sha256, + "sha256_matches_manifest": sha256 == entry["sha256_file"], + "klickd_version": payload.get("klickd_version"), + "payload_schema_version": payload.get("payload_schema_version"), + "domain": payload.get("domain"), + "profile_kind": payload.get("profile_kind"), + "competency_ids": competency_ids, + "gates": gates, + "evidence_policy": pack.get("evidence_policy"), + "human_authority": pack.get("human_authority"), + "human_veto": pack.get("human_veto"), + } diff --git a/packages/pypi/klickd/tests/test_x_klickd_skills.py b/packages/pypi/klickd/tests/test_x_klickd_skills.py new file mode 100644 index 0000000..71e7b82 --- /dev/null +++ b/packages/pypi/klickd/tests/test_x_klickd_skills.py @@ -0,0 +1,72 @@ +# klickd — x.klickd v4.1 skill-pack inclusion test +# SPDX-License-Identifier: CC0-1.0 + +import hashlib + +import pytest + +import klickd + + +def test_manifest_is_42_packs_8_lite_34_pro(): + manifest = klickd.get_xklickd_skills_manifest() + assert manifest["non_normative"] is True + assert manifest["claims_v41_ga"] is False + assert manifest["total_count"] == 42 + assert len(manifest["packs"]) == 42 + lite = [p for p in manifest["packs"] if p["tier"] == "lite"] + pro = [p for p in manifest["packs"] if p["tier"] == "pro"] + assert len(lite) == 8 + assert len(pro) == 34 + + +def test_every_bundled_pack_hash_matches_manifest(): + for pack in klickd.list_xklickd_skill_packs(): + data = klickd.get_xklickd_skill_pack_bytes(pack["file"]) + assert hashlib.sha256(data).hexdigest() == pack["sha256_file"] + assert len(data) == pack["bytes"] + + +def test_resolves_by_file_pack_id_and_bare_id(): + by_file = klickd.load_xklickd_skill_pack("work-assistant.klickd") + by_pack = klickd.load_xklickd_skill_pack("x.klickd/work_assistant") + by_bare = klickd.load_xklickd_skill_pack("work-assistant") + assert by_file["sha256"] == by_pack["sha256"] == by_bare["sha256"] + + +def test_load_work_assistant_reports_verified_artifact(): + summary = klickd.load_xklickd_skill_pack("work-assistant") + assert summary["artifact_loaded"] is True + assert summary["sha256_matches_manifest"] is True + assert summary["tier"] == "lite" + assert summary["pack"] == "x.klickd/work_assistant" + assert summary["klickd_version"] is not None + + +def test_load_llm_agent_engineering_exposes_governance_fields(): + summary = klickd.load_xklickd_skill_pack("llm-agent-engineering") + assert summary["artifact_loaded"] is True + assert summary["sha256_matches_manifest"] is True + assert summary["tier"] == "pro" + assert summary["pack"] == "x.klickd/llm_agent_engineering" + assert summary["domain"] == "software_engineering" + assert summary["profile_kind"] == "carrier_competency_pack" + assert len(summary["competency_ids"]) > 0 + assert len(summary["gates"]) > 0 + assert summary["evidence_policy"] is not None + assert summary["human_authority"] is not None + + +def test_rejects_unknown_pack(): + with pytest.raises(ValueError): + klickd.get_xklickd_skill_pack_bytes("../pyproject.toml") + with pytest.raises(ValueError): + klickd.get_xklickd_skill_pack_bytes("does-not-exist") + with pytest.raises(ValueError): + klickd.load_xklickd_skill_pack("nope") + + +def test_dir_returns_string(): + d = klickd.get_xklickd_skills_dir() + assert isinstance(d, str) + assert d diff --git a/scripts/verify_xklickd_skill_packs.py b/scripts/verify_xklickd_skill_packs.py new file mode 100755 index 0000000..270758d --- /dev/null +++ b/scripts/verify_xklickd_skill_packs.py @@ -0,0 +1,223 @@ +#!/usr/bin/env python3 +"""Offline verifier + CLI for the 42 x.klickd v4.1 candidate skill packs. + +Source of truth: examples/v4.1/x-klickd-skills/ (8 Lite + 34 Pro `.klickd` +artifacts and the aggregated download index manifest.json). + +These are NON-NORMATIVE JSON artifacts and NOT a v4.1 GA release. They are +not native skills in any AI assistant. A pack is only "used" once its bytes +have been loaded and hash-verified against the manifest (or a host runtime has +otherwise explicitly integrated it). See +examples/v4.1/x-klickd-skills/README.md and +docs/integrations/skill-loader-protocol.md. + +Checks performed by `verify` (the default): + + 1. Manifest reports 42 packs total: 8 Lite, 34 Pro; counts agree. + 2. Every `.klickd` parses as JSON. + 3. Required top-level fields present: klickd_version, payload_schema_version, + domain, profile_kind, x_klickd_pack. + 4. x_klickd_pack.pack is present (and matches the manifest entry). + 5. SHA-256 of the file bytes matches manifest.json (and byte length matches). + +Exit code 0 = all checks pass. Non-zero = at least one check failed. + +No network. No provider calls. No paid resources. + +CLI (no external dependencies; reads the public artifacts directly): + + python scripts/verify_xklickd_skill_packs.py verify # full check (default) + python scripts/verify_xklickd_skill_packs.py list # list 42 packs + python scripts/verify_xklickd_skill_packs.py load # load + hash-verify one pack +""" + +from __future__ import annotations + +import hashlib +import json +import sys +from pathlib import Path +from typing import Any + +REPO_ROOT = Path(__file__).resolve().parents[1] +PACK_DIR = REPO_ROOT / "examples" / "v4.1" / "x-klickd-skills" +MANIFEST_PATH = PACK_DIR / "manifest.json" + +REQUIRED_TOP_LEVEL = ( + "klickd_version", + "payload_schema_version", + "domain", + "profile_kind", + "x_klickd_pack", +) + + +def _load_manifest() -> dict[str, Any]: + return json.loads(MANIFEST_PATH.read_text(encoding="utf-8")) + + +def _pack_path(entry: dict[str, Any]) -> Path: + # relative_path is repo-root-relative; fall back to tier/file. + rel = entry.get("relative_path") + if rel: + return REPO_ROOT / rel + return PACK_DIR / entry["tier"] / entry["file"] + + +def _find_entry(manifest: dict[str, Any], name: str) -> dict[str, Any] | None: + needle = name.strip() + norm = needle[:-7] if needle.endswith(".klickd") else needle + for entry in manifest["packs"]: + if entry["file"] == needle or entry["pack"] == needle: + return entry + bare_pack = entry["pack"].split("/")[-1] + bare_file = entry["file"][:-7] if entry["file"].endswith(".klickd") else entry["file"] + if norm in (bare_pack, bare_file): + return entry + if bare_pack == norm.replace("-", "_") or bare_file == norm.replace("_", "-"): + return entry + return None + + +def cmd_verify() -> int: + failures: list[str] = [] + manifest = _load_manifest() + packs = manifest.get("packs", []) + + if manifest.get("total_count") != 42 or len(packs) != 42: + failures.append( + f"expected total_count 42 and 42 entries, got " + f"{manifest.get('total_count')} / {len(packs)}" + ) + + lite = [p for p in packs if p.get("tier") == "lite"] + pro = [p for p in packs if p.get("tier") == "pro"] + if len(lite) != 8: + failures.append(f"expected 8 Lite packs, got {len(lite)}") + if len(pro) != 34: + failures.append(f"expected 34 Pro packs, got {len(pro)}") + + for entry in packs: + path = _pack_path(entry) + label = entry.get("file", "") + if not path.exists(): + failures.append(f"{label}: missing file at {path}") + continue + data = path.read_bytes() + + try: + payload = json.loads(data.decode("utf-8")) + except (UnicodeDecodeError, json.JSONDecodeError) as exc: + failures.append(f"{label}: not valid JSON ({exc})") + continue + + for field in REQUIRED_TOP_LEVEL: + if field not in payload: + failures.append(f"{label}: missing required field {field!r}") + + pack = payload.get("x_klickd_pack") + if not isinstance(pack, dict) or not pack.get("pack"): + failures.append(f"{label}: x_klickd_pack.pack missing") + elif pack["pack"] != entry["pack"]: + failures.append( + f"{label}: x_klickd_pack.pack {pack['pack']!r} != manifest " + f"{entry['pack']!r}" + ) + + sha = hashlib.sha256(data).hexdigest() + if sha != entry.get("sha256_file"): + failures.append( + f"{label}: sha256 {sha} != manifest {entry.get('sha256_file')}" + ) + if len(data) != entry.get("bytes"): + failures.append( + f"{label}: byte length {len(data)} != manifest {entry.get('bytes')}" + ) + + if failures: + print(f"FAIL: {len(failures)} problem(s) found:") + for f in failures: + print(f" - {f}") + return 1 + + print(f"OK: 42 x.klickd v4.1 skill packs verified ({len(lite)} Lite, {len(pro)} Pro).") + print("All parse as JSON, carry required fields, and hash-match the manifest.") + return 0 + + +def cmd_list() -> int: + manifest = _load_manifest() + for entry in manifest["packs"]: + print(f"{entry['tier']:<5} {entry['pack']:<45} {entry['file']}") + return 0 + + +def _summary(manifest: dict[str, Any], entry: dict[str, Any]) -> dict[str, Any]: + path = _pack_path(entry) + data = path.read_bytes() + sha = hashlib.sha256(data).hexdigest() + payload = json.loads(data.decode("utf-8")) + pack = payload.get("x_klickd_pack") or {} + compact = pack.get("compact_index") or {} + competency_ids = compact.get("competency_ids") + if not isinstance(competency_ids, list): + competency_ids = [ + c.get("competency_ref") + for c in pack.get("competencies", []) + if isinstance(c, dict) and c.get("competency_ref") + ] + vgates = pack.get("verification_gates") + if isinstance(vgates, dict) and isinstance(vgates.get("gates"), list): + gates = vgates["gates"] + else: + gates = compact.get("gate_summaries", []) if isinstance(compact, dict) else [] + return { + "artifact_loaded": True, + "id": entry["pack"], + "tier": entry.get("tier"), + "file": entry["file"], + "pack": pack.get("pack"), + "pack_version": pack.get("pack_version"), + "bytes": len(data), + "sha256": sha, + "sha256_matches_manifest": sha == entry.get("sha256_file"), + "klickd_version": payload.get("klickd_version"), + "payload_schema_version": payload.get("payload_schema_version"), + "domain": payload.get("domain"), + "profile_kind": payload.get("profile_kind"), + "competency_ids": competency_ids, + "gates": gates, + "evidence_policy": pack.get("evidence_policy"), + "human_authority": pack.get("human_authority"), + "human_veto": pack.get("human_veto"), + } + + +def cmd_load(name: str) -> int: + manifest = _load_manifest() + entry = _find_entry(manifest, name) + if entry is None: + print(f"unknown x.klickd skill pack: {name!r} (try `list`)", file=sys.stderr) + return 2 + print(json.dumps(_summary(manifest, entry), indent=2)) + return 0 + + +def main(argv: list[str]) -> int: + args = argv[1:] + cmd = args[0] if args else "verify" + if cmd == "verify": + return cmd_verify() + if cmd == "list": + return cmd_list() + if cmd == "load": + if len(args) < 2: + print("usage: load ", file=sys.stderr) + return 2 + return cmd_load(args[1]) + print(f"unknown command: {cmd!r} (verify|list|load)", file=sys.stderr) + return 2 + + +if __name__ == "__main__": + raise SystemExit(main(sys.argv))