palskills 1.0.0

package/README.md

@@ -0,0 +1,106 @@
+# Palskills
+
+**AI-powered development pipeline** — a suite of 5 Hermes Agent skills that orchestrate the full development lifecycle: context retrieval → planning → execution via Codex CLI → archival.
+
+```
+User Prompt
+     │
+     ▼
+┌──────────────────────────────────────────────────────┐
+│                                                      │
+│  🔮 Astralym — State Machine Core                    │
+│     Routes every prompt through the pipeline          │
+│                                                      │
+│     ├─► 📖 Lyleen — Palbox Reader & Bootstrapper     │
+│     │   Checks .palbox/ for context; creates if new   │
+│     │                                                 │
+│     ├─► 🐉 Jetdragon — Planner                       │
+│     │   Asks clarifying questions → detailed plan     │
+│     │                                                 │
+│     ├─► ⚔️ Anubis — Codex Development Engine         │
+│     │   Builds Codex prompt → codex exec (SOLID+SRP)  │
+│     │                                                 │
+│     └─► 📝 Panthalus — Palbox Archivist              │
+│         Records plan + execution → .palbox/history/   │
+│                                                      │
+└──────────────────────────────────────────────────────┘
+```
+
+## Skills
+
+| Skill | Role | Key Trait |
+|-------|------|-----------|
+| **Astralym** | State machine orchestrator | Non-skip states, gate-keeps the flow |
+| **Lyleen** | Palbox reader & bootstrapper | Auto-creates `.palbox/` if missing |
+| **Jetdragon** | Planner | Asks until clear, generates Codex-ready prompts |
+| **Anubis** | Codex executor | SOLID + SRP enforced, English only |
+| **Panthalus** | Archivist | Records EVERY session to palbox |
+
+## Prerequisites
+
+- [Hermes Agent](https://github.com/nousresearch/hermes-agent)
+- [Codex CLI](https://github.com/openai/codex) (`npm install -g @openai/codex`)
+- Git (all work happens in git repositories)
+
+## Install
+
+### npm (recommended)
+```bash
+npm install -g palskills
+# Skills auto-installed to ~/.hermes/skills/palskills/
+```
+
+### Git
+```bash
+git clone https://github.com/faizalardhi16/palskills.git
+cd palskills
+./install.sh
+```
+
+## Usage
+
+### Interactive CLI
+```bash
+palskills
+```
+
+```
+╔══════════════════════════════════════╗
+║           PALSKILLS                  ║
+║     AI Development Pipeline          ║
+╚══════════════════════════════════════╝
+
+  Pilih coding agent:
+
+  [1] Codex CLI     → .codex.md
+  [2] Cursor        → .cursorrules
+  [3] Claude Code   → CLAUDE.md
+  [4] Semua         → generate all
+
+  Pilih [1-4]:
+```
+
+Pilih agent, langsung generate config file dengan SOLID + SRP rules + palbox conventions.
+
+### One-shot (tanpa install)
+```bash
+npx palskills
+```
+
+## Palbox
+
+Palskills creates a `.palbox/` second brain in every project:
+
+```
+.palbox/
+├── README.md          # Project identity & tech stack
+├── architecture.md    # Folder map & design patterns
+├── methods.md         # Conventions & standards
+├── flows/             # Feature workflow docs
+├── plans/             # Active plans (Jetdragon)
+└── history/           # Past executions (Panthalus)
+```
+
+## License
+
+MIT

package/bin/palskills.js

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const MAGENTA = '\x1b[35m';
+const BOLD = '\x1b[1m';
+const NC = '\x1b[0m';
+
+function box(text) {
+  const lines = text.split('\n');
+  const width = Math.max(...lines.map(l => l.length)) + 4;
+  const top = '╔' + '═'.repeat(width - 2) + '╗';
+  const bottom = '╚' + '═'.repeat(width - 2) + '╝';
+  console.log(CYAN + top);
+  lines.forEach(l => console.log('║ ' + l.padEnd(width - 4) + ' ║'));
+  console.log(bottom + NC);
+}
+
+function ask(q) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => rl.question(q, ans => { rl.close(); resolve(ans.trim()); }));
+}
+
+async function main() {
+  box('PALSKILLS\nAI Development Pipeline');
+
+  console.log('');
+  console.log(`  ${BOLD}Pilih coding agent:${NC}`);
+  console.log('');
+  console.log(`  ${MAGENTA}[1]${NC} Codex CLI     → .codex.md`);
+  console.log(`  ${MAGENTA}[2]${NC} Cursor        → .cursorrules`);
+  console.log(`  ${MAGENTA}[3]${NC} Claude Code   → CLAUDE.md`);
+  console.log(`  ${MAGENTA}[4]${NC} Semua         → generate all`);
+  console.log('');
+
+  const choice = await ask(`  Pilih [1-4]: `);
+  console.log('');
+
+  const agents = [];
+  if (choice === '1') agents.push('codex');
+  else if (choice === '2') agents.push('cursor');
+  else if (choice === '3') agents.push('claude');
+  else if (choice === '4') agents.push('codex', 'cursor', 'claude');
+  else { console.log('  Pilihan tidak valid. Exit.'); process.exit(1); }
+
+  for (const agent of agents) {
+    generate(agent);
+  }
+
+  // Also install Hermes skills
+  installSkills();
+
+  console.log(`\n  ${GREEN}✅ Done!${NC} Restart Hermes Agent untuk load skills.\n`);
+}
+
+function generate(agent) {
+  const cwd = process.cwd();
+
+  if (agent === 'codex') {
+    const file = path.join(cwd, '.codex.md');
+    fs.writeFileSync(file, codexRules());
+    console.log(`  ${GREEN}✓${NC} .codex.md`);
+  }
+
+  if (agent === 'cursor') {
+    const file = path.join(cwd, '.cursorrules');
+    fs.writeFileSync(file, cursorRules());
+    console.log(`  ${GREEN}✓${NC} .cursorrules`);
+  }
+
+  if (agent === 'claude') {
+    const file = path.join(cwd, 'CLAUDE.md');
+    fs.writeFileSync(file, claudeRules());
+    console.log(`  ${GREEN}✓${NC} CLAUDE.md`);
+  }
+}
+
+function codexRules() {
+  return `# Codex Rules — Palskills
+# Generated by palskills CLI
+
+## SOLID Principles (Enforced)
+1. **Single Responsibility:** Every class/module/function has exactly ONE reason to change.
+2. **Open/Closed:** Extend via inheritance/composition, never modify existing code.
+3. **Liskov Substitution:** Subtypes must be fully substitutable for their base types.
+4. **Interface Segregation:** Small, focused interfaces. No client depends on unused methods.
+5. **Dependency Inversion:** Depend on abstractions. Inject dependencies.
+
+## SRP Enforcement
+- Repository → data access ONLY
+- Service → business logic ONLY
+- Validator → validation rules ONLY
+- Model → data structures ONLY
+- If a class mixes these, REFACTOR immediately.
+
+## Code Structure
+- No file exceeds 200 lines without strong justification.
+- Business logic → services/. Data access → repositories/. Validation → validators/.
+- Models are pure data structures — no methods, no logic.
+
+## Language
+ALL code, comments, docstrings, variable names, and commit messages MUST be in English.
+
+## Git
+- One commit per logical change.
+- Conventional commits: feat(scope): description / fix(scope): description / test(scope): description
+
+## Palbox
+- Check .palbox/ for project context before starting.
+- Record results to .palbox/history/ after completion.
+`;
+}
+
+function cursorRules() {
+  return `# Cursor Rules — Palskills
+# Generated by palskills CLI
+
+## Core Principles
+You are working in a project managed by the Palskills development system.
+Always follow these rules.
+
+### SOLID
+1. **S** — Single Responsibility: one class, one reason to change.
+2. **O** — Open/Closed: extend, don't modify.
+3. **L** — Liskov Substitution: subtypes fully substitutable.
+4. **I** — Interface Segregation: small interfaces, no fat abstractions.
+5. **D** — Dependency Inversion: depend on abstractions, inject deps.
+
+### SRP (Single Responsibility Pattern)
+- Repository classes: data access ONLY
+- Service classes: business logic ONLY
+- Validator classes: validation rules ONLY
+- Model classes: data structures ONLY
+- If any module mixes these, REFACTOR.
+
+### Language
+ALL code, comments, docs, variable names, and commit messages MUST be in English.
+
+### Git
+- One commit per logical change
+- Conventional commits format: feat(scope): / fix(scope): / test(scope):
+
+### Project Context
+- Check .palbox/ for architecture, conventions, and past work.
+- Read .palbox/README.md, .palbox/architecture.md, .palbox/methods.md before coding.
+- After completing work, the Palskills system will record to .palbox/history/.
+
+### Code Quality
+- No file exceeds 200 lines without strong justification.
+- Every function has a clear, single purpose.
+- Prefer composition over inheritance.
+- Write tests for all new logic.
+`;
+}
+
+function claudeRules() {
+  return `# CLAUDE.md — Palskills
+# Generated by palskills CLI
+
+## Who You Are
+You are an AI coding assistant working in a Palskills-managed project.
+You follow SOLID principles, Single Responsibility Pattern, and write all code in English.
+
+## SOLID (Strict)
+1. **Single Responsibility:** Every class, module, and function has exactly ONE reason to change.
+2. **Open/Closed:** Open for extension via inheritance/composition, closed for modification.
+3. **Liskov Substitution:** Derived classes must be fully substitutable for base classes.
+4. **Interface Segregation:** Many small, focused interfaces — no fat abstractions.
+5. **Dependency Inversion:** Depend on abstractions, inject dependencies. Never instantiate collaborators in business logic.
+
+## SRP (Single Responsibility Pattern)
+- Repository classes → data access ONLY
+- Service classes → business logic ONLY
+- Validator classes → validation rules ONLY
+- Model classes → data structures ONLY (no methods, no logic)
+- If a class mixes these concerns, REFACTOR immediately.
+
+## Code Structure
+\`\`\`
+src/
+├── models/      # Pure data structures
+├── repositories/ # Data access layer
+├── services/    # Business logic
+├── validators/  # Validation rules
+└── interfaces/  # Abstract bases & protocols
+\`\`\`
+
+## Language
+ALL code, comments, docstrings, variable names, function names, and commit messages MUST be in English.
+
+## Git
+- One commit per logical change.
+- Conventional commits: feat(scope): / fix(scope): / test(scope):
+- Never commit generated files, node_modules, or secrets.
+
+## Project Context (Palbox)
+Before starting any task:
+1. Check if .palbox/ exists.
+2. Read .palbox/README.md for project overview.
+3. Read .palbox/architecture.md for folder structure and patterns.
+4. Read .palbox/methods.md for conventions.
+5. Search .palbox/history/ for related past work.
+
+After completing work:
+- The Palskills system will record your session to .palbox/history/.
+`;
+}
+
+function installSkills() {
+  const hermesHome = process.env.HERMES_HOME || path.join(process.env.HOME || '~', '.hermes');
+  const target = path.join(hermesHome, 'skills', 'palskills');
+  const src = path.join(__dirname, '..', 'skills');
+
+  if (!fs.existsSync(src)) {
+    console.log(`  ${YELLOW}⚠${NC}  Skills source not found, skipping Hermes skills install.`);
+    return;
+  }
+
+  fs.mkdirSync(target, { recursive: true });
+
+  const skills = fs.readdirSync(src);
+  for (const skill of skills) {
+    const skillMd = path.join(src, skill, 'SKILL.md');
+    if (fs.existsSync(skillMd)) {
+      const dest = path.join(target, skill);
+      fs.mkdirSync(dest, { recursive: true });
+      fs.copyFileSync(skillMd, path.join(dest, 'SKILL.md'));
+      console.log(`  ${GREEN}✓${NC} Skill: ${skill}`);
+    }
+  }
+}
+
+main().catch(e => { console.error(e); process.exit(1); });

