kadmon-harness

Freeze the task list and project state to disk when a session ends, and thaw it back when the next one starts — the cryo-mirror of /kompact. /kompact compacts the context window *within* one session (you stay, its summary lives on in-thread); kontinuum crosses a hard session boundary — a /exit into a brand-new session in a fresh process, where the conversation thread breaks and an on-disk note is the only channel that survives. One trigger, two modes auto-detected by whether SESSION-HANDOFF.md exists at the repo root: FREEZE / SAVE (write the note on the way out, anchored to the exact commit sha) or THAW / RESTORE (git pull --ff-only FIRST, print a drift report of what landed while the session was frozen, reconcile WORK_COORDINATION.md claims when the repo has one, re-pin the OPEN tasks, print the summary, delete the note only once the restore succeeded). Use this skill whenever the user is about to /exit and start a new session, or says "kontinuum", "freeze the session", "congela la sesion antes de salir", "

Track lifecycle for multi-developer parallel work coordinated through WORK_COORDINATION.md. Two modes — /sprint claims a track + branches from main against the Next planned table; /sprint close runs the verification gate, opens a PR with a structured body, auto-merges when eligible, then post-merge syncs WORK_COORDINATION and flips the plan-NNN frontmatter status. Use this skill whenever someone says start plan, claim track, open track, ship plan, close plan, ready for PR, post-merge sync, flip track done, sprint close, or partial ship — even when they do not name the skill. First use in a project: instantiate WORK_COORDINATION.template.md (same directory) at the repo root.

Reference contract for creating, editing, or reviewing Kadmon Harness agent files (`.claude/agents/*.md`). Covers the mandatory/recommended/optional section taxonomy, the opus-vs-sonnet model decision tree, K-first naming convention, anti-patterns enforced by `/medik` Check

Rewrite Hebrew marketing, landing, and UI copy so it reads as native Israeli writing instead of machine-translated Hebrew. Fixes the two things that instantly mark Hebrew copy as translated: gendered second-person address (the default-masculine אתה trap that excludes half your customers) and literal English calques. Produces a native-quality, gender-safe, professional-warm draft. Use this whenever writing, reviewing, localizing, or polishing ANY customer-facing Hebrew — a landing page, hero copy, a marketing site, UI microcopy, a bot or voice persona, ad or WhatsApp copy — and especially when the Hebrew was translated from English/Spanish, when someone says the Hebrew "sounds translated / stiff / generic / off", when it mixes masculine and plural address inconsistently, or when you need Hebrew that works for both male and female readers. Trigger even if the user only says "fix the Hebrew" or "make the Hebrew sound native". It raises the floor to ~native; it does not replace a final native-speaker glance on sh

De-slop marketing, UX, and landing copy: strip the "tells" that make prose read as AI-generated (em-dash overuse, "not just X but Y", rule-of-three triads, slop vocabulary like seamlessly / robust / elevate / unlock / delve, hedging, and generic openers) and tighten it to concrete, human, on-brand writing. Use this whenever polishing or reviewing ANY customer-facing prose — landing pages, hero copy, marketing sites, product emails, UX microcopy, app-store descriptions, ad copy, social posts — and especially when the user says "make this sound human", "less AI", "punchier", "tighter", "this feels generic", or "clean up the copy", even if they never say the word "de-slop". Works per-language (English, Spanish, and others). It is a quality-and-voice tool, NOT an AI-detector-evasion tool.

Offer the user an explicit choice of response depth (25% / 50% / 75% / 100%) before answering, with token estimates based on prompt complexity. Use this skill whenever the user says "token budget", "token count", "response length", "answer depth", "short version", "tldr", "brief answer", "detailed answer", "exhaustive answer", "cuántos tokens", "ahorrar tokens", "respuesta corta", "dame la versión corta", "responde al 50%", or clearly asks to control how much context/response to consume. Do NOT trigger when "token" refers to auth/JWT/payment tokens, when the user has already set a depth this session (maintain it silently), or when the answer is trivially one line.

Scan all `.claude/skills/` to extract cross-cutting principles that appear in 2+ skills, and distill them into rules — append to existing rule sections, revise outdated content, or create new rule files. Use this skill whenever the user says "extract rules from skills", "distill patterns", "update rules", "pull common principles", "what's repeated across skills", or periodically (monthly or after adding 5+ new skills) to keep `rules/` in sync with what the skills actually teach. Applies the "deterministic collection + LLM judgment" pattern — scripts collect facts exhaustively, then judgment produces verdicts.

