@olegkoval/agent-skills 1.17.0 → 1.18.0

package/packages/software-development/product-builder/adapters/grok/skills/product-builder/SKILL.md

@@ -0,0 +1,224 @@
+---
+name: product-builder
+description: Use when a user asks to build a full-stack web application, SaaS product, dashboard, or any complete working app from a description. Generates production-ready code with auth, database, API, UI, and tests instead of asking clarifying questions. Activates on "build me X", "create an app that", or any product-building request.
+license: MIT
+allowed-tools: Bash, Read, Write, Edit, WebSearch, WebFetch
+compatibility: Codex, Claude Code, Cursor, GitHub Copilot, Windsurf, Kiro, and other Agent Skills compatible tools. Requires a writable application repository and a stack compatible with the generated implementation.
+metadata:
+  targets: [_source-only]
+  author: Oleg Koval
+  tags:
+    - product
+    - full-stack
+    - saas
+    - web-app
+    - builder
+    - nextjs
+---
+<!-- Generated by scripts/build-adapters.sh. Do not edit directly. -->
+
+# Product Builder
+
+You are a full-stack product builder. Your goal: **build real, working products — not prototypes**.
+
+## Core Philosophy
+
+- **Ship immediately** — No explanations, no questions about architecture. Code first.
+- **Full-stack defaults** — Every product includes auth, database, APIs, and UI.
+- **Real code patterns** — Use production-ready patterns, not toy examples.
+- **Minimal diffs** — Change only what's necessary. Respect existing code.
+
+## When a user asks to "build X"
+
+You MUST:
+1. Generate a working product, not a skeleton
+2. Include authentication
+3. Include database schema with migrations
+4. Include API routes with input validation
+5. Include a polished, responsive UI
+6. Include tests
+
+You MUST NOT:
+- Ask "what framework do you want?"
+- Ask "should we use a database?"
+- Ask "how many features?"
+- Create TODO comments for later implementation
+
+## Default Tech Stack
+
+| Layer | Technology |
+|-------|-----------|
+| **Framework** | Next.js 14 (App Router) |
+| **Language** | TypeScript (strict) |
+| **Styling** | Tailwind CSS + shadcn/ui |
+| **Database** | Prisma + PostgreSQL |
+| **Auth** | NextAuth.js |
+| **Validation** | Zod |
+| **State** | React Query + Zustand |
+| **Testing** | Vitest + React Testing Library + Playwright |
+
+The user can override any of these. If the project already uses a different stack, follow the existing stack.
+
+## Specialist Domains
+
+When building a product, apply expertise from these domains as needed:
+
+### UI Design
+- Tailwind CSS utility-first, mobile-first responsive
+- shadcn/ui components over custom solutions
+- Dark mode support with `class` strategy
+- Accessibility: semantic HTML, ARIA labels, keyboard nav, WCAG AA contrast
+- Animations with Framer Motion or CSS transitions
+- Component pattern: `cn()` utility for conditional classes
+
+### Database Architecture
+- Prisma schema with proper indexes and relations
+- Multi-tenant patterns when applicable (org-scoped data)
+- Referential integrity and cascade rules
+- Query optimization: use `select` and `include` deliberately
+- Migration strategy: always generate and review migrations
+- Audit fields: `createdAt`, `updatedAt` on every model
+
+### API Design
+- Consistent response format: `{ success: true, data }` / `{ success: false, error: { code, message } }`
+- Zod validation schemas for all inputs
+- Proper HTTP status codes (201 for creation, 400 for validation, 401/403 for auth)
+- Pagination: `page`, `limit`, `total`, `totalPages`
+- Rate limiting for public endpoints
+- Server Actions for form submissions
+
+### Testing
+- Vitest for unit and integration tests
+- React Testing Library for component tests
+- Playwright for E2E tests
+- Test critical paths: auth flows, CRUD operations, edge cases
+- Mock external services, not internal code
+- Factories/fixtures for test data
+
+## Code Quality Standards
+
+- TypeScript strict mode, no `any` types without justification
+- Error boundaries and proper error handling at every layer
+- Security-first: validate inputs, sanitize outputs, check permissions
+- Performance: memoize expensive renders, optimize queries, pagination
+- Accessibility: semantic HTML, ARIA labels, keyboard navigation
+
+## File Organization
+
+```
+app/
+  (auth)/              # Auth routes group
+    login/page.tsx
+    register/page.tsx
+  (app)/               # Protected routes group
+    dashboard/page.tsx
+    settings/page.tsx
+  api/                 # API routes
+    auth/route.ts
+    [resource]/route.ts
+  actions/             # Server actions
+lib/
+  db.ts                # Database client
+  auth.ts              # Auth config
+  api-response.ts      # Response helpers
+  validation.ts        # Zod schemas
+components/
+  ui/                  # shadcn/ui components
+  forms/               # Form components
+  layouts/             # Layout components
+prisma/
+  schema.prisma
+  migrations/
+__tests__/
+  unit/
+  integration/
+  e2e/
+```
+
+## API Response Pattern
+
+```typescript
+// lib/api-response.ts
+export type ApiResponse<T = unknown> =
+  | { success: true; data: T }
+  | { success: false; error: { code: string; message: string; details?: Record<string, string[]> } };
+
+export function successResponse<T>(data: T): ApiResponse<T> {
+  return { success: true, data };
+}
+
+export function errorResponse(code: string, message: string, details?: Record<string, string[]>): ApiResponse<never> {
+  return { success: false, error: { code, message, details } };
+}
+```
+
+## Route Handler Pattern
+
+```typescript
+// app/api/posts/route.ts
+import { NextRequest, NextResponse } from 'next/server';
+import { z } from 'zod';
+import { prisma } from '@/lib/db';
+import { auth } from '@/lib/auth';
+import { successResponse, errorResponse } from '@/lib/api';
+
+const createPostSchema = z.object({
+  title: z.string().min(1).max(200),
+  content: z.string().min(1),
+  status: z.enum(['DRAFT', 'PUBLISHED']).default('DRAFT'),
+});
+
+export async function POST(request: NextRequest) {
+  const session = await auth();
+  if (!session?.user) {
+    return NextResponse.json(errorResponse('UNAUTHORIZED', 'Authentication required'), { status: 401 });
+  }
+
+  const body = await request.json();
+  const result = createPostSchema.safeParse(body);
+
+  if (!result.success) {
+    return NextResponse.json(
+      errorResponse('VALIDATION_ERROR', 'Invalid input', result.error.flatten().fieldErrors),
+      { status: 400 },
+    );
+  }
+
+  const post = await prisma.post.create({
+    data: { ...result.data, authorId: session.user.id },
+  });
+
+  return NextResponse.json(successResponse(post), { status: 201 });
+}
+```
+
+## Component Pattern
+
+```typescript
+import { cn } from '@/lib/utils';
+
+interface CardProps extends React.HTMLAttributes<HTMLDivElement> {
+  children: React.ReactNode;
+}
+
+export function Card({ className, ...props }: CardProps) {
+  return (
+    <div
+      className={cn(
+        'rounded-lg border border-slate-200 bg-white p-6 shadow-sm',
+        'dark:border-slate-800 dark:bg-slate-950',
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+```
+
+## When Stuck or Uncertain
+
+Do not ask the user. Execute using best practices from the relevant domain. Default to the simplest solution that works.
+
+## Example Prompts
+
+See [examples.md](examples.md) for ready-to-use prompts covering SaaS dashboards, e-commerce, project management, AI chat apps, and more.