package/index.js

@@ -0,0 +1 @@
+console.log("HELLO")

package/install.sh

@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+HERMES_SKILLS="${HERMES_HOME:-$HOME/.hermes}/skills"
+TARGET="${HERMES_SKILLS}/palskills"
+
+echo "╔══════════════════════════════════════╗"
+echo "║     Palskills Installer             ║"
+echo "╚══════════════════════════════════════╝"
+echo ""
+
+# Check Hermes skills directory
+if [ ! -d "$HERMES_SKILLS" ]; then
+    echo "📁 Creating Hermes skills directory: $HERMES_SKILLS"
+    mkdir -p "$HERMES_SKILLS"
+fi
+
+# Install each skill
+SKILLS_DIR="$(cd "$(dirname "$0")" && pwd)/skills"
+
+for skill in astralym lyleen jetdragon anubis panthalus; do
+    if [ -f "$SKILLS_DIR/$skill/SKILL.md" ]; then
+        echo "📦 Installing: $skill"
+        mkdir -p "$TARGET/$skill"
+        cp "$SKILLS_DIR/$skill/SKILL.md" "$TARGET/$skill/SKILL.md"
+    else
+        echo "⚠️  Warning: $skill/SKILL.md not found, skipping"
+    fi
+done
+
+echo ""
+echo "✅ Palskills installed to: $TARGET"
+echo ""
+echo "Skills ready:"
+ls -1 "$TARGET"/*/SKILL.md | while read f; do
+    dir=$(basename "$(dirname "$f")")
+    echo "  • $dir"
+done
+echo ""
+echo "Usage: In Hermes Agent, invoke any skill by name:"
+echo "  - 'Load the astralym skill'"
+echo "  - 'Use lyleen to check palbox'"
+echo "  - 'Run jetdragon for planning'"

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "palskills",
+  "version": "1.0.0",
+  "description": "AI-powered development pipeline — 5 Hermes Agent skills orchestrated as a knowledge graph",
+  "keywords": [
+    "hermes-agent",
+    "skills",
+    "palskills",
+    "knowledge-graph",
+    "codex",
+    "development",
+    "ai-agent",
+    "solidsrp"
+  ],
+  "homepage": "https://github.com/faizalardhi16/palskills#readme",
+  "bugs": {
+    "url": "https://github.com/faizalardhi16/palskills/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/faizalardhi16/palskills.git"
+  },
+  "license": "MIT",
+  "author": "Faizal Ardhi Cahyanto",
+  "type": "commonjs",
+  "main": "index.js",
+  "bin": {
+    "palskills": "bin/palskills.js"
+  },
+  "files": [
+    "skills/",
+    "bin/",
+    "install.sh"
+  ],
+  "scripts": {
+    "postinstall": "bash install.sh"
+  }
+}

package/skills/anubis/SKILL.md

@@ -0,0 +1,192 @@
+---
+name: anubis
+description: "Development execution via Codex CLI — receives approved plans, formats them as Codex prompts, and runs codex exec following SOLID + SRP. All output in English."
+version: 2.0.0
+author: Palskills
+license: MIT
+platforms: [linux, macos, windows]
+metadata:
+  hermes:
+    tags: [palskills, development, codex, SOLID, SRP, English-only]
+    related_skills: [astralym, lyleen, jetdragon, panthalus, codex]
+---
+
+# Anubis — Codex Development Engine
+
+Anubis is the **execution arm** of the palskills system. It receives an approved plan from **Jetdragon** and delegates the actual coding to **OpenAI Codex CLI**. Anubis acts as the bridge — translating plans into effective Codex prompts, monitoring execution, and verifying results.
+
+## Why Codex?
+
+- Anubis doesn't write code directly — it **directs** Codex to write code
+- Codex runs autonomously in a sandbox, making file changes and commits
+- Anubis ensures Codex follows SOLID + SRP principles via explicit prompt instructions
+
+## Core Principles (Enforced via Prompting)
+
+| Principle | How Anubis Enforces It |
+|-----------|----------------------|
+| **S** — Single Responsibility | Prompt explicitly: "Each class/module must have exactly one reason to change" |
+| **O** — Open/Closed | Prompt: "Use interfaces/abstract bases; extend via inheritance, never modify existing" |
+| **L** — Liskov Substitution | Prompt: "Subtypes must be fully substitutable for their base types" |
+| **I** — Interface Segregation | Prompt: "Create small, focused interfaces; no client should depend on unused methods" |
+| **D** — Dependency Inversion | Prompt: "Depend on abstractions; inject dependencies, no hard-coded instantiations" |
+
+## How It Works
+
+### Step 1: Load Approved Plan
+
+Read the plan from `.palbox/plans/` (handed off by Jetdragon). Verify:
+- Plan status is `APPROVED`
+- All tasks have clear acceptance criteria
+
+### Step 2: Build the Codex Prompt
+
+Transform the plan into a Codex-optimized prompt. The prompt MUST include:
+
+```markdown
+## Task
+[what to build — from the plan]
+
+## Context
+- **Project:** [from .palbox/README.md]
+- **Architecture:** [from .palbox/architecture.md]
+- **Conventions:** [from .palbox/methods.md]
+- **Relevant history:** [from .palbox/history/ — linked entries]
+
+## SOLID Requirements
+1. **Single Responsibility:** Every class/module does exactly ONE thing
+2. **Open/Closed:** Extend via inheritance/composition, never modify existing code
+3. **Liskov Substitution:** Subtypes must be fully substitutable
+4. **Interface Segregation:** Small focused interfaces, no fat abstractions
+5. **Dependency Inversion:** Depend on abstractions, inject dependencies
+
+## SRP Enforcement
+- If a class can be described with "and" in its responsibility — split it
+- Business logic lives in services, data access in repositories, validation in validators
+- No file should exceed 200 lines without strong justification
+
+## Language
+ALL code, comments, docstrings, variable names, and commit messages MUST be in English.
+
+## Deliverables
+[list of files to create/modify from the plan]
+
+## Verification
+[acceptance criteria from the plan]
+```
+
+### Step 3: Execute via Codex
+
+```bash
+# One-shot execution
+codex exec "[the full prompt above]"
+
+# For larger tasks, use --full-auto
+codex exec --full-auto "[the full prompt above]"
+```
+
+**Using Hermes terminal with PTY (required):**
+
+```
+terminal(
+  command="codex exec '[prompt]'",
+  workdir="~/project",
+  pty=true,
+  background=true,
+  notify_on_complete=true
+)
+```
+
+**Key flags:**
+| Flag | When to use |
+|------|-------------|
+| `exec "[prompt]"` | Default — one-shot, exits when done |
+| `--full-auto` | Larger multi-file changes, auto-approves sandboxed changes |
+| `--yolo` | Only when user explicitly requests maximum speed (rare) |
+
+### Step 4: Monitor Execution
+
+```bash
+# Check progress
+process(action="poll", session_id="<id>")
+
+# Read full output if needed
+process(action="log", session_id="<id>")
+
+# Answer Codex questions if they arise
+process(action="submit", session_id="<id>", data="yes, proceed")
+```
+
+### Step 5: Verify Output
+
+After Codex finishes:
+
+```bash
+# Check what changed
+git diff --stat HEAD~1
+git log --oneline -5
+
+# Verify tests pass (if applicable)
+# [project-specific test command]
+```
+
+### Step 6: Report
+
+Return to Astralym with:
+- ✅ / ❌ status
+- Files changed
+- Commits made
+- Any issues encountered
+
+## Prompt Template (Full)
+
+```
+You are implementing a feature in this project. Follow these rules strictly.
+
+## PROJECT CONTEXT
+{palbox_context}
+
+## TASK
+{plan_tasks}
+
+## CODING STANDARDS
+
+### SOLID Principles
+1. **Single Responsibility:** Every class, module, and function must have exactly ONE reason to change. If a class handles both data access AND business logic, split it.
+2. **Open/Closed:** Software entities must be open for extension but closed for modification. Use abstract base classes, interfaces, and strategy patterns.
+3. **Liskov Substitution:** Derived classes must be fully substitutable for their base classes. Never violate base class contracts.
+4. **Interface Segregation:** Many small, focused interfaces are better than one large, general-purpose interface. No client should be forced to depend on methods it does not use.
+5. **Dependency Inversion:** Depend on abstractions, not concretions. Inject dependencies — never instantiate collaborators directly inside business logic.
+
+### SRP (Single Responsibility Pattern) — CRITICAL
+- Repository classes: data access ONLY
+- Service classes: business logic ONLY
+- Validator classes: validation rules ONLY
+- Model classes: data structures ONLY
+- If any module mixes these concerns, REFACTOR immediately
+
+### Code Structure
+{project_structure}
+
+### Language
+ALL code, comments, docstrings, variable names, function names, and commit messages MUST be in English. No exceptions.
+
+## FILES TO CREATE/MODIFY
+{file_list}
+
+## ACCEPTANCE CRITERIA
+{criteria}
+
+## COMMIT
+When done, commit each logical change separately with descriptive English commit messages following conventional commits format.
+```
+
+## Rules
+
+1. **Codex runs the code** — Anubis directs, Codex executes
+2. **SOLID + SRP in every prompt** — never assume Codex will follow them otherwise
+3. **Always use `pty=true`** — Codex is interactive, hangs without PTY
+4. **Background for non-trivial tasks** — use `background=true` + `notify_on_complete=true`
+5. **Verify after execution** — don't trust Codex blindly; check git diff
+6. **English only** — prompts, expectations, verification. All in English.
+7. **Respect palbox context** — always include relevant architecture/methods/history in the prompt

package/skills/astralym/SKILL.md

@@ -0,0 +1,111 @@
+---
+name: astralym
+description: "Core state machine orchestrator for the palskills development system. Routes user prompts through CHECK_GRAPH → PLANNING → DEVELOPING → RECORDING states across an Obsidian-like knowledge graph."
+version: 1.1.0
+author: Palskills
+license: MIT
+platforms: [linux, macos, windows]
+metadata:
+  hermes:
+    tags: [palskills, state-machine, orchestrator, knowledge-graph, development-workflow]
+    related_skills: [lyleen, jetdragon, anubis, panthalus]
+---
+
+# Astralym — State Machine Core
+
+Astralym is the central orchestrator of the palskills development system. It routes every user prompt through a strict pipeline, treating the **palbox as a knowledge graph** where every `.md` file is a node connected by `[[wikilinks]]`.
+
+## The Knowledge Graph Pipeline
+
+```
+                        ┌──────────────────────┐
+     user prompt        │                      │
+   ───────────────────► │    CHECK_GRAPH        │
+                        │    (Lyleen)           │
+                        │                      │
+                        │  .palbox/ missing?    │
+                        │  → bootstrap graph    │
+                        │  .palbox/ exists?     │
+                        │  → traverse wikilinks │
+                        │  → return subgraph    │
+                        └──────────┬───────────┘
+                                   │
+                         context subgraph
+                         (seeds + neighbors)
+                                   │
+                                   ▼
+                        ┌──────────────────────┐
+                        │    PLANNING           │
+                        │    (Jetdragon)        │
+                        │                      │
+                        │  → study subgraph     │
+                        │  → ask questions      │
+                        │  → generate plan      │
+                        │    with [[wikilinks]] │
+                        └──────────┬───────────┘
+                                   │
+                         user says "Gas"
+                                   │
+                                   ▼
+                        ┌──────────────────────┐
+                        │    DEVELOPING         │
+                        │    (Anubis → Codex)   │
+                        │                      │
+                        │  → build Codex prompt │
+                        │  → codex exec         │
+                        │  → verify output      │
+                        └──────────┬───────────┘
+                                   │
+                         code committed
+                                   │
+                                   ▼
+                        ┌──────────────────────┐
+                        │    RECORDING          │
+                        │    (Panthalus)        │
+                        │                      │
+                        │  → create history node│
+                        │  → add [[wikilinks]]  │
+                        │  → create backlinks   │
+                        │  → enrich the graph   │
+                        └──────────┬───────────┘
+                                   │
+                                   ▼
+                        ┌──────────────────────┐
+                        │    DONE              │
+                        │    (Report + stats)  │
+                        └──────────────────────┘
+```
+
+## States
+
+| State | Skill | Action |
+|-------|-------|--------|
+| `CHECK_GRAPH` | Lyleen | Bootstrap if missing; traverse `[[wikilinks]]` → context subgraph |
+| `PLANNING` | Jetdragon | Study subgraph → generate plan with `[[wikilinks]]` → ask questions |
+| `DEVELOPING` | Anubis → Codex | Build Codex prompt from plan → `codex exec` → verify |
+| `RECORDING` | Panthalus | Create history node → add `[[wikilinks]]` → create backlinks → enrich graph |
+| `DONE` | Astralym | Report summary + graph stats; return to IDLE |
+
+## Palbox Knowledge Graph Structure
+
+```
+.palbox/
+├── README.md              # Root node — [[architecture]], [[methods]]
+├── architecture.md         # Codebase map — [[methods]], [[flows/*]]
+├── methods.md              # Conventions — [[architecture]], [[history/*]]
+├── flows/                  # Feature docs — [[architecture]], [[methods]], [[history/*]]
+│   └── *.md
+├── plans/                  # Active plans — [[flows/*]], [[history/*]]
+│   └── YYYY-MM-DD-*.md
+└── history/                # Session records — [[flows/*]], [[architecture]], [[methods]]
+    └── YYYY-MM-DD-*.md
+```
+
+## Rules
+
+1. **Never skip states** — every prompt flows through the full pipeline
+2. **Graph is source of truth** — always traverse before planning
+3. **User approval is gate** — DEVELOPING only after "Gas"
+4. **Recording is mandatory** — every session enriches the graph
+5. **Links over repetition** — use `[[wikilinks]]` instead of duplicating content
+6. **Bidirectional links** — every edge should have a backlink (Panthalus enforces this)

package/skills/jetdragon/SKILL.md

@@ -0,0 +1,127 @@
+---
+name: jetdragon
+description: "Planning specialist — asks clarifying questions, generates detailed plans with [[wikilinks]] to palbox context, and produces Codex-ready prompts."
+version: 1.1.0
+author: Palskills
+license: MIT
+platforms: [linux, macos, windows]
+metadata:
+  hermes:
+    tags: [palskills, planning, clarification, wikilinks, knowledge-graph]
+    related_skills: [astralym, lyleen, anubis, panthalus]
+---
+
+# Jetdragon — Planning & Clarification
+
+Jetdragon is the **planning engine** of the palskills system. It receives a context subgraph from **Lyleen** (not just flat context — a connected graph of palbox nodes with `[[wikilinks]]`) and produces a detailed implementation plan. It **asks questions** until the plan is crystal clear.
+
+## Philosophy
+
+> A bad plan produces bad code. Jetdragon's job is to eliminate ambiguity before a single line of code is written.
+
+Per the user's convention: **brainstorming dulu, baru kode**. Jetdragon embodies this — it will not hand off to Anubis until the user explicitly says "Gas".
+
+## How It Works
+
+### Step 1: Absorb the Knowledge Graph
+
+Jetdragon receives from Lyleen:
+- The user's original prompt
+- A **context subgraph** — seed nodes + their wikilink neighbors (1-2 hops)
+
+Example subgraph:
+```
+Seed: [[flows/auth-login]]
+  ├── [[architecture]] → Auth module in `src/auth/`
+  ├── [[methods]] → JWT + refresh token pattern
+  ├── [[history/2026-07-10-jwt-refresh]] → Previous JWT work
+  └── [[history/2026-06-28-session-store]] → Session storage refactor
+```
+
+### Step 2: Generate Initial Plan with Wikilinks
+
+Create `.palbox/plans/YYYY-MM-DD-feature-name.md`:
+
+```markdown
+# Plan: [Feature Name]
+**Date:** YYYY-MM-DD
+**Status:** DRAFT — awaiting user feedback
+
+## Knowledge Graph Context
+- [[flows/auth-login]] — This plan extends the auth flow
+- [[architecture]] — Relevant module: `src/auth/`
+- [[methods]] — Follows JWT conventions
+- [[history/2026-07-10-jwt-refresh]] — Builds on previous JWT work
+
+## Overview
+[2-3 sentences describing what will be built]
+
+## Scope
+- **In scope:** ...
+- **Out of scope:** ...
+
+## Tasks (ordered)
+### Task 1: [Name]
+- **What:** ...
+- **Files to touch:** ...
+- **Linked context:** [[architecture]], [[methods]]
+- **Verification:** ...
+
+### Task 2: [Name]
+...
+
+## Open Questions
+1. ???
+2. ???
+```
+
+### Step 3: Ask Clarifying Questions
+
+Jetdragon **must** ask when ambiguous. Categories:
+- **Scope** — "Should this also handle X?"
+- **Design** — "Class-based or functional?"
+- **Edge cases** — "What happens when input is empty?"
+- **Integration** — "Does this need to integrate with [[flows/payment]]?"
+- **Priority** — "Which task first?"
+
+### Step 4: Iterate Until Clear
+
+Cycle: user responds → Jetdragon updates plan → asks more → repeat.
+
+Ends when: user says **"Gas"**, **"Go"**, **"Execute"**.
+
+### Step 5: Finalize & Hand Off
+
+- Status → `APPROVED`
+- Add `## Codex Prompt` section (self-contained, English, includes linked context summaries)
+- Hand off to **Anubis**
+
+## Codex-Ready Output
+
+Every plan includes a **Codex Prompt** section:
+
+```markdown
+## Codex Prompt
+
+[Self-contained prompt in English]
+
+Context from palbox:
+- Architecture: [[architecture]] → auth module in src/auth/, uses Repository pattern
+- Methods: [[methods]] → JWT with refresh tokens, pytest for testing
+- Past work: [[history/2026-07-10-jwt-refresh]] → existing refresh rotation logic
+
+Task: [what to build]
+SOLID + SRP requirements: [enforced]
+Files: [list]
+Verification: [criteria]
+```
+
+## Rules
+
+1. **Never skip questions** — ambiguous = ask
+2. **Plan before code** — wait for "Gas"
+3. **Save to `.palbox/plans/`** with `[[wikilinks]]` to context
+4. **Respect the graph** — plans align with linked architecture/methods
+5. **One plan per feature**
+6. **Always include Codex Prompt** — Anubis needs it
+7. **Link context, don't repeat** — use `[[wikilinks]]` instead of copy-pasting

package/skills/lyleen/SKILL.md

@@ -0,0 +1,243 @@
+---
+name: lyleen
+description: "Palbox knowledge graph reader & bootstrapper — creates .palbox/ if missing, then traverses [[wikilinks]] to retrieve connected context like an Obsidian vault."
+version: 3.0.0
+author: Palskills
+license: MIT
+platforms: [linux, macos, windows]
+metadata:
+  hermes:
+    tags: [palskills, palbox, knowledge-graph, wikilinks, context-retrieval, bootstrapper]
+    related_skills: [astralym, jetdragon, anubis, panthalus]
+---
+
+# Lyleen — Knowledge Graph Reader & Bootstrapper
+
+Lyleen is the **gatekeeper** of the palskills knowledge graph. The palbox is an Obsidian-style interconnected vault where every `.md` file is a **node** and `[[wikilinks]]` form the **edges**. When invoked, Lyleen first checks whether `.palbox/` exists — if not, it bootstraps the entire graph from the codebase. Once the graph exists, Lyleen traverses wikilinks to retrieve a **context subgraph** relevant to the user's prompt.
+
+## Palbox as a Knowledge Graph
+
+```
+                    .palbox/
+                        │
+              ┌─────────┼──────────┐
+              ▼         ▼          ▼
+         README.md  architecture  methods.md
+              │         │              │
+         [[architecture]]  [[methods]]   [[flows/auth]]
+         [[methods]]       [[flows/*]]   [[history/*]]
+              │         │              │
+              └────┬────┴──────┬───────┘
+                   │           │
+                   ▼           ▼
+               flows/      history/
+              auth.md     2026-07-19-login.md
+                 │              │
+            [[methods]]    [[flows/auth]]
+            [[history/*]]  [[architecture]]
+```
+
+**Nodes** = `.md` files. **Edges** = `[[wikilinks]]` between them.
+
+## How It Works
+
+### Step 1: Check if Palbox Exists
+
+```bash
+ls .palbox/ 2>/dev/null
+```
+
+### Step 2a: Palbox Missing → BOOTSTRAP
+
+If `.palbox/` does NOT exist, Lyleen creates the knowledge graph from scratch.
+
+#### Bootstrap Process
+
+**1. Create the folder structure:**
+
+```bash
+mkdir -p .palbox/{flows,history,plans}
+```
+
+**2. Analyze the codebase:**
+
+```bash
+find . -maxdepth 2 -type d ! -path './.git/*' ! -path './node_modules/*' ! -path './__pycache__/*' ! -path './.venv/*' | sort
+ls -la package.json requirements.txt pyproject.toml go.mod Cargo.toml 2>/dev/null
+cat README.md 2>/dev/null
+git log --oneline --since="3 months ago" | head -20
+find . -name '*test*' -o -name '*spec*' | head -20
+```
+
+**3. Create interconnected core documents with wikilinks:**
+
+`.palbox/README.md` — the root node, links to everything:
+```markdown
+# [Project Name]
+
+**Generated:** YYYY-MM-DD
+**Bootstrapped by:** Lyleen (palskills)
+
+## Overview
+[Brief description]
+
+## Tech Stack
+- **Language:** [...]
+- **Framework:** [...]
+- **Database:** [...]
+
+## Knowledge Graph
+- [[architecture]] — folder structure & design patterns
+- [[methods]] — coding conventions & standards
+- [[flows/]] — feature workflow documentation
+- [[history/]] — past development sessions
+```
+
+`.palbox/architecture.md` — codebase map:
+```markdown
+# Architecture
+
+**Last Updated:** YYYY-MM-DD
+
+## Folder Structure
+```
+[annotated tree]
+```
+
+## Design Patterns
+[Patterns detected]
+
+## Key Modules
+| Module | Responsibility |
+|--------|---------------|
+| ... | ... |
+
+## Related
+- [[methods]] — how we build
+- [[README]] — project overview
+```
+
+`.palbox/methods.md` — conventions:
+```markdown
+# Development Methods
+
+**Last Updated:** YYYY-MM-DD
+
+## Coding Conventions
+[...]
+
+## Testing Strategy
+[...]
+
+## Git Workflow
+[...]
+
+## Related
+- [[architecture]] — where things live
+- [[README]] — project overview
+```
+
+**4. Report:**
+
+```
+## Palbox Knowledge Graph Bootstrapped ✓
+
+Created `.palbox/` with interconnected nodes:
+- [[README]] — root node, links to all core docs
+- [[architecture]] — codebase map ↔ [[methods]]
+- [[methods]] — conventions ↔ [[architecture]]
+- `flows/` — (empty) ready for feature docs
+- `history/` — (empty) ready for session records
+
+Graph has [N] nodes and [M] edges.
+```
+
+### Step 2b: Palbox Exists → TRAVERSE
+
+**Phase 1: Seed Discovery**
+
+Find palbox entries that directly match the user's prompt keywords:
+
+```bash
+grep -ril "<keyword1>\|<keyword2>" .palbox/ --include="*.md" | head -10
+```
+
+Each matching file is a **seed node**.
+
+**Phase 2: Graph Traversal**
+
+For each seed node, extract all `[[wikilinks]]` and follow them 1-2 hops:
+
+```python
+# Pseudo-code for link traversal
+visited = set()
+queue = seed_nodes
+
+for node in queue:
+    visited.add(node)
+    content = read(".palbox/" + node)
+    links = extract_wikilinks(content)  # regex: \[\[([^\]]+)\]\] 
+    for link in links:
+        resolved = resolve_link(link)  # handle paths, .md extension
+        if resolved not in visited:
+            queue.append(resolved)
+            if depth > max_depth: break
+```
+
+**Phase 3: Build Context Subgraph**
+
+Return the connected subgraph as structured context:
+
+```
+## Palbox Context (Knowledge Graph)
+
+### Seed: [[flows/auth-login]]
+Matched: "login", "authentication"
+
+### Linked Nodes (1 hop)
+- [[architecture]] — Auth module lives in `src/auth/`
+- [[methods]] — Uses JWT + refresh token pattern
+
+### Linked Nodes (2 hops)  
+- [[history/2026-07-10-jwt-refresh]] — Previous JWT refresh work
+- [[history/2026-06-28-session-store]] — Session storage refactor
+
+### Graph Summary
+- **Nodes traversed:** 5
+- **Relevant past work:** 2 sessions
+- **Conventions found:** JWT pattern, testing with pytest
+```
+
+**Phase 4: Deliver**
+
+Return the subgraph to Astralym/Jetdragon. The context is now **relational** — not just a flat list of files, but a connected graph of knowledge.
+
+## Wikilink Conventions
+
+| Syntax | Meaning |
+|--------|---------|
+| `[[architecture]]` | Links to `.palbox/architecture.md` |
+| `[[methods]]` | Links to `.palbox/methods.md` |
+| `[[flows/auth]]` | Links to `.palbox/flows/auth.md` |
+| `[[history/2026-07-19-feature]]` | Links to a specific history entry |
+| `[[methods#testing-strategy]]` | Links to a heading within a page |
+| `[[architecture|see architecture]]` | Aliased link (display text differs) |
+
+## Traversal Rules
+
+1. **Max depth: 2 hops** — enough for context, prevents graph explosion
+2. **Bidirectional awareness** — if A links to B, treat B's link to A as redundant
+3. **Prioritize seeds** — direct matches are primary; linked nodes are supporting
+4. **Skip cycles** — `visited` set prevents infinite loops
+5. **Highlight orphans** — if a seed has no wikilinks, flag it so user can enrich
+
+## Rules
+
+1. **Bootstrap if missing** — never return "palbox not found"; create the graph
+2. **Analyze before writing** — read actual files, don't guess
+3. **Traverse wikilinks** — context retrieval is graph traversal, not grep
+4. **Return subgraphs** — provide related nodes, not isolated files
+5. **Max 2 hops** — enough context without noise
+6. **Report graph stats** — nodes traversed, links followed, orphans found
+7. **Bootstrap is one-time** — subsequent calls traverse the existing graph
+8. **Bidirectional links matter** — Panthalus maintains them; Lyleen exploits them

package/skills/panthalus/SKILL.md

@@ -0,0 +1,201 @@
+---
+name: panthalus
+description: "Palbox knowledge graph archivist — records sessions with bi-directional [[wikilinks]], creating a traversable Obsidian-like vault of development history."
+version: 2.0.0
+author: Palskills
+license: MIT
+platforms: [linux, macos, windows]
+metadata:
+  hermes:
+    tags: [palskills, palbox, knowledge-graph, wikilinks, archivist]
+    related_skills: [astralym, lyleen, jetdragon, anubis]
+---
+
+# Panthalus — Knowledge Graph Archivist
+
+Panthalus is the **graph builder** of the palskills system. After every development session, it records what was done — not as an isolated file, but as a **node** in the palbox knowledge graph, connected via `[[wikilinks]]` to related entries. It also **backlinks** — updating existing nodes to point to the new entry, maintaining a bidirectional graph.
+
+## The Graph Philosophy
+
+```
+Before Panthalus:          After Panthalus:
+
+[[flows/auth]]                 [[flows/auth]]
+     │                              │
+     └── (no links)                 ├── [[history/2026-07-19-login]]
+                                    │         │
+[[architecture]]                [[architecture]]
+     │                              │
+     └── (no links)                 └── [[history/2026-07-19-login]]
+
+                              [[history/2026-07-19-login]]
+                                    │
+                                    ├── [[flows/auth]]
+                                    ├── [[architecture]]
+                                    └── [[methods]]
+```
+
+Every session enriches the graph. Nodes gain connections. Orphans get adopted.
+
+## How It Works
+
+### Step 1: Collect Artifacts
+
+After Anubis/Codex completes:
+
+```bash
+git log --oneline --since="1 hour ago"
+git diff --stat HEAD~1
+```
+
+Collect: plan, files changed, commits, decisions, lessons.
+
+### Step 2: Identify Related Nodes
+
+Find existing palbox entries that relate to this session:
+
+```bash
+# Search for related flows, patterns, past work
+grep -ril "<feature_keywords>" .palbox/flows/ .palbox/history/ 2>/dev/null
+```
+
+These become the **link targets** for the new entry.
+
+### Step 3: Create History Node with Wikilinks
+
+Create `.palbox/history/YYYY-MM-DD-feature-name.md`:
+
+```markdown
+# [Feature Name]
+**Date:** YYYY-MM-DD
+**Executor:** Codex CLI
+
+## Links
+- [[flows/auth]] — Authentication flow this feature extends
+- [[architecture]] — Auth module in `src/auth/`
+- [[methods]] — JWT + testing conventions followed
+- [[history/2026-07-10-jwt-refresh]] — Previous JWT work this builds on
+
+## Original Prompt
+> [user's original prompt]
+
+## Plan
+[approved plan from Jetdragon]
+
+## Codex Execution
+### Prompt Sent
+``` [Codex prompt] ```
+
+### Files Changed
+- `path/to/file.py` — [what was done]
+- `path/to/another.py` — [what was done]
+
+### Commits
+- `abc1234` feat(scope): description
+- `def5678` test(scope): description
+
+## Key Decisions
+| Decision | Rationale |
+|----------|-----------|
+| ... | ... |
+
+## Lessons Learned
+- **Pitfall:** ...
+- **Discovery:** ...
+- **Codex quirk:** ...
+
+## Backlinks
+*The following entries now link here:*
+- [[flows/auth]] — updated with link to this session
+- [[history/2026-07-10-jwt-refresh]] — updated with "see also" link
+```
+
+### Step 4: Create Backlinks (CRITICAL)
+
+For every `[[link]]` in the history entry, Panthalus **must** add a reciprocal link back:
+
+```bash
+# For each linked file, append a backlink
+echo "- [[history/2026-07-19-feature]] — [one-line summary]" >> .palbox/flows/auth.md
+```
+
+**Backlink format:**
+```markdown
+## Related Sessions
+- [[history/2026-07-19-login-fix]] — Fixed login edge case with expired tokens
+- [[history/2026-07-10-jwt-refresh]] — Implemented JWT refresh rotation
+```
+
+If the target file doesn't have a "Related Sessions" section, create one at the bottom.
+
+### Step 5: Update Core Docs (If Structure Changed)
+
+Only when architecture or methods fundamentally change:
+
+- `.palbox/architecture.md` — new modules, pattern shifts
+- `.palbox/methods.md` — new conventions emerged
+
+Add the change AND link to the history entry that caused it:
+```markdown
+## Changelog
+- [[history/2026-07-19-feature]] — Added `src/cache/` module for Redis caching layer
+```
+
+### Step 6: Report
+
+```
+## Knowledge Graph Updated
+
+**New node:** [[history/2026-07-19-feature]]
+**Edges created:** 6 (3 outgoing, 3 backlinks)
+**Nodes enriched:** [[flows/auth]], [[architecture]], [[history/2026-07-10-jwt-refresh]]
+
+**Graph health:**
+- Total nodes: 12
+- Total edges: 34
+- Orphan nodes: 0
+- Avg. degree: 2.8
+```
+
+## Graph Health Checks
+
+Every ~5 sessions, Panthalus should audit the graph:
+
+```bash
+# Find orphan nodes (no incoming links)
+for f in .palbox/history/*.md; do
+  name=$(basename "$f" .md)
+  grep -rl "\[\[history/$name\]\]" .palbox/ | wc -l
+done
+
+# Find broken links
+grep -roh '\[\[[^]]*\]\]' .palbox/ | sed 's/\[\[//;s/\]\]//' | while read link; do
+  # Resolve and check if file exists
+done
+```
+
+Flag:
+- **Orphans** — history entries with no backlinks (nothing points to them)
+- **Dead ends** — entries with no outgoing links
+- **Broken links** — wikilinks pointing to non-existent files
+
+## Wikilink Conventions
+
+| Syntax | Usage |
+|--------|-------|
+| `[[flows/feature-name]]` | Link to a flow document |
+| `[[history/YYYY-MM-DD-name]]` | Link to a past session |
+| `[[architecture]]` | Link to architecture doc |
+| `[[methods]]` | Link to methods doc |
+| `[[README]]` | Link to project overview |
+
+## Rules
+
+1. **Record EVERY session** — no exceptions
+2. **Always create bi-directional links** — outgoing + backlinks
+3. **Enrich, don't duplicate** — link to existing docs instead of repeating them
+4. **Backlink section** — every linked file gets a `## Related Sessions` entry
+5. **Graph health** — audit every ~5 sessions
+6. **No orphan nodes** — every history entry must have at least one incoming link
+7. **Preserve the plan** — full plan in history, not summarized
+8. **Codex metadata** — capture flags, iterations, prompt patterns