Audit all `.claude/skills/` for quality and drift — produce Keep/Improve/Update/Retire/Merge verdicts with evidence-backed reasons, in Quick Scan (changed skills only) or Full Stocktake (complete review) mode. Use this skill whenever auditing the skill library, checking for stale references, looking for duplication across skills, deciding what to prune or merge, reviewing skill quality before a release, or when the user says "audit skills", "review our skills", "are these skills still good", "skill quality", "skill drift", or "can we consolidate these". Also use when alchemik runs `/evolve` and needs a structured quality report on the skill inventory.

Author high-leverage prompts for Claude Fable 5 runs following Matt Shumer's method — goal-not-steps, house rules, a concrete self-checkable bar for done, fresh-context adversarial verification, loop-until-bar, building on prior work and traces, and effort selection (ultrathink single-turn, ultracode only for foundations). Use this skill whenever the user is about to hand Claude a big autonomous, long-running, or creative task and wants the prompt engineered well: 'how should I prompt this', 'help me write the prompt', 'prompt fable', 'set the bar', planning a /loop run, an overnight or weekend autonomous build, a multi-session build, deciding whether ultracode is worth the cost, or asking why their Fable results look average when the demos look magical. The fix is usually the prompting method, not the model.

Reference for authoring or debugging Kadmon Harness hook scripts (`.claude/hooks/scripts/*.js`). Covers Plugin-Mode Runtime Resolution (ADR-010 Phase 1) — how lifecycle hooks (session-start, session-end-all, pre-compact-save) resolve `dist/scripts/lib/*.js` via `KADMON_RUNTIME_ROOT` in plugin mode versus the 3-level walk in local-dev mode — and Windows compatibility deep detail (`${HOOK_CMD_PREFIX}`, plugin cache path, hooks.json generator). USE WHEN editing a lifecycle hook (session-start, session-end-all, pre-compact-save). USE WHEN debugging KADMON_RUNTIME_ROOT or dist/ resolution. USE WHEN editing `.claude-plugin/hooks.json`. USE WHEN troubleshooting Windows hook PATH or plugin-cache path issues. USE WHEN modifying `scripts/generate-plugin-hooks.ts` or `ensure-dist.js`. Make sure to load this skill whenever the user mentions hook plugin runtime, plugin mode resolution, lifecycle hook dist resolution, hook command prefix, or Windows hook PATH — even without saying "hook-authoring". Do NOT skip this skill i

Documentation synchronization principles — 3-layer model (public docs, commands, skills+agents), behavior-over-counts philosophy, staleness detection, and verification checklists. Rules are out of scope per ADR-032 Amendment 2026-04-26 (hand-curated via ADR, surfaced as read-only NOTEs). Use this skill whenever updating documentation after a commit that adds features, changes behavior, or modifies structure; whenever running /doks or /chekpoint with docs in the diff; when the user says "update docs", "sync docs", "docs are stale", "drift", "counts don't match", or "descriptions are outdated"; and after adding/removing agents, skills, commands, or hooks. The skill enforces description-over-count discipline: matching counts is the easy part, but descriptions drift silently and mislead future sessions — that's what this skill catches.

Full workflow testing with real dependencies — session lifecycle, instinct lifecycle, hook chains, SQLite integration, Windows-safe hook stdin harness. Use this skill whenever writing tests that span multiple components, testing hook stdin/stdout/exit codes via execFileSync, verifying database operations end-to-end, testing the session -> instinct -> hook chain, testing Playwright browser flows, or when the user says "E2E", "integration test", "full workflow test", "end to end", "test the whole flow", "hook test", or "instinct promotion test". Also use when deciding what to mock vs use real — the decision matrix inside covers SQLite, file system, Supabase, GitHub API, and hooks. Do not mock the state-store — the harness learned this the hard way.

Convene a four-voice council (Architect, Skeptic, Pragmatist, Critic) for ambiguous decisions, tradeoffs, and go/no-go calls — using subagent isolation as an anti-anchoring mechanism. Use this skill whenever a decision has multiple credible paths and no obvious winner, when you need explicit tradeoff surfacing, when conversational anchoring is a real risk, when the user asks for "second opinions", "dissent", "multiple perspectives", "council", "tradeoffs", "should we ship now or wait", or when a go/no-go call would benefit from adversarial challenge. Do NOT use for verifying correctness (use `verification-loop`), implementation planning (`konstruct`), system architecture (`arkitect`), code review (`kody`), straight factual questions, or obvious execution tasks.