package/packages/software-development/promptctl/adapters/grok/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "olko:promptctl",
+  "version": "0.1.0",
+  "description": "Use promptctl for template-based prompt engineering, scoring, and workflow automation.",
+  "skills": "skills/"
+}

package/packages/software-development/promptctl/adapters/grok/skills/promptctl/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: promptctl
+description: Use promptctl for template-based prompt engineering, prompt scoring, prompt generation, and reusable prompt workflows across repositories and teams.
+license: MIT
+allowed-tools: Bash, Read, Write
+compatibility: Codex, Claude Code, Cursor, GitHub Copilot, Windsurf, Kiro, and other Agent Skills compatible tools. Requires promptctl to be installed when the workflow depends on the CLI.
+metadata:
+  targets: [_source-only]
+  author: Oleg Koval
+  tags:
+    - prompts
+    - prompt-engineering
+    - templates
+    - cli
+---
+<!-- Generated by scripts/build-adapters.sh. Do not edit directly. -->
+
+# promptctl — Template-Based Prompt Engineering
+
+promptctl is a CLI for version control and testing of LLM prompt templates. It treats prompts like code: template them, version them, score them, and share them across your team.
+
+## When to suggest promptctl
+
+Suggest using promptctl when the user:
+- Repeatedly copies the same type of prompt (code review, debug analysis, architecture notes)
+- Wants to share prompt conventions across a team or repo
+- Needs CI/CD gates on prompt quality
+- Wants to improve prompt quality without an LLM (offline rule-based enhance)
+- Asks about structuring or scoring a prompt
+
+## Core commands
+
+```
+promptctl review --file=src/auth.ts          # Code review prompt
+promptctl debug --file=src/handler.go        # Systematic debug analysis
+promptctl arch --file=docs/design.md         # Architecture decision record
+promptctl commit                             # Conventional commit message
+promptctl explain --file=src/parser.ts       # Code explanation
+
+promptctl list                               # See all available templates
+promptctl score prompts/                     # Score prompt files 0-100
+promptctl fix prompts/                       # Auto-fix low-scoring prompts
+promptctl create "review auth for security"  # Create prompt from raw intent (offline)
+```
+
+## Pi integration commands
+
+When the user is inside pi:
+- `/promptctl review --file=src/auth.ts` — renders the review template and injects it as the next user message
+- `/quick-templates` — lists all available templates
+- `/cost-score <file>` — scores a prompt file on structure and clarity
+- The `promptctl_apply` tool can be called by the LLM directly to render a template
+
+## Key capabilities
+
+- Templates are YAML files with `{{.variable}}` substitution — stored in `~/.promptctl/templates/` or `.promptctl/templates/` in your project
+- `--file=path` auto-populates `{{.file_content}}`, `{{.file_name}}`, `{{.file_ext}}`
+- Prompt scoring (0–100) on: structure, clarity, constraints, persona
+- Offline rule-based enhance (`promptctl create`) — no API key or network needed
+- JSON output and exit codes for CI pipelines (`promptctl score --min-score=80`)
+- Direct LLM send (`promptctl send review --file=main.go`) with Anthropic/OpenAI support
+
+## Example workflows
+
+**Code review in pi:**
+```
+/promptctl review --file=src/payments.ts --focus=security
+```
+
+**Debug analysis:**
+```
+/promptctl debug --file=src/worker.go --error="context deadline exceeded"
+```
+
+**Improve a prompt file:**
+```
+promptctl score my-prompt.md
+promptctl fix my-prompt.md
+```
+
+**Create a new structured prompt from intent (offline):**
+```
+promptctl create "analyze this Go function for race conditions"
+```
+
+## Resources
+
+- GitHub: https://github.com/oleg-koval/promptctl
+- Website: https://prompt-ctl.com
+- Install: `brew tap oleg-koval/tap && brew install promptctl`

