singularity-claude 0.1.0

package/.claude-plugin/marketplace.json

@@ -0,0 +1,15 @@
+{
+  "name": "singularity-claude",
+  "description": "Self-evolving skill engine for Claude Code",
+  "owner": {
+    "name": "Haroun El Alami"
+  },
+  "plugins": [
+    {
+      "name": "singularity-claude",
+      "description": "Self-evolving skill engine for Claude Code. Creates, scores, repairs, and hardens skills autonomously.",
+      "version": "0.1.0",
+      "source": "./"
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,21 @@
+{
+  "name": "singularity-claude",
+  "description": "Self-evolving skill engine for Claude Code. Creates, scores, repairs, and hardens skills autonomously through recursive improvement cycles.",
+  "version": "0.1.0",
+  "author": {
+    "name": "Haroun El Alami"
+  },
+  "homepage": "https://github.com/shmayro/singularity-claude",
+  "repository": "https://github.com/shmayro/singularity-claude",
+  "license": "MIT",
+  "keywords": [
+    "skills",
+    "evolution",
+    "self-improving",
+    "scoring",
+    "auto-repair",
+    "crystallization",
+    "memory",
+    "claude-code"
+  ]
+}

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+## [0.1.0] - 2026-03-17
+
+### Added
+- Initial plugin structure with `.claude-plugin/` registration
+- **using-singularity** skill — bootstrap context injected at session start
+- **creating-skills** skill — meta-skill for building new Claude Code skills
+- **scoring** skill — 5-dimension rubric (Correctness, Completeness, Edge Cases, Efficiency, Reusability)
+- **repairing** skill — auto-fix failing skills through diagnosis and targeted rewrite
+- **crystallizing** skill — lock validated versions via git tags
+- **reviewing** skill — health check with trend analysis and recommendations
+- **dashboard** skill — overview table of all managed skills with alerts
+- **skill-assessor** agent (haiku) — automated scoring subagent
+- **gap-detector** agent (haiku) — capability gap analysis subagent
+- **score-manager.sh** — CLI for managing score JSON files
+- **telemetry-writer.sh** — CLI for structured execution logging
+- SessionStart hook with alert injection
+- Data storage at `~/.claude/singularity/` (scores, telemetry, registry, config)
+- Maturity progression: draft → tested → hardened → crystallized

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Haroun El Alami
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,269 @@
+<p align="center">
+  <h1 align="center">singularity-claude</h1>
+  <p align="center">
+    <strong>Skills that evolve themselves.</strong>
+    <br />
+    A self-evolving skill engine for Claude Code — create, score, repair, and crystallize skills through autonomous recursive improvement loops.
+  </p>
+  <p align="center">
+    <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a>
+    <a href="#installation"><img src="https://img.shields.io/badge/Claude%20Code-Plugin-blue?logo=data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48Y2lyY2xlIGN4PSIxMiIgY3k9IjEyIiByPSIxMCIgZmlsbD0id2hpdGUiLz48L3N2Zz4=" alt="Claude Code Plugin"></a>
+    <img src="https://img.shields.io/badge/Version-0.1.0-green" alt="Version">
+    <img src="https://img.shields.io/badge/Status-Experimental-orange" alt="Status">
+  </p>
+</p>
+
+---
+
+## The Problem
+
+Claude Code skills are **static**. You write them once, and they stay exactly as they are — even when they fail, produce subpar output, or encounter new edge cases. There's no feedback loop, no way to know which skills are working well, and no mechanism to improve them over time.
+
+You end up with a growing pile of skills where some work great, some are mediocre, and some are silently broken. The only way to fix them is manual review.
+
+## The Solution
+
+**singularity-claude** adds a recursive evolution loop to your skills:
+
+```mermaid
+graph TD
+    Goal["🎯 Goal:<br/>Set up API proxy endpoints"]
+    Goal --> HasSkill{Skill exists?}
+
+    HasSkill -->|No| Gap["🔍 Gap detected:<br/>recurring pattern"]
+    Gap --> Create["⚙️ /singularity-create\nGather requirements\nGenerate SKILL.md\nRegister + init scoring"]
+    Create --> Execute
+
+    HasSkill -->|Yes| Execute["⚡ Execute skill"]
+    Execute --> Score["📊 /singularity-score\nDispatch assessor agent\nRate 5 dimensions · 0-100"]
+    Score --> Maturity["🔄 Auto-update maturity\ndraft → tested → hardened"]
+
+    Maturity --> Low{Avg < 50\n2+ runs?}
+    Low -->|Yes| Repair["🔧 /singularity-repair\nAnalyze telemetry\nRewrite weak dimensions\nBump version · re-test"]
+    Repair --> Execute
+
+    Low -->|No| High{Avg ≥ 90 · 5+ runs\nhardened · edge cases?}
+    High -->|Yes| Crystal["💎 /singularity-crystallize\nGit tag + lock version"]
+    Crystal --> Done["✅ Production-grade skill\nImmutable · rollback-safe"]
+
+    High -->|No| Loop["🔁 Keep using + scoring"]
+    Loop --> Execute
+
+    style Goal fill:#1d3557,color:#fff,stroke:#0d1b2a
+    style Gap fill:#e9ecef,color:#000,stroke:#adb5bd
+    style Create fill:#457b9d,color:#fff,stroke:#1d3557
+    style Execute fill:#2a9d8f,color:#fff,stroke:#1a7a6e
+    style Score fill:#e76f51,color:#fff,stroke:#c1440e
+    style Maturity fill:#264653,color:#fff,stroke:#1d3540
+    style Low fill:#fff3cd,color:#000,stroke:#ffc107
+    style High fill:#d4edda,color:#000,stroke:#28a745
+    style Repair fill:#f4a261,color:#000,stroke:#e76f51
+    style Crystal fill:#2d6a4f,color:#fff,stroke:#1b4332
+    style Done fill:#1b4332,color:#fff,stroke:#0d2818
+    style Loop fill:#a8dadc,color:#000,stroke:#457b9d
+```
+
+> **Tip:** Click the expand button (↔) on the diagram to see the full interactive flow.
+
+Skills are scored after every execution. Low scores trigger automatic repair. High scores lead to crystallization — a locked, battle-tested version you can trust. Every step is logged for full auditability.
+
+**No external dependencies.** No SmythOS, no OpenTelemetry collector, no Docker. Pure Claude Code.
+
+## What's Inside
+
+### Skills (7)
+
+| Skill | Command | Purpose |
+|-------|---------|---------|
+| **using-singularity** | *(auto-loaded)* | Bootstrap context + capability gap detection |
+| **creating-skills** | `/singularity-create` | Build new skills through a structured workflow |
+| **scoring** | `/singularity-score` | Rate execution on a 5-dimension rubric (0-100) |
+| **repairing** | `/singularity-repair` | Auto-fix failing skills by analyzing score history |
+| **crystallizing** | `/singularity-crystallize` | Lock validated versions via git tags |
+| **reviewing** | `/singularity-review` | Health check with trend analysis |
+| **dashboard** | `/singularity-dashboard` | Overview of all managed skills |
+
+### Agents (2)
+
+| Agent | Model | Purpose |
+|-------|-------|---------|
+| **skill-assessor** | Haiku | Fast, cheap automated scoring against the rubric |
+| **gap-detector** | Haiku | Analyzes failed tasks to find missing skill capabilities |
+
+### Scripts (2)
+
+| Script | Purpose |
+|--------|---------|
+| `score-manager.sh` | CLI for reading/writing score JSON files (atomic writes, jq/node fallback) |
+| `telemetry-writer.sh` | CLI for structured execution logging with replay support |
+
+## Installation
+
+### From the official Claude Code plugin registry
+
+> **Requires** [Claude Code](https://docs.anthropic.com/en/docs/claude-code) CLI
+
+Inside a Claude Code session, run:
+
+```
+/plugin marketplace add Shmayro/singularity-claude
+/plugin install singularity-claude
+```
+
+### From npm
+
+```bash
+npm install -g singularity-claude
+```
+
+Then inside a Claude Code session:
+
+```
+/plugin marketplace add $(npm root -g)/singularity-claude
+/plugin install singularity-claude
+```
+
+### From source
+
+```bash
+git clone https://github.com/shmayro/singularity-claude.git
+cd singularity-claude
+```
+
+Then inside a Claude Code session:
+
+```
+/plugin marketplace add .
+/plugin install singularity-claude
+```
+
+## Quick Start
+
+```bash
+# 1. Start a new Claude Code session — singularity loads automatically
+
+# 2. Create your first skill
+/singularity-create
+
+# 3. Use the skill, then score it
+/singularity-score
+
+# 4. Check the dashboard
+/singularity-dashboard
+```
+
+That's it. The evolution loop starts running from the first score.
+
+## How It Works
+
+### The Evolution Loop
+
+**1. Create** — `/singularity-create` walks you through building a new skill: requirements gathering, duplicate checking, SKILL.md generation, registry registration, and initial scoring.
+
+**2. Score** — After every skill execution, `/singularity-score` dispatches a Haiku assessor agent that rates the output on 5 dimensions:
+
+| Dimension | What It Measures |
+|-----------|-----------------|
+| **Correctness** (0-20) | Did it achieve the goal? |
+| **Completeness** (0-20) | Were all requirements addressed? |
+| **Edge Cases** (0-20) | Did it handle unusual inputs? |
+| **Efficiency** (0-20) | Was the approach direct and minimal? |
+| **Reusability** (0-20) | Could the output be reused? |
+
+**3. Repair** — When a skill's average drops below 50 (configurable), `/singularity-repair` kicks in: reads score history + telemetry, identifies the weakest rubric dimensions, rewrites the skill to fix them, bumps the version, and re-tests.
+
+**4. Harden** — Each edge case encountered is recorded. Skills that handle more edge cases with higher scores progress through maturity levels.
+
+**5. Crystallize** — Once a skill hits 90+ average over 5+ runs with edge cases handled, `/singularity-crystallize` locks it with a git tag. Crystallized skills are immutable — a production-grade snapshot you can always roll back to.
+
+### Maturity Progression
+
+```mermaid
+graph TD
+    Draft["📝 Draft<br/><i>&lt; 3 runs</i>"] --> Tested["✅ Tested<br/><i>3+ runs, avg ≥ 60</i>"]
+    Tested --> Hardened["🛡️ Hardened<br/><i>5+ runs, avg ≥ 80<br/>edge cases handled</i>"]
+    Hardened --> Crystallized["🔒 Crystallized<br/><i>git-tagged, immutable</i>"]
+
+    style Draft fill:#e9ecef,color:#000,stroke:#adb5bd
+    style Tested fill:#a8dadc,color:#000,stroke:#457b9d
+    style Hardened fill:#264653,color:#fff,stroke:#1d3540
+    style Crystallized fill:#2d6a4f,color:#fff,stroke:#1b4332
+```
+
+### Capability Gap Detection
+
+The `using-singularity` skill (injected at every session start) teaches Claude to recognize when a new skill is needed:
+
+- **Repetition** — Doing the same multi-step procedure across sessions
+- **Failure without coverage** — No existing skill addresses the task
+- **Generalizable pattern** — The procedure applies beyond the current task
+
+When a gap is detected, Claude suggests creating a new skill automatically.
+
+## Data Storage
+
+All data is local. Nothing leaves your machine.
+
+```
+~/.claude/singularity/
+├── scores/          # Score history per skill (JSON)
+├── telemetry/       # Execution logs per skill (JSON)
+├── registry.json    # All managed skills
+└── config.json      # Thresholds and preferences
+```
+
+## Configuration
+
+Edit `~/.claude/singularity/config.json`:
+
+```json
+{
+  "autoRepairThreshold": 50,
+  "crystallizationThreshold": 90,
+  "crystallizationMinExecutions": 5,
+  "scoringMode": "auto"
+}
+```
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| `autoRepairThreshold` | 50 | Average score below this triggers repair suggestion |
+| `crystallizationThreshold` | 90 | Average score above this enables crystallization |
+| `crystallizationMinExecutions` | 5 | Minimum runs before crystallization is allowed |
+| `scoringMode` | `"auto"` | `"auto"` (agent scores), `"manual"` (you score), `"hybrid"` (agent scores, you override) |
+
+## Integration
+
+- Works alongside [superpowers](https://github.com/obra/superpowers) and other Claude Code plugins
+- Skills namespaced as `singularity-claude:*` — no conflicts
+- Created skills go to `~/.claude/skills/` — the standard Claude Code location, usable by any plugin
+
+## Requirements
+
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code) CLI
+- `jq` (recommended) or Node.js (fallback) for JSON manipulation
+- Git (optional, for crystallization via tags)
+
+## Inspired By
+
+[Moltron](https://github.com/adridder/moltron) — a self-evolving skill engine built on SmythOS. singularity-claude takes the same core ideas (scoring, auto-repair, crystallization, hardening) and rebuilds them natively for Claude Code with zero external dependencies.
+
+## Contributing
+
+Contributions welcome! See [CONTRIBUTING.md](.github/CONTRIBUTING.md) for guidelines.
+
+**Ideas for contributions:**
+- New scoring rubric dimensions
+- Additional maturity metrics
+- Platform support (Cursor, Codex, Gemini CLI)
+- Skill templates for common patterns
+
+## License
+
+[MIT](LICENSE) — use it however you want.
+
+---
+
+<p align="center">
+  <sub>Built with Claude Code. Skills that improve themselves.</sub>
+</p>

package/agents/gap-detector.md

@@ -0,0 +1,74 @@
+---
+name: gap-detector
+description: Analyzes a failed or unsatisfied task to determine if a new skill should be created. Checks existing registry for coverage and recommends skill creation when capability gaps are found.
+model: haiku
+---
+
+# Gap Detector
+
+You are a capability gap analyzer for the singularity-claude skill evolution engine. Your job is to determine whether a task failure or difficulty indicates a missing skill.
+
+## Input
+
+You will receive:
+1. **Task description** — what the user tried to accomplish
+2. **Outcome** — what happened (failure, partial success, manual workaround)
+3. **Registry** — list of existing singularity-managed skills
+4. **Context** — any relevant error messages, code, or notes
+
+## Analysis Process
+
+1. **Understand the task** — What capability was needed?
+2. **Check coverage** — Does any existing skill address this capability?
+   - Full coverage → No gap
+   - Partial coverage → Suggest extending existing skill
+   - No coverage → New skill needed
+3. **Assess recurrence** — Is this a one-off or likely to recur?
+   - One-off → Not worth a skill
+   - Recurring → Skill candidate
+4. **Assess generalizability** — Would this skill be useful beyond this specific task?
+   - Too specific → Not a skill (put in CLAUDE.md instead)
+   - Generalizable → Good skill candidate
+
+## Rules
+
+- A gap is only worth flagging if the skill would be used 3+ times
+- Don't recommend skills for things that are simple one-liners
+- Don't recommend skills that duplicate existing tools or CLI commands
+- Do recommend skills for multi-step workflows that require coordination
+
+## Output
+
+Return ONLY valid JSON:
+
+```json
+{
+  "gapDetected": true,
+  "confidence": "high",
+  "reasoning": "This task required X which no existing skill covers, and it's likely to recur because Y",
+  "recommendation": {
+    "action": "create-new",
+    "suggestedName": "<skill-name>",
+    "suggestedDescription": "Use when <triggering conditions>",
+    "suggestedScope": "<what the skill should cover>",
+    "relatedSkills": ["<existing-skill-if-any>"]
+  }
+}
+```
+
+Or if no gap:
+
+```json
+{
+  "gapDetected": false,
+  "confidence": "high",
+  "reasoning": "This is covered by existing skill X / This is a one-off / This is too simple for a skill",
+  "recommendation": {
+    "action": "none",
+    "existingSkill": "<skill-name-if-applicable>"
+  }
+}
+```
+
+Confidence levels: `"high"`, `"medium"`, `"low"`
+Actions: `"create-new"`, `"extend-existing"`, `"none"`

package/agents/skill-assessor.md

@@ -0,0 +1,55 @@
+---
+name: skill-assessor
+description: Evaluates the quality of a skill execution output against the Singularity scoring rubric. Returns a structured score breakdown with per-dimension ratings and rationale. Use this agent for automated skill scoring.
+model: haiku
+---
+
+# Skill Assessor
+
+You are a skill quality assessor for the singularity-claude evolution engine. Your job is to objectively evaluate how well a skill performed on a specific task.
+
+## Input
+
+You will receive:
+1. **Skill name** and version
+2. **Task description** — what was requested
+3. **Skill output** — what was produced (files, code, analysis)
+4. **Scoring rubric** — the 5-dimension rubric to evaluate against
+
+## Evaluation Process
+
+1. Read the task description carefully
+2. Examine the skill output thoroughly
+3. Rate each rubric dimension 0-20 with a brief rationale
+4. Identify strengths, weaknesses, and edge cases encountered
+5. Compute the total score (sum of all dimensions)
+
+## Rules
+
+- Be objective. A score of 100 means perfection — rare.
+- A typical good execution scores 70-85.
+- Don't inflate scores. If something is missing, dock points.
+- Focus on what the skill ACTUALLY produced, not what it could have done.
+- Edge cases: note any unusual inputs, boundary conditions, or error scenarios that arose.
+
+## Output
+
+Return ONLY valid JSON in this format:
+
+```json
+{
+  "totalScore": <0-100>,
+  "dimensions": {
+    "correctness": { "score": <0-20>, "rationale": "<why>" },
+    "completeness": { "score": <0-20>, "rationale": "<why>" },
+    "edgeCases": { "score": <0-20>, "rationale": "<why>" },
+    "efficiency": { "score": <0-20>, "rationale": "<why>" },
+    "reusability": { "score": <0-20>, "rationale": "<why>" }
+  },
+  "strengths": ["<strength1>", "<strength2>"],
+  "weaknesses": ["<weakness1>"],
+  "edgeCasesEncountered": ["<edge-case-if-any>"]
+}
+```
+
+Do not include any text outside the JSON block.

package/hooks/hooks.json

@@ -0,0 +1,16 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|clear|compact",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cmd\" session-start",
+            "async": false
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/run-hook.cmd

@@ -0,0 +1,5 @@
+: ; # Polyglot script: runs as bash on Unix, cmd on Windows
+: ; SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" ; exec bash "${SCRIPT_DIR}/$1" ; exit $?
+@echo off
+set "SCRIPT_DIR=%~dp0"
+bash "%SCRIPT_DIR%\%1"

package/hooks/session-start

@@ -0,0 +1,97 @@
+#!/usr/bin/env bash
+# SessionStart hook for singularity-claude plugin
+# Injects using-singularity context and skill health alerts
+
+set -euo pipefail
+
+# Determine plugin root directory
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PLUGIN_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
+
+# Data directory
+SINGULARITY_DATA="${HOME}/.claude/singularity"
+
+# Ensure data directories exist
+mkdir -p "${SINGULARITY_DATA}/scores"
+mkdir -p "${SINGULARITY_DATA}/telemetry"
+
+# Initialize registry if it doesn't exist
+if [ ! -f "${SINGULARITY_DATA}/registry.json" ]; then
+  cat > "${SINGULARITY_DATA}/registry.json" << 'REGISTRY'
+{
+  "$schema": "singularity-registry-v1",
+  "skills": {}
+}
+REGISTRY
+fi
+
+# Initialize config if it doesn't exist
+if [ ! -f "${SINGULARITY_DATA}/config.json" ]; then
+  cat > "${SINGULARITY_DATA}/config.json" << 'CONFIG'
+{
+  "autoRepairThreshold": 50,
+  "crystallizationThreshold": 90,
+  "crystallizationMinExecutions": 5,
+  "hardeningMinExecutions": 3,
+  "telemetryEnabled": true,
+  "scoringMode": "auto",
+  "skillOutputDir": "~/.claude/skills",
+  "gitTagPrefix": "singularity/"
+}
+CONFIG
+fi
+
+# Read using-singularity content
+using_singularity_content=$(cat "${PLUGIN_ROOT}/skills/using-singularity/SKILL.md" 2>&1 || echo "Error reading using-singularity skill")
+
+# Build alerts from registry
+alerts=""
+if command -v jq &>/dev/null && [ -f "${SINGULARITY_DATA}/registry.json" ]; then
+  # Find skills needing repair (avg < 50 with 2+ executions)
+  repair_needed=$(jq -r '
+    .skills | to_entries[]
+    | select(.value.averageScore < 50 and .value.executionCount >= 2)
+    | "  - ⚠ \(.key): avg score \(.value.averageScore)/100 (\(.value.executionCount) runs) — needs repair"
+  ' "${SINGULARITY_DATA}/registry.json" 2>/dev/null || true)
+
+  # Find skills ready for crystallization (avg >= 90 with 5+ executions)
+  crystal_ready=$(jq -r '
+    .skills | to_entries[]
+    | select(.value.averageScore >= 90 and .value.executionCount >= 5 and .value.maturity != "crystallized")
+    | "  - ✦ \(.key): avg score \(.value.averageScore)/100 (\(.value.executionCount) runs) — ready to crystallize"
+  ' "${SINGULARITY_DATA}/registry.json" 2>/dev/null || true)
+
+  if [ -n "$repair_needed" ] || [ -n "$crystal_ready" ]; then
+    alerts="\n\n**Skill Alerts:**\n"
+    [ -n "$repair_needed" ] && alerts="${alerts}${repair_needed}\n"
+    [ -n "$crystal_ready" ] && alerts="${alerts}${crystal_ready}\n"
+  fi
+fi
+
+# Escape string for JSON embedding
+escape_for_json() {
+    local s="$1"
+    s="${s//\\/\\\\}"
+    s="${s//\"/\\\"}"
+    s="${s//$'\n'/\\n}"
+    s="${s//$'\r'/\\r}"
+    s="${s//$'\t'/\\t}"
+    printf '%s' "$s"
+}
+
+using_singularity_escaped=$(escape_for_json "$using_singularity_content")
+alerts_escaped=$(escape_for_json "$alerts")
+session_context="<SINGULARITY_ENGINE>\nYou have singularity-claude — a self-evolving skill engine.\n\n${using_singularity_escaped}\n${alerts_escaped}\n</SINGULARITY_ENGINE>"
+
+# Output context injection as JSON
+# Cursor hooks expect additional_context
+# Claude Code hooks expect hookSpecificOutput.additionalContext
+if [ -n "${CURSOR_PLUGIN_ROOT:-}" ]; then
+  printf '{\n  "additional_context": "%s"\n}\n' "$session_context"
+elif [ -n "${CLAUDE_PLUGIN_ROOT:-}" ]; then
+  printf '{\n  "hookSpecificOutput": {\n    "hookEventName": "SessionStart",\n    "additionalContext": "%s"\n  }\n}\n' "$session_context"
+else
+  printf '{\n  "additional_context": "%s"\n}\n' "$session_context"
+fi
+
+exit 0

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "singularity-claude",
+  "version": "0.1.0",
+  "description": "Self-evolving skill engine for Claude Code. Creates, scores, repairs, and hardens skills autonomously.",
+  "author": "Haroun El Alami",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/shmayro/singularity-claude"
+  },
+  "homepage": "https://github.com/shmayro/singularity-claude#readme",
+  "keywords": [
+    "claude-code",
+    "skills",
+    "evolution",
+    "self-improving",
+    "ai-agent"
+  ],
+  "files": [
+    "skills/",
+    "agents/",
+    "scripts/",
+    "hooks/",
+    ".claude-plugin/",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ]
+}