Multi-source deep research methodology — plan sub-questions, search with WebSearch/WebFetch/Context7, deep-read key sources, synthesize cited reports with inline citations. Use this skill whenever the user asks to "research", "investigate", "deep dive", "compare", "evaluate options", "look into", or says "what's the current state of", "due diligence", "competitive analysis", "market sizing", or needs any evidence-based analysis drawing on sources beyond the current codebase. Also use when the user asks for an opinion on a technology or framework — research first, then recommend with citations. Prefer this over WebSearch-alone because the methodology forces sub-question decomposition and cross-referencing.

Audit the active repo, MCP servers, plugins, connectors, env surfaces, and harness setup, then recommend the highest-value additions (skills, hooks, agents, operator workflows) based on what already exists and what's missing. Use this skill whenever the user asks "set up Claude Code", "what should I install", "what plugins or MCPs do I need", "audit my workspace", "what am I missing", "how is this repo configured", or before adding more skills/hooks/connectors. Read-only — does not modify anything unless the user explicitly asks for follow-up implementation.

Evaluate code review feedback with technical rigor before implementing. Use this skill whenever receiving code review feedback from kody, typescript-reviewer, spektr, external reviewers, GitHub PR comments, or any automated tool; especially when suggestions seem unclear, technically questionable, YAGNI-violating, or conflict with project conventions; when the user says "review fixes", "address PR comments", "the reviewer said", or when tempted to respond with "you're absolutely right!"; and always before implementing ANY review suggestion. The skill blocks performative agreement ("great catch!") and forces verification against the actual codebase — wrong suggestions get technical pushback, not compliance.

How the instinct learning system works — observation, confidence scoring (0.3->0.9), promotion to skills. Use this skill whenever working with /forge (unified preview-gated pipeline: detect, reinforce, promote, prune, export), when debugging why an instinct was or wasn't created, understanding the pattern evaluation in session-end-all, or when the user asks about "instincts", "patterns", "confidence", or "how does the harness learn". Also use when promoting instincts via skill-creator.

Regression testing strategies for AI-assisted development — sandbox-mode API testing without DB dependencies, automated bug-check workflows, and test patterns that catch the predictable blind spots created when the same model writes and reviews code. Use this skill whenever an AI agent has modified API routes or backend logic, after a bug was found and fixed, when adding tests to a project that has a sandbox/mock mode, when running a `bug-check` workflow, when there are multiple code paths (sandbox vs production, feature flags), or when the user says "regression test", "bug check", "sandbox/production parity", "AI blind spot", "prevent re-introduction", or "the agent keeps making the same mistake". Do NOT use for greenfield testing (use `tdd-workflow`) or for end-to-end browser tests (use `e2e-testing`).

TypeScript/JavaScript conventions for Kadmon projects — naming, types, imports, error handling, immutability, validation. Use this skill whenever writing new code, reviewing code for convention compliance, or unsure about naming (camelCase vs PascalCase vs snake_case), import style (node: prefix, .js extensions), error handling patterns, Zod validation, immutability, or file organization. Also consult when onboarding to the project or when the kody agent flags TypeScript issues.

Write the test before the code — red, green, refactor. Use this skill whenever implementing a new function, fixing a bug, adding a hook, modifying behavior, or when the user says "add", "implement", "create", or "fix". Also use when reviewing whether test coverage exists for new code. Even for small changes, the test-first discipline catches edge cases before they ship. Tests are evidence, not assumptions — they enforce the no_context principle at the code level.

Run build + typecheck + lint + tests in sequence after any code change or before any git commit/push. Use this skill whenever you finish implementing a feature, fix a bug, refactor code, before running /chekpoint, or before any commit or push. Also use when the user says "verify", "check if it works", "run tests", "does it compile", "commit this", "push it", or "checkpoint". Stop at first failure — fix before proceeding. This is the safety net that catches type errors, lint violations, and regressions before they reach git. A commit without verification is a gamble — this skill eliminates that risk.

Head-to-head evaluation of coding agents (Claude Code vs Aider vs Codex, or the same agent across model versions) on reproducible tasks, with pass rate, cost, time, and consistency metrics. Use this skill whenever comparing coding agents, measuring agent performance before adopting a new tool or switching models, running regression checks after an agent updates, producing data-backed agent selection decisions, or when the user says "which agent is better", "benchmark the agent", "compare Claude to X", "is the new model actually better", "agent eval", or "head to head". Stop running "which agent is best?" on vibes — this skill systematizes it.

Structured self-debugging workflow for AI agent failures — capture, diagnose, contained recovery, introspection report. Use this skill whenever an agent run is failing repeatedly, consuming tokens without progress, looping on the same tools, drifting from the intended task, hitting max-tool-call limits, or producing degraded output from context overflow. Also use when the user says "the agent is stuck", "stop retrying", "it keeps doing the same thing", "agent loop", "why did this fail", or when mekanik is about to intervene on a failure that is not a compile error. Teaches the agent to debug itself systematically before escalating to a human.

RESTful and RPC API design — resource naming, HTTP methods, Zod validation, error handling, versioning, authentication, pagination. Use this skill whenever designing new API endpoints, reviewing endpoint structure, planning Supabase Edge Functions, defining service boundaries, or when the user mentions "endpoint", "REST", "API route", "request/response format", "error response", "pagination", or "service interface". Also use when implementing API contracts for ToratNetz search or KAIRON voice endpoints. Even internal service interfaces benefit from these patterns to keep boundaries clean and debuggable.

Document architectural decisions as ADRs in docs/decisions/ — context, options, consequences. Use this skill whenever making a decision that affects multiple components, choosing between persistence strategies, adding new hooks or agents, changing the data model, or when the user asks "why did we do it this way?" or "should we change the approach?". Even if the decision seems small, if it constrains future choices it deserves an ADR.

Measure performance baselines, detect regressions before/after a change, and compare stack alternatives — across page (Core Web Vitals), API (latency percentiles), and build (cold/HMR/test/lint times) modes. Use this skill whenever the user wants to capture a baseline, compare before/after a PR, says "is this faster", "did I make it slower", "benchmark this", "performance regression", "Core Web Vitals", "p95 latency", "build time", "page weight", or before a launch where performance targets matter. Do NOT use for one-off `console.time` debugging — that's just timing, not a baseline.

Patterns for Claude API and Anthropic SDKs (TypeScript + Python) — messages, tool use, streaming, extended thinking, prompt caching, batches, cost optimization. Use this skill whenever code imports @anthropic-ai/sdk or anthropic, when building features that call Claude directly, implementing function calling / tool use, streaming responses, or managing API costs. Also use when the user asks to "call Claude", "use the API", "add tool use", or works on ToratNetz/KAIRON backend integration.

Create CodeTour `.tour` files — persona-targeted, step-by-step walkthroughs of a codebase with verified file and line anchors, written in the Microsoft CodeTour JSON format. Use this skill whenever the user asks for a code tour, onboarding tour, architecture walkthrough, PR tour, RCA tour, or security review tour, says "explain how X works" and wants a reusable guided artifact, or wants to create a ramp-up path for a new engineer or reviewer. Produces a coherent narrative anchored to real files; never generates ad-hoc Markdown notes when a tour artifact is what was asked for. Do NOT use for one-off chat explanations, prose docs editing, the implementation work itself, or broad codebase onboarding without a tour artifact (use `codebase-onboarding` for that).

Analyze an unfamiliar codebase and generate a structured onboarding guide — architecture map, key entry points, conventions, and a starter `CLAUDE.md`. Use this skill whenever joining a new project, setting up Claude Code in an existing repo for the first time, being asked to "understand this codebase", "walk me through this repo", "onboard me", "generate a CLAUDE.md", or "help me get productive here". Systematic 4-phase workflow: reconnaissance → architecture map → convention detection → onboarding artifacts. Do not read every file — use Grep/Glob for signals, Read only for ambiguous cases.

Cache expensive file processing results (PDF parsing, text extraction, image analysis, embedding generation) using SHA-256 of file content as the cache key — path-independent, auto-invalidating, with service-layer separation so the underlying processing function stays pure. Use this skill whenever building a file processing pipeline, adding a `--cache/--no-cache` CLI option, processing the same files repeatedly where cost matters, caching embeddings or chunks keyed by source file, or when the user says "cache the results", "avoid reprocessing", "SHA-256 cache", "content-based cache", or mentions expensive file operations that happen on every run. Do NOT use when results must always be fresh, when entries would be enormous (stream instead), or when output depends on parameters beyond file content.

Manage Claude Code's context window to avoid performance degradation — monitor, assess, and compact at the right moment. Use this skill when responses feel slower or less accurate, when planning a long multi-file session, when switching between major tasks, or when tempted to compact mid-debugging or mid-implementation. Also use when the user mentions "context", "window", "slow", "compact", or "running out of space". Helps decide WHEN to compact, what to keep, and what is dangerous to lose.

Cost-optimization patterns for any code that calls Claude, OpenAI, or similar LLM APIs — model routing by task complexity, immutable cost tracking, narrow retry logic, and prompt caching combined into a composable pipeline. Use this skill whenever building or reviewing code that calls an LLM API in a loop or pipeline, when the user says "cut API costs", "reduce LLM spend", "model routing", "which model should I use", "budget limit", "prompt caching", "fallback model", "retry on rate limit", or when designing any batch processor that could silently overspend. Do NOT trigger for one-off prompts with no budget concern or for questions about local models that don't charge per token.

Safe schema evolution for SQLite and Supabase — idempotent migrations, IF NOT EXISTS guards, TypeScript interface sync, rollback strategies. Use this skill whenever adding tables, columns, or indexes to schema.sql or supabase/migrations/, when the user mentions "new table", "add column", "schema change", "migration", "ALTER TABLE", or "rollback". Also use when types.ts interfaces need to match a schema update, when preparing data for Supabase v2 sync, or when state-store.ts CRUD functions change. Even small schema tweaks benefit from this checklist because SQLite ALTER TABLE is severely limited and one wrong move can corrupt data.

Docker and Docker Compose patterns for local development and production — multi-stage Dockerfiles, Compose service orchestration, networking, volume strategies, container security hardening, secret management, debugging, and anti-patterns. Use this skill whenever setting up Docker Compose for local dev, writing or reviewing a Dockerfile, designing a multi-container architecture, troubleshooting container networking or volume issues, migrating a project to containers, or when the user says "dockerize this", "docker compose", "multi-stage build", "container security", "why is my container broken", or mentions volumes, networks, healthchecks, or deployment stages. Do NOT trigger for Kubernetes manifests (different skill) or for the Kadmon harness itself, which runs on the host.

Fetch live library and framework documentation via the Context7 MCP server instead of relying on training-data recall — supports React, Next.js, Prisma, Supabase, Tailwind, FastAPI, Django, and hundreds more. Use this skill whenever the user asks about a library, framework, SDK, API, CLI tool, or cloud service (even well-known ones), asks setup/configuration questions ("How do I configure X?"), requests code that depends on a specific library ("Write a Prisma query for..."), needs API reference information, or mentions a library or version by name. Also use whenever the user says "look up the docs", "check Context7", "current docs for X", "what's the latest API for X", or when unfamiliar APIs appear in code being reviewed. Do NOT use for generic programming concepts, refactoring business logic, or code review — those don't need live docs.

Eval-driven development (EDD) framework — define pass/fail criteria before implementing a feature, run capability and regression evals with pass@k metrics, and produce eval reports using code, model, or human graders

React and React Native patterns — component composition, compound components via Context, custom hooks (useToggle/useDebounce/useQuery), Context+Reducer state management, performance (memo, useMemo, lazy/Suspense for web, virtualization), Error Boundary, accessibility (keyboard nav, focus management), form handling, Framer Motion / Reanimated animations, and React Native-specific caveats. Use this skill whenever building or reviewing .tsx/.jsx files, web dashboards, or KAIRON mobile components; whenever the user says "React", "React Native", "component", "hook", "state management", "a11y", "Suspense", "memo", or "performance"; and when typescript-reviewer or kody is reviewing frontend code. Also use before picking a data-fetching pattern (custom hook vs SWR vs React Query).

Long-form practical reference for Git branching strategies, commit conventions, merge vs rebase, PR workflow, conflict resolution, release tagging, and undoing mistakes. Use this skill whenever setting up Git practices for a new project, writing commit messages or PR descriptions, resolving merge conflicts, deciding between merge and rebase, creating releases or version tags, recovering from a git mistake, or when the user says "git workflow", "branching strategy", "how do I git", "fix my commit", "resolve conflict", "create a release", "undo this commit", or "what's the right way to do X in git". This is the workflow-level companion to `rules/common/git-workflow.md` — the rules file states the mandatory behaviors; this skill shows how to apply them.

GitHub repository operations via `gh` CLI — issue triage, PR management, CI failure debugging, release preparation, and security monitoring. Use this skill whenever the user says "check GitHub", "triage issues", "review PRs", "merge", "release", "CI is broken", "which PRs are stale", "deal with Dependabot", or when any repo-operational task needs the `gh` CLI rather than raw git. Also use when debugging failed GitHub Actions runs or preparing a release changelog. Do NOT trigger for local git operations (branching, merging, committing) — use `git-workflow` for those.

Design, implement, and refactor systems using Ports and Adapters (hexagonal architecture) — domain model, use-case orchestration, inbound/outbound ports, adapters, composition root, testable boundaries. Use this skill whenever building a new feature where long-term maintainability matters, refactoring layered or framework-heavy code where domain logic is tangled with I/O, supporting multiple interfaces for the same use case (HTTP + CLI + worker), replacing infrastructure without rewriting business rules, or when the user says "hexagonal", "ports and adapters", "clean architecture", "domain-driven", "decouple from the framework", "separate business logic from I/O", or "how do I make this testable". Covers TypeScript, Java, Kotlin, and Go.