package/packages/software-development/relay/adapters/grok/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "olko:relay",
+  "version": "0.1.0",
+  "description": "Use claude-relay to run long or rate-limit-prone tasks autonomously across subscription accounts.",
+  "skills": "skills/"
+}

package/packages/software-development/relay/adapters/grok/skills/relay/SKILL.md

@@ -0,0 +1,117 @@
+---
+name: relay
+description: >
+  Use claude-relay to run a long or rate-limit-prone task autonomously across subscription accounts.
+  Invoke this skill whenever the user says "use relay", "run this with relay", "do this overnight",
+  "run this autonomously", "use relay for X", or has a multi-hour / multi-step task they want to
+  hand off completely. Also use proactively when a task looks like it will take many turns and the
+  user hasn't thought about rate limits yet. Guides goal writing, picks the right flags, and starts
+  the run.
+license: MIT
+allowed-tools: Bash, Read, Write
+metadata:
+  author: Oleg Koval
+  tags:
+    - relay
+    - autonomous
+    - rate-limits
+    - claude-relay
+---
+<!-- Generated by scripts/build-adapters.sh. Do not edit directly. -->
+
+# relay
+
+Runs a task **unattended** using `claude-relay`: drives `claude -p` in a headless loop, writes a
+handoff summary when one account's limit approaches, and switches to the next account automatically.
+You watch logs; relay handles the rest.
+
+Binary: `claude-relay` (alias `relay` if added to shell). Config: `~/.claude-relay/relay.config.json`.
+
+---
+
+## Step 1 — Decide: relay or inline?
+
+**Use relay when:**
+- Task will take many turns or hours (big refactor, migration, research + implementation)
+- The user wants to hand it off and walk away
+- Rate limits are a real concern (long-running or token-heavy)
+
+**Stay inline when:**
+- Task is quick (< ~10 turns)
+- User wants to review each step
+- Task needs interactive input that relay can't provide
+
+---
+
+## Step 2 — Write the goal
+
+A relay goal is a self-contained spec a fresh Claude agent can execute cold. Write it to
+`/tmp/relay-goal-<short-name>.md`. It must include:
+
+- **What to do** — concrete deliverables, not vague intent
+- **How to verify** — the exact command proving success (`npm test`, `curl /api/health`, etc.)
+- **Scope** — explicit list of what NOT to do (no commits, no PRs, no migrations — unless stated)
+- **Key files** — paths the agent should read first if the context isn't obvious
+
+**Template:**
+```markdown
+## Goal
+<1-3 sentences: the deliverable>
+
+## Success criteria
+Run `<command>` and confirm it exits 0 / returns the expected result.
+
+## Scope
+- DO: <explicit list>
+- DO NOT: open PRs / push commits / run migrations / touch unrelated files
+
+## Key files
+- <path> — <why it matters>
+```
+
+Good goals are specific. "Add input validation to all POST routes in `app/api/`" beats "improve the API".
+
+---
+
+## Step 3 — Pick flags
+
+| Situation | Flag |
+|-----------|------|
+| Task needs uncommitted changes, local `.env`, or a local database | `--in-place` |
+| Everything is committed; task is self-contained | *(default — isolated git worktree)* |
+
+When in doubt: if the repo has a `.env` or `node_modules` the task depends on, use `--in-place`.
+
+---
+
+## Step 4 — Run
+
+```bash
+claude-relay run /tmp/relay-goal-<name>.md <absolute-path-to-repo> [--in-place]
+```
+
+Relay logs stream to stderr. The run ends when the agent outputs `RELAY_TASK_COMPLETE` on its own
+line, or hits a hard cap (400 turns / 48h wall clock).
+
+---
+
+## Step 5 — Tell the user
+
+After starting, report:
+- The exact command you ran
+- What to watch for: `RELAY_TASK_COMPLETE` in logs, or `claude-relay status --config ~/.claude-relay/relay.config.json`
+- The flag you picked and why (especially if you chose `--in-place`)
+
+---
+
+## Health check
+
+If anything seems misconfigured:
+```bash
+claude-relay doctor --config ~/.claude-relay/relay.config.json
+```
+
+Should show ✓ for both account slots. If a slot shows ✗, tell the user to run:
+```bash
+claude-relay login <email>  # must have claude.ai open in browser as that account first
+```

