@bcelep/capint 0.4.2 → 0.6.5

package/skills/pptx/scripts/internals/structure.py

@@ -0,0 +1,162 @@
+"""Slide structural operations — clone existing slides or instantiate from layouts."""
+from __future__ import annotations
+
+import re
+import shutil
+from pathlib import Path
+
+
+_EMPTY_SLIDE = '''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<p:sld xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
+       xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+       xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main">
+  <p:cSld>
+    <p:spTree>
+      <p:nvGrpSpPr>
+        <p:cNvPr id="1" name=""/>
+        <p:cNvGrpSpPr/>
+        <p:nvPr/>
+      </p:nvGrpSpPr>
+      <p:grpSpPr>
+        <a:xfrm>
+          <a:off x="0" y="0"/>
+          <a:ext cx="0" cy="0"/>
+          <a:chOff x="0" y="0"/>
+          <a:chExt cx="0" cy="0"/>
+        </a:xfrm>
+      </p:grpSpPr>
+    </p:spTree>
+  </p:cSld>
+  <p:clrMapOvr>
+    <a:masterClrMapping/>
+  </p:clrMapOvr>
+</p:sld>'''
+
+_LAYOUT_RELS = '''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout" Target="../slideLayouts/{layout}"/>
+</Relationships>'''
+
+
+def clone_or_instantiate(workspace: str, source: str) -> None:
+    root = Path(workspace)
+    if not root.exists():
+        raise FileNotFoundError(f"Workspace not found: {workspace}")
+
+    if source.startswith("slideLayout") and source.endswith(".xml"):
+        _from_layout(root, source)
+    elif source.endswith(".xml"):
+        _duplicate(root, source)
+    else:
+        raise ValueError(f"Source must be slide*.xml or slideLayout*.xml, got: {source}")
+
+
+def _from_layout(root: Path, layout_name: str) -> None:
+    layout_path = root / "ppt" / "slideLayouts" / layout_name
+    if not layout_path.exists():
+        raise FileNotFoundError(f"Layout not found: {layout_path}")
+
+    slides_dir = root / "ppt" / "slides"
+    num = _next_num(slides_dir)
+    fname = f"slide{num}.xml"
+
+    (slides_dir / fname).write_text(_EMPTY_SLIDE, encoding="utf-8")
+
+    rels_dir = slides_dir / "_rels"
+    rels_dir.mkdir(exist_ok=True)
+    (rels_dir / f"{fname}.rels").write_text(
+        _LAYOUT_RELS.format(layout=layout_name), encoding="utf-8"
+    )
+
+    _register_ct(root, fname)
+    rid = _register_pres_rel(root, fname)
+    sid = _next_sid(root)
+
+    print(f"Created {fname} from layout {layout_name}")
+    print(f'Add to <p:sldIdLst>: <p:sldId id="{sid}" r:id="{rid}"/>')
+
+
+def _duplicate(root: Path, source_name: str) -> None:
+    slides_dir = root / "ppt" / "slides"
+    rels_dir = slides_dir / "_rels"
+    source = slides_dir / source_name
+
+    if not source.exists():
+        raise FileNotFoundError(f"Slide not found: {source}")
+
+    num = _next_num(slides_dir)
+    fname = f"slide{num}.xml"
+
+    shutil.copy2(source, slides_dir / fname)
+
+    src_rels = rels_dir / f"{source_name}.rels"
+    dst_rels = rels_dir / f"{fname}.rels"
+    if src_rels.exists():
+        shutil.copy2(src_rels, dst_rels)
+        rels_text = dst_rels.read_text(encoding="utf-8")
+        rels_text = re.sub(
+            r'\s*<Relationship[^>]*Type="[^"]*notesSlide"[^>]*/>\s*',
+            "\n", rels_text,
+        )
+        dst_rels.write_text(rels_text, encoding="utf-8")
+
+    _register_ct(root, fname)
+    rid = _register_pres_rel(root, fname)
+    sid = _next_sid(root)
+
+    print(f"Cloned {source_name} -> {fname}")
+    print(f'Add to <p:sldIdLst>: <p:sldId id="{sid}" r:id="{rid}"/>')
+
+
+def _next_num(slides_dir: Path) -> int:
+    nums = [
+        int(m.group(1))
+        for f in slides_dir.glob("slide*.xml")
+        if (m := re.match(r"slide(\d+)\.xml", f.name))
+    ]
+    return max(nums, default=0) + 1
+
+
+def _next_sid(root: Path) -> int:
+    pres = (root / "ppt" / "presentation.xml").read_text(encoding="utf-8")
+    ids = [int(x) for x in re.findall(r'<p:sldId[^>]*id="(\d+)"', pres)]
+    base = max(ids, default=255) + 1
+
+    tracker = root / ".verdent_sid_counter"
+    if tracker.exists():
+        prev = int(tracker.read_text().strip())
+        base = max(base, prev + 1)
+    tracker.write_text(str(base))
+    return base
+
+
+def _register_ct(root: Path, fname: str) -> None:
+    ct_path = root / "[Content_Types].xml"
+    ct = ct_path.read_text(encoding="utf-8")
+    part_name = f"/ppt/slides/{fname}"
+    if part_name not in ct:
+        entry = (
+            f'<Override PartName="{part_name}" '
+            f'ContentType="application/vnd.openxmlformats-officedocument.presentationml.slide+xml"/>'
+        )
+        ct = ct.replace("</Types>", f"  {entry}\n</Types>")
+        ct_path.write_text(ct, encoding="utf-8")
+
+
+def _register_pres_rel(root: Path, fname: str) -> str:
+    rels_path = root / "ppt" / "_rels" / "presentation.xml.rels"
+    rels = rels_path.read_text(encoding="utf-8")
+
+    existing_ids = [int(x) for x in re.findall(r'Id="rId(\d+)"', rels)]
+    rid = f"rId{max(existing_ids, default=0) + 1}"
+
+    if f"slides/{fname}" not in rels:
+        tag = (
+            f'<Relationship Id="{rid}" '
+            f'Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide" '
+            f'Target="slides/{fname}"/>'
+        )
+        rels = rels.replace("</Relationships>", f"  {tag}\n</Relationships>")
+        rels_path.write_text(rels, encoding="utf-8")
+
+    return rid

package/skills/pr-creator/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: pr-creator
+description:
+  Use this skill when asked to create a pull request (PR). It ensures all PRs
+  follow the repository's established templates and standards.
+metadata:
+  version: '1.0.1'
+origin: verdent
+prismx_bundle: verdent
+prismx_imported_at: 2026-05-27
+---
+
+# Pull Request Creator
+
+This skill guides the creation of high-quality Pull Requests that adhere to the
+repository's standards.
+
+## Workflow
+
+Follow these steps to create a Pull Request:
+
+1.  **Branch Management**: **CRITICAL:** Ensure you are NOT working on the
+    `main` branch.
+    - Run `git branch --show-current`.
+    - If the current branch is `main`, you MUST create and switch to a new
+      descriptive branch:
+      ```bash
+      git checkout -b <new-branch-name>
+      ```
+
+2.  **Commit Changes**: Verify that all intended changes are committed.
+    - Run `git status` to check for unstaged or uncommitted changes.
+    - If there are uncommitted changes, stage and commit them with a descriptive
+      message before proceeding. NEVER commit directly to `main`.
+      ```bash
+      git add .
+      git commit -m "type(scope): description"
+      ```
+
+3.  **Locate Template**: Search for a pull request template in the repository.
+    - Check `.github/pull_request_template.md`
+    - Check `.github/PULL_REQUEST_TEMPLATE.md`
+    - If multiple templates exist (e.g., in `.github/PULL_REQUEST_TEMPLATE/`),
+      ask the user which one to use or select the most appropriate one based on
+      the context (e.g., `bug_fix.md` vs `feature.md`).
+
+4.  **Read Template**: Read the content of the identified template file.
+
+5.  **Draft Description**: Create a PR description that strictly follows the
+    template's structure.
+    - **Headings**: Keep all headings from the template.
+    - **Checklists**: Review each item. Mark with `[x]` if completed. If an item
+      is not applicable, leave it unchecked or mark as `[ ]` (depending on the
+      template's instructions) or remove it if the template allows flexibility
+      (but prefer keeping it unchecked for transparency).
+    - **Content**: Fill in the sections with clear, concise summaries of your
+      changes.
+    - **Related Issues**: Link any issues fixed or related to this PR (e.g.,
+      "Fixes #123").
+
+6.  **Preflight Check**: Before creating the PR, run the workspace preflight
+    script to ensure all build, lint, and test checks pass.
+    ```bash
+    npm run preflight
+    ```
+    If any checks fail, address the issues before proceeding to create the PR.
+
+7.  **Push Branch**: Push the current branch to the remote repository.
+    **CRITICAL SAFETY RAIL:** Double-check your branch name before pushing.
+    NEVER push if the current branch is `main`.
+    ```bash
+    # Verify current branch is NOT main
+    git branch --show-current
+    # Push non-interactively
+    git push -u origin HEAD
+    ```
+
+8.  **Create PR**: Use the `gh` CLI to create the PR. To avoid shell escaping
+    issues with multi-line Markdown, write the description to a temporary file
+    first.
+    ```bash
+    # 1. Write the drafted description to a temporary file
+    # 2. Create the PR using the --body-file flag
+    gh pr create --title "type(scope): succinct description" --body-file <temp_file_path>
+    # 3. Remove the temporary file
+    rm <temp_file_path>
+    ```
+    - **Title**: Ensure the title follows the
+      [Conventional Commits](https://www.conventionalcommits.org/) format if the
+      repository uses it (e.g., `feat(ui): add new button`,
+      `fix(core): resolve crash`).
+
+## Principles
+
+- **Safety First**: NEVER push to `main`. This is your highest priority.
+- **Compliance**: Never ignore the PR template. It exists for a reason.
+- **Completeness**: Fill out all relevant sections.
+- **Accuracy**: Don't check boxes for tasks you haven't done.

package/skills/pr-creator/agents/verdent.yaml

@@ -0,0 +1,11 @@
+category: Development
+interface:
+  display_name: PR Creator
+  short_description: Create high-quality Pull Requests following repo standards.
+  icon_dark: './assets/icon-dark.png'
+  icon_light: './assets/icon-light.png'
+  default_prompt: Create a pull request for my changes.
+  label:
+    - github
+    - pull-request
+    - collaboration

package/skills/prd/SKILL.md

@@ -0,0 +1,148 @@
+---
+name: prd
+description: 'Generate high-quality Product Requirements Documents (PRDs) for software systems and AI-powered features. Includes executive summaries, user stories, technical specifications, and risk analysis.'
+license: MIT
+metadata:
+  version: '1.0.1'
+origin: verdent
+prismx_bundle: verdent
+prismx_imported_at: 2026-05-27
+---
+
+# Product Requirements Document (PRD)
+
+## Overview
+
+Design comprehensive, production-grade Product Requirements Documents (PRDs) that bridge the gap between business vision and technical execution. This skill works for modern software systems, ensuring that requirements are clearly defined.
+
+## When to Use
+
+Use this skill when:
+
+- Starting a new product or feature development cycle
+- Translating a vague idea into a concrete technical specification
+- Defining requirements for AI-powered features
+- Stakeholders need a unified "source of truth" for project scope
+- User asks to "write a PRD", "document requirements", or "plan a feature"
+
+---
+
+## Operational Workflow
+
+### Phase 1: Discovery (The Interview)
+
+Before writing a single line of the PRD, you **MUST** interrogate the user to fill knowledge gaps. Do not assume context.
+
+**Ask about:**
+
+- **The Core Problem**: Why are we building this now?
+- **Success Metrics**: How do we know it worked?
+- **Constraints**: Budget, tech stack, or deadline?
+
+### Phase 2: Analysis & Scoping
+
+Synthesize the user's input. Identify dependencies and hidden complexities.
+
+- Map out the **User Flow**.
+- Define **Non-Goals** to protect the timeline.
+
+### Phase 3: Technical Drafting
+
+Generate the document using the **Strict PRD Schema** below.
+
+---
+
+## PRD Quality Standards
+
+### Requirements Quality
+
+Use concrete, measurable criteria. Avoid "fast", "easy", or "intuitive".
+
+```diff
+# Vague (BAD)
+- The search should be fast and return relevant results.
+- The UI must look modern and be easy to use.
+
+# Concrete (GOOD)
++ The search must return results within 200ms for a 10k record dataset.
++ The search algorithm must achieve >= 85% Precision@10 in benchmark evals.
++ The UI must follow the 'Vercel/Next.js' design system and achieve 100% Lighthouse Accessibility score.
+```
+
+---
+
+## Strict PRD Schema
+
+You **MUST** follow this exact structure for the output:
+
+### 1. Executive Summary
+
+- **Problem Statement**: 1-2 sentences on the pain point.
+- **Proposed Solution**: 1-2 sentences on the fix.
+- **Success Criteria**: 3-5 measurable KPIs.
+
+### 2. User Experience & Functionality
+
+- **User Personas**: Who is this for?
+- **User Stories**: `As a [user], I want to [action] so that [benefit].`
+- **Acceptance Criteria**: Bulleted list of "Done" definitions for each story.
+- **Non-Goals**: What are we NOT building?
+
+### 3. AI System Requirements (If Applicable)
+
+- **Tool Requirements**: What tools and APIs are needed?
+- **Evaluation Strategy**: How to measure output quality and accuracy.
+
+### 4. Technical Specifications
+
+- **Architecture Overview**: Data flow and component interaction.
+- **Integration Points**: APIs, DBs, and Auth.
+- **Security & Privacy**: Data handling and compliance.
+
+### 5. Risks & Roadmap
+
+- **Phased Rollout**: MVP -> v1.1 -> v2.0.
+- **Technical Risks**: Latency, cost, or dependency failures.
+
+---
+
+## Implementation Guidelines
+
+### DO (Always)
+
+- **Define Testing**: For AI systems, specify how to test and validate output quality.
+- **Iterate**: Present a draft and ask for feedback on specific sections.
+
+### DON'T (Avoid)
+
+- **Skip Discovery**: Never write a PRD without asking at least 2 clarifying questions first.
+- **Hallucinate Constraints**: If the user didn't specify a tech stack, ask or label it as `TBD`.
+
+---
+
+## Example: Intelligent Search System
+
+### 1. Executive Summary
+
+**Problem**: Users struggle to find specific documentation snippets in massive repositories.
+**Solution**: An intelligent search system that provides direct answers with source citations.
+**Success**:
+
+- Reduce search time by 50%.
+- Citation accuracy >= 95%.
+
+### 2. User Stories
+
+- **Story**: As a developer, I want to ask natural language questions so I don't have to guess keywords.
+- **AC**:
+  - Supports multi-turn clarification.
+  - Returns code blocks with "Copy" button.
+
+### 3. AI System Architecture
+
+- **Tools Required**: `codesearch`, `grep`, `webfetch`.
+
+### 4. Evaluation
+
+- **Benchmark**: Test with 50 common developer questions.
+- **Pass Rate**: 90% must match expected citations.

package/skills/prd/agents/verdent.yaml

@@ -0,0 +1,11 @@
+category: Documentation
+interface:
+  display_name: PRD Generator
+  short_description: Generate production-grade Product Requirements Documents.
+  icon_dark: './assets/icon-dark.png'
+  icon_light: './assets/icon-light.png'
+  default_prompt: Help me write a PRD for my product.
+  label:
+    - product
+    - requirements
+    - planning

package/skills/prismx-skill-gateway/SKILL.md

@@ -0,0 +1,179 @@
+---
+name: prismx-skill-gateway
+description: >
+  PrismX Skill Gateway — Invisible skill router. PRIORITY: Consult this skill BEFORE any other for ANY
+  task-oriented request. Routes to the right .prismx/skills/ skill automatically.
+  Trigger for: ANY file creation, ANY coding/building task, ANY design/creative request,
+  ANY debugging, ANY testing, ANY refactoring, ANY SEO/security/deployment task,
+  ANY documentation request, ANY "how do I" or "help me with" question.
+  ONLY skip for pure conversational chat. Responds in the user's language.
+version: 1.0.0
+---
+
+# PrismX Skill Gateway
+<!-- last_synced_from: .prismx/skills/skill-gateway/SKILL.md | 2026-05-17T20:00:42.836Z -->
+
+You are the **invisible skill router**. Every task request passes through you first.
+
+> **Constitutional layer:** Apply `.prismx/rules/karpathy-core.md` (P1–P4) before routing — P1 if ambiguous, P3 on every edit.
+
+## How It Works
+1. User makes a request
+2. Assess the need (internally, never out loud)
+3. Check `.prismx/REGISTRY.md` or `.prismx/registry.json` for the target skill status
+4. If the skill is present (`core`, `recommended`, `optional`, `project_added`) and its `SKILL.md` exists, read it
+5. If the skill is `not_installed` or missing, use the documented fallback or suggest installing/adding it
+6. Execute the task with the best available skill set
+
+**Never say** "I'm routing you to the X skill." Just do the work seamlessly.
+
+## Dependency Status Rules
+
+| Status | Gateway Behavior |
+|--------|------------------|
+| `core` | Must be available in a PrismX workspace. If missing, report setup corruption. |
+| `recommended` | Use when available; if missing, use general workflow fallback and recommend setup. |
+| `optional` | Use only when the project has it. Do not block if absent. |
+| `not_installed` | Do not pretend it exists. Use fallback or suggest `prismx skill add <name>`. |
+| `project_added` | Treat as first-class for this project after reading its `SKILL.md`. |
+
+## PrismX Context Check (Before Routing)
+1. Read `.prismx/HANDOFF.md` → current task context
+2. Read `.prismx/CURRENT_TASK.md` → today's focus (if present)
+3. Check `.prismx/DONE.md` → don't rebuild completed features
+4. New session → prefer `session-context-primer` before heavy work
+5. Check complexity weight → 🟢 skip brainstorming, 🔴 always brainstorm first
+
+## Quick Routing Table
+| Keywords | Preferred Skill(s) | If Missing |
+|----------|--------------------|------------|
+| new session, start, context load, where were we | `session-context-primer` | Read HANDOFF + INDEX manually |
+| vague, unclear, fix it, improve, optimize (ambiguous) | `prompt-enhancer` → then domain skill | Ask clarifying questions |
+| skill plan, hangi skill, which skill, route task | `task-skill-router` | Read gateway table manually |
+| skill catalog, tüm skill, all skills, skill listesi | `prismx-skills-catalog` | `prismx skill list` |
+| verdent skill, verdent bundle | `verdent-skills-catalog` | Browse `references/inventory.json` |
+| learned, gotcha, decision, remember, document finding | `knowledge-base-update` | Append wiki/decisions or gotchas manually |
+| docs stale, sync readme, update changelog after code | `documentation-sync` | Update CHANGELOG + README manually |
+| production down, outage, incident, P1, error spike | `incident-response` | Contain + log in `.prismx/incidents/` |
+| npm audit, CVE, dependency scan, outdated packages | `dependency-audit` | Run ecosystem audit manually |
+| new feature, build, add | `brainstorming` → `task-planner` | Use `/genesis`/`/blueprint` prompts and recommend adding planning skills |
+| bug, error, broken | `systematic-debugging`, `test-driven-development` | Use hypothesis/debug log manually |
+| refactor, clean up, code smell, simplify, sadeleştir | `refactor`, `code-simplifier`, `code-reviewer` | `improve-codebase-architecture` |
+| prd, requirements, user story, gereksinim | `prd`, `spec-writer`, `brainstorming` | Use `/genesis` prompts |
+| threat model, tehdit model, appsec | `security-threat-model`, `security-and-hardening` | Security checklist |
+| acceptance, kabul testi, delivery test | `delivery-acceptance`, `playwright`, `webapp-testing` | Manual test plan |
+| mcp server, model context protocol | `mcp-builder` | Read MCP docs |
+| pdf, excel, xlsx, word, docx, powerpoint, pptx | `pdf`, `xlsx`, `docx`, `pptx` | Manual file handling |
+| graphql, schema design | `graphql-schema`, `graphql-operations` | `api-and-interface-design` |
+| i18n, localization, çeviri, laravel lang | `localization-hub` | Manual locale files |
+| deploy vercel, netlify, cloudflare workers | `vercel-deploy`, `netlify-deploy`, `cloudflare` | `shipping-and-launch` |
+| react performance, next.js best practices | `vercel-react-best-practices`, `vercel-composition-patterns` | `performance`, `core-web-vitals` |
+| figma, design to code | `figma-implement-design`, `figma` | `frontend-design-pro` |
+| langchain, RAG, vector | `langchain-rag` | Manual RAG setup |
+| commit message, conventional commit | `git-commit` | `git-workflow-and-versioning` |
+| open PR, pull request template | `pr-creator`, `gh-cli` | Manual PR |
+| documentation, diataxis, tech docs | `documentation-writer`, `documentation-sync` | Update README manually |
+| test, TDD, coverage | `test-driven-development` | Write minimal verification plan |
+| review, PR, quality | `code-reviewer` | Use review stance checklist |
+| design review, architecture review | `design-reviewer` | Use `/challenge` built-in design checklist |
+| task review, task quality | `task-reviewer` | Use `/challenge` built-in task checklist |
+| security, auth, OWASP | `security-and-hardening`, `auth-patterns`, `code-reviewer`, `verification-before-completion` | Treat as heavy and require explicit evidence |
+| UI, CSS, design, layout | `frontend-design-pro`, `emil-design-eng`, `impeccable` | Use accessible UI checklist |
+| accessibility, WCAG, a11y | `impeccable` | Use `frontend-design-pro` accessibility section |
+| SEO, meta, sitemap | `seo-audit`, `schema-markup` | Use general SEO checklist |
+| performance, speed, loading | `performance` | Optimize with Lighthouse performance guidelines |
+| LCP, INP, CLS, web vitals | `core-web-vitals` | Use `performance` skill as broader fallback |
+| security, HTTPS, headers, CSP | `security-and-hardening` + `best-practices`, `code-reviewer` | Use security checklist |
+| audit site, lighthouse, quality | `web-quality-audit` | Run individual skill audits (seo + performance + a11y + best-practices) |
+| e2e, browser test, playwright | `e2e-testing-guide`, `webapp-testing` | Use manual test plan |
+| runtime, process, port, server | `runtime-inspector` | Use manual log reading + script analysis |
+| compare tech, evaluate, ADR | `tech-evaluator` | Use structured comparison matrix |
+| docs, API docs | `spec-writer` | Use PrismX document templates |
+| plan, roadmap | `task-planner` | Use WBS fallback |
+| graph, dependency | `nexus-mapper`, optional `nexus-query` | Use file tree + dependency search |
+| create skill, new workflow | `craft-authoring` or `/craft` | Use `/craft` workflow built-in scaffold |
+| find/add skill | `find-skills` or `/craft` | Add registry entry as `project_added` after creation |
+| API design, interface, REST, GraphQL | `api-and-interface-design` | Use general API design principles |
+| CI/CD, pipeline, deploy, automate | `ci-cd-and-automation` | Use deployment checklist |
+| context, session, agent setup | `context-engineering` | Use standard session protocol |
+| deprecate, migrate, upgrade legacy | `deprecation-and-migration` | Use `/upgrade` workflow |
+| ADR, decision record, document | `documentation-and-adrs` | Use PrismX arch/ templates |
+| doubt, adversarial, second opinion | `doubt-driven-development` | Use `/challenge` workflow |
+| git, commit, branch, version | `git-workflow-and-versioning` | Use standard git practices |
+| interview, requirements, discover | `interview-me` | Use `/genesis` Step 1 |
+| launch, ship, production ready | `shipping-and-launch` | Use deployment checklist |
+| official docs, source truth | `source-driven-development` | Use general documentation reading |
+| concept, model, domain map | `concept-modeler` | Use brainstorming + manual domain mapping |
+| copy, headline, tone, writing | `copywriting` | Use general writing best practices |
+| architect, system boundary, decompose | `system-architect` | Use `/genesis` built-in architecture step |
+| detailed design, interface, data model | `system-designer`, `database-and-data-modeling` | Use `/blueprint` built-in design step |
+| database, schema, migration, SQL, ORM | `database-and-data-modeling` | Use `system-designer` data model section |
+| error, exception, retry, circuit breaker | `error-handling`, `systematic-debugging` | Use hypothesis/debug log manually |
+| env, config, secrets, feature flag, .env | `environment-and-config` | Use deployment checklist |
+| best practices, standards, conventions | `best-practices` | Use general coding standards |
+
+> **Non-routed skills** (workflow-internal, no user keyword triggers):
+> `dispatching-parallel-agents`, `executing-plans`, `sequential-thinking`, `verification-before-completion`.
+> These are activated automatically by workflows or other skills, not by user keywords.
+
+## Task routing (capability-first)
+
+Read `.prismx/skill-routing-matrix.json` — canonical policy for weights, capabilities, and confirm step.
+
+Runtime chain (CLI + agent parity):
+
+`parseIntent -> routeCapability -> resolveMemoryStrategy -> buildExecutionPolicy -> formatOutput`
+
+| Step | Behavior |
+|------|----------|
+| Every task | Short **Execution Intent** per `session-start.md` |
+| Light 🟢 | No confirm — implement after Intent (`Plan: auto`) |
+| Medium/heavy 🟡🔴 | One-line Turkish confirm; accept devam/plan/analiz — never require `apply_now` token |
+| Apply | Classify silently → gateway → implement |
+| Plan | Run `task-skill-router` → Skill Plan table → approval → implement |
+| Analyze | Research/read-only; no code unless user changes choice |
+
+Execute via activated skills without announcing "routing to X" during implementation.
+
+> **Deprecated:** `skill_plan_mode` in old `context.json` / `config.json` — ignore; use matrix `clarification_policy` + `execution_policy_defaults`.
+> **Policy source:** provider precedence and fallback are controlled by matrix `resolver_order`; domain skill boosts obey `rules_domain_map.weight_min`.
+
+## When No Skill Matches
+1. Check `.prismx/REGISTRY.md` and `.prismx/registry.json` for recommended installs
+2. Handle with general capabilities if possible
+3. Suggest: `prismx skill add <name-or-repo>` or create via `/craft`
+
+## After Routing
+- Follow the activated skill's SKILL.md completely
+- Respect PrismX session protocol (HANDOFF/DONE updates)
+- On 🔴 Heavy tasks: trigger triple-sync (DONE + Graph + Wiki)
+
+## Extension Checklist — Adding `project_added` Skills to Gateway
+
+When a new skill is added via `prismx skill add`, decide if it needs gateway routing:
+
+### When to Add Routing Keywords
+
+- [ ] Skill has **user-facing triggers** (keywords users would type naturally)
+- [ ] Skill covers a **domain not handled** by existing routing entries
+- [ ] Skill is **frequently needed** in this project type
+
+→ **Action**: Add a row to the Quick Routing Table above:
+
+```markdown
+| <keywords> | `<skill-name>` | <fallback if removed> |
+```
+
+### When Routing is Optional
+
+- Skill is **only called from workflows** (e.g., `craft-authoring` from `/craft`)
+- Skill is a **sub-skill** activated by another skill (e.g., `nexus-query` from `nexus-mapper`)
+- Skill is **project-specific** and unlikely to match generic keywords
+
+→ **Action**: No routing row needed. Document in `REGISTRY.md` notes column.
+
+### Maintenance
+
+- When a `project_added` skill is removed, check if its routing row should be deleted
+- Run `/audit --registry` to detect routing entries pointing to missing skills
+- See: [Skill add contract](../../wiki/conventions/skill-add-contract.md)

package/skills/prismx-skill-gateway/references/installed-skills.md

@@ -0,0 +1,38 @@
+# PrismX Installed Skills — Antigravity
+<!-- auto-generated by prismx init | 2026-05-17T20:00:42.836Z -->
+
+| Skill | Description |
+|-------|-------------|
+| accessibility | Audit and improve web accessibility following WCAG 2.2 guidelines. Use when asked to "improve access |
+| api-and-interface-design | Guides stable API and interface design. Use when designing APIs, module boundaries, or any public in |
+| best-practices | Apply modern web development best practices for security, compatibility, and code quality. Use when  |
+| browser-testing-with-devtools | Tests in real browsers via Chrome DevTools MCP. Use when building or debugging anything that runs in |
+| ci-cd-and-automation | Automates CI/CD pipeline setup. Use when setting up or modifying build and deployment pipelines. Use |
+| code-review-and-quality | Conducts multi-axis code review. Use before merging any change. Use when reviewing code written by y |
+| code-simplification | Simplifies code for clarity. Use when refactoring code for clarity without changing behavior. Use wh |
+| context-engineering | Optimizes agent context setup. Use when starting a new session, when agent output quality degrades,  |
+| core-web-vitals | Optimize Core Web Vitals (LCP, INP, CLS) for better page experience and search ranking. Use when ask |
+| debugging-and-error-recovery | Guides systematic root-cause debugging. Use when tests fail, builds break, behavior doesn't match ex |
+| deprecation-and-migration | Manages deprecation and migration. Use when removing old systems, APIs, or features. Use when migrat |
+| documentation-and-adrs | Records decisions and documentation. Use when making architectural decisions, changing public APIs,  |
+| doubt-driven-development | Subjects every non-trivial decision to a fresh-context adversarial review before it stands. Use when |
+| frontend-ui-engineering | Builds production-quality UIs. Use when building or modifying user-facing interfaces. Use when creat |
+| git-workflow-and-versioning | Structures git workflow practices. Use when making any code change. Use when committing, branching,  |
+| graphify | > |
+| idea-refine | Refines raw ideas into sharp, actionable concepts through structured divergent and convergent thinki |
+| incremental-implementation | Delivers changes incrementally. Use when implementing any feature or change that touches more than o |
+| interview-me | Extracts what the user actually wants instead of what they think they should want. Achieves this thr |
+| performance | Optimize web performance for faster loading and better user experience. Use when asked to "speed up  |
+| performance-optimization | Optimizes application performance. Use when performance requirements exist, when you suspect perform |
+| planning-and-task-breakdown | Breaks work into ordered tasks. Use when you have a spec or clear requirements and need to break wor |
+| prclipper | > |
+| security-and-hardening | Hardens code against vulnerabilities. Use when handling user input, authentication, data storage, or |
+| seo | Optimize for search engine visibility and ranking. Use when asked to "improve SEO", "optimize for se |
+| shipping-and-launch | Prepares production launches. Use when preparing to deploy to production. Use when you need a pre-la |
+| source-driven-development | Grounds every implementation decision in official documentation. Use when you want authoritative, so |
+| spec-driven-development | Creates specs before coding. Use when starting a new project, feature, or significant change and no  |
+| test-driven-development | Drives development with tests. Use when implementing any logic, fixing any bug, or changing any beha |
+| using-agent-skills | Discovers and invokes agent skills. Use when starting a session or when you need to discover which s |
+| web-quality-audit | Comprehensive web quality audit covering performance, accessibility, SEO, and best practices. Use wh |
+
+Skills are located in `.prismx/skills/<name>/SKILL.md`.