package/packages/software-development/review-past-performance/adapters/grok/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "olko:review-past-performance",
+  "version": "0.1.0",
+  "description": "Self-improvement loop that pulls the last 24h of ICM memories, git history, and skill analytics to detect repeated mistakes, slow workflows, and missing coverage, then proposes 1-3 concrete improvements.",
+  "skills": "skills/"
+}

package/packages/software-development/review-past-performance/adapters/grok/skills/review-past-performance/SKILL.md

@@ -0,0 +1,212 @@
+---
+name: review-past-performance
+description: 'Self-improvement loop for coding sessions. Pulls the last 24h of ICM memories, git history, and available transcripts; detects patterns like repeated mistakes, slow workflows, untested changes, or missing skills; then proposes 1-3 concrete improvements (new skills, prompt tweaks, eval criteria). Nothing is written until you approve. Use when asked to "review my performance", "self-improve", "what am I repeating", "review past performance", or "what should I fix in my workflow".'
+license: MIT
+allowed-tools: Bash, Read, Write, Grep, Glob, AskUserQuestion
+compatibility: Claude Code, Codex, Cursor, and other Agent Skills compatible tools. Requires ICM (https://github.com/rtk-ai/icm) for memory recall; degrades gracefully to git log + gstack analytics when ICM is unavailable.
+metadata:
+  author: Oleg Koval
+  tags:
+    - self-improvement
+    - performance-review
+    - icm
+    - skills
+    - workflow
+    - ai-tools
+---
+<!-- Generated by scripts/build-adapters.sh. Do not edit directly. -->
+
+# /review-past-performance
+
+Self-improvement loop. Analyze recent sessions, find durable patterns, propose fixes.
+
+## Step 1 — Gather raw signals (run in parallel)
+
+```bash
+# A: ICM memories from last 24h
+icm recall "mistakes errors repeated workflow" --limit 10 2>/dev/null || echo "ICM_UNAVAILABLE"
+icm recall "completed task feature fix" --limit 10 2>/dev/null || echo "ICM_UNAVAILABLE"
+```
+
+```bash
+# B: Git activity last 24h across all repos the user works in
+git log --all --since="24 hours ago" --oneline --author="$(git config user.email 2>/dev/null)" 2>/dev/null | head -30 || echo "NO_GIT"
+```
+
+```bash
+# C: ICM transcripts (last 3 sessions)
+icm transcript search "" --limit 3 2>/dev/null || echo "TRANSCRIPTS_UNAVAILABLE"
+```
+
+```bash
+# D: Skill usage from gstack analytics (what skills were run, outcomes)
+tail -50 ~/.gstack/analytics/skill-usage.jsonl 2>/dev/null | jq -c 'select(.ts > (now - 86400 | todate))' 2>/dev/null || \
+  tail -50 ~/.gstack/analytics/skill-usage.jsonl 2>/dev/null | head -20 || echo "NO_ANALYTICS"
+```
+
+```bash
+# E: ICM errors-resolved topic (what broke and was fixed)
+icm recall "error" -t "errors-resolved" --limit 5 2>/dev/null || echo "NO_ERROR_MEMORIES"
+```
+
+```bash
+# F: Recent learnings (gstack)
+_GSTACK_HOME="${GSTACK_HOME:-$HOME/.gstack}"
+eval "$($HOME/.slate/skills/gstack/bin/gstack-slug 2>/dev/null)" 2>/dev/null || true
+_LEARN_FILE="$_GSTACK_HOME/projects/${SLUG:-unknown}/learnings.jsonl"
+[ -f "$_LEARN_FILE" ] && tail -20 "$_LEARN_FILE" || echo "NO_LEARNINGS"
+```
+
+## Step 2 — Synthesize patterns
+
+Read all signals. Classify findings into these categories:
+
+**Repeated mistakes** — same error, same fix, same confusion appearing more than once in the signals. E.g., always forgetting to handle null on a specific field, always hitting the same linting error.
+
+**Slow workflows** — multi-step sequences that took many tool calls but could be a single skill. E.g., always doing manual `git log` + `grep` + read 3 files before every PR review.
+
+**Missing coverage** — areas where work was done but no test was written or no memory was stored.
+
+**Underused skills** — skills that would have applied but were not invoked (check skill-usage.jsonl gaps vs. git activity).
+
+**Knowledge gaps** — concepts that came up repeatedly as questions or confusion.
+
+Score each finding:
+- **Frequency**: how many times it appeared (1 = once, 3 = three or more)
+- **Time cost**: rough estimate per occurrence (minutes)
+- **Fixability**: easy (a new skill/memory fixes it), medium (needs a process change), hard (structural)
+
+Pick the top 1-3 findings by `frequency × time_cost × fixability_inverse`.
+
+## Step 3 — Formulate proposals
+
+For each finding, produce exactly one proposal. Proposal types:
+
+**Type A — New skill**: The repeated sequence can be codified. Provide:
+- Proposed skill name (lowercase, dashes, ≤32 chars)
+- Trigger phrases (3-5)
+- 5-8 line SKILL.md workflow skeleton
+- Estimated time savings per occurrence
+
+**Type B — Skill tweak**: An existing skill is close but missing a step or check. Provide:
+- Which skill (`/skill-name`)
+- What specific text to add/change (before/after diff)
+- Why this covers the gap
+
+**Type C — ICM memory / eval criteria**: A pattern should be captured as a durable memory or eval rule. Provide:
+- `icm store` command (with topic, content, importance)
+- Or: a yes/no eval question to add to an existing skill
+
+## Step 4 — Present findings (D1)
+
+Use AskUserQuestion:
+
+```
+D1 — Performance review: N patterns found, N proposals
+Project/branch/task: 24h session review — git, ICM memories, skill analytics.
+ELI10: I looked at your last 24 hours of work: git commits, ICM memories,
+skill runs, and resolved errors. Here's what I found repeating and what
+I'd do about it. Approve proposals individually or skip any.
+Stakes if we pick wrong: skipping a proposal leaves the pattern unfixed;
+approving a bad proposal adds noise. You can always /skillify or rm a skill later.
+Recommendation: A — review each proposal and approve what resonates.
+Note: options differ in kind, not coverage — no completeness score.
+A) Walk me through each proposal (recommended)
+B) Show summary only, I'll decide what to dig into
+C) Abort — nothing to act on today
+```
+
+If B: print a one-line summary table (proposal number, type, finding, estimated savings). Stop.
+
+If C: print "No changes made. Run /review-past-performance again anytime." Stop.
+
+If A: proceed to Step 5.
+
+## Step 5 — Proposal gate (one per proposal)
+
+For each proposal (D2, D3, D4 ...):
+
+Print:
+```
+--- Proposal N of N ---
+Finding: <one sentence>
+Pattern evidence: <which signals showed this>
+Proposal type: <A/B/C>
+<full proposal detail from Step 3>
+Estimated savings: ~X min/occurrence
+```
+
+Then AskUserQuestion:
+
+```
+D<N> — Apply proposal N: <short title>?
+Project/branch/task: <finding in one sentence>
+ELI10: <plain English: what this proposes, what changes, what you gain>
+Stakes if we pick wrong: <what happens if you apply a bad one, or skip a good one>
+Recommendation: A — apply it — the evidence is clear enough to try it.
+Note: options differ in kind, not coverage — no completeness score.
+A) Apply this proposal (recommended)
+B) Skip this one
+C) Modify before applying (describe what to change)
+```
+
+If C: ask what to change, update the proposal in-memory, re-show, re-ask A/B only.
+
+## Step 6 — Execute approved proposals
+
+For each approved proposal:
+
+**Type A (new skill):**
+```bash
+mkdir -p ~/.claude/skills/<name>
+```
+Write `~/.claude/skills/<name>/SKILL.md` with the skeleton from Step 3.
+Print: "Skill /<name> created at ~/.claude/skills/<name>/SKILL.md — invoke it with /<name>."
+
+**Type B (skill tweak):**
+Read the target skill file. Apply the diff. Print the before/after. Do NOT commit.
+
+**Type C (ICM memory):**
+```bash
+icm store -t "<topic>" -c "<content>" -i <importance> -k "<keywords>"
+```
+Print the stored memory ID.
+
+## Step 7 — Summary
+
+After all proposals are processed, print a compact summary:
+
+```
+/review-past-performance complete
+Applied: N proposals
+Skipped: N proposals
+
+What changed:
+- [list each applied change with one line]
+
+Run again tomorrow: /review-past-performance
+```
+
+Then:
+```bash
+# Store this review run as an ICM memory so future reviews have continuity
+icm store -t "context-workflow" \
+  -c "Performance review $(date +%Y-%m-%d): found [N] patterns, applied [N] proposals. Key findings: [one-line summary]" \
+  -i medium \
+  -k "performance-review,self-improvement" 2>/dev/null || true
+```
+
+```bash
+# Log to gstack timeline if available
+~/.slate/skills/gstack/bin/gstack-timeline-log \
+  '{"skill":"review-past-performance","event":"completed","outcome":"success"}' 2>/dev/null || true
+```
+
+---
+
+## Notes
+
+- This skill reads only — no git mutations, no PR actions, no Notion/Linear writes.
+- Type A skills created here are skeletons. Run them once and tune before relying on them.
+- If ICM is unavailable (`ICM_UNAVAILABLE`), fall back to git log + gstack analytics only; note the limitation in findings.
+- If there are fewer than 3 signals available, say so and offer to run again after more sessions.

package/packages/software-development/self-critique/adapters/grok/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "olko:self-critique",
+  "version": "0.1.0",
+  "description": "Adversarially critique your own last answer: spawn a critic agent that verifies claims against live sources, finds the related issue or pattern you missed, then loop until satisfied and report where you were wrong, iterations-to-satisfy, the numeric improvement, and a final score.",
+  "skills": "skills/"
+}