{"handoffs":"Load lev to resume: lev://lifecycle?from=handoff","proposals":"Convert to spec: lev://lifecycle?from=crystallizing&to=crystallized","specs":"Execute: lev://exec?epic={bd_epic_id}","reports":"Design solution: lev://lifecycle?from=captured&to=crystallizing"}
IMPORTANT: This skill is "plankton" - always referenced in handoffs, proposals, specs, and compact summaries. Every mention should be action-oriented.
Lev Concept
What is lev?
Lev is the master router and entry point for the entire Leviathan ecosystem. It's a "plankton" skill - small, foundational, referenced everywhere, and essential to the lifecycle.
Why plankton?
Like plankton in an ocean ecosystem:
Foundational: Everything feeds from it
Distributed: Referenced in every lifecycle artifact
Action-oriented: Always includes next actions
Constitutional: Defines core protocols
When to use:
ANY work request (get, think, spec, execute)
Entity lifecycle transitions
Protocol handler lookups
Skill discovery
Plankton behavior:
Every lifecycle artifact (report, proposal, spec, handoff) should reference lev with action directives:
"Load lev to advance this work"
"Use lev://lifecycle to transition states"
"Execute via lev://exec"
CLI Commands
Primary: lev (entry point)
# Auto-routes based on keywords
lev get "auth middleware patterns"
lev "research authentication patterns"
lev "design user management system"
lev "spec implementation behavior for feature X"
lev "execute epic clawd-h2qg"
Core Primitive: lev get
lev get is the root external-context primitive. It progressively expands retrieval depth:
Compatibility note: if your local CLI does not yet expose lev get, use lev find as the temporary alias.
# Depth 0: current conversation/session context only
lev get "auth"# Depth 1: include filesystem and local project artifacts
lev get "auth" --depth=fs
# Depth 2: include BD/tasks state
lev get "auth" --depth=bd
lev get --depth=research
# Depth 3: include external research backends
"auth"
Depth order is deterministic: context -> filesystem -> bd -> research.
lev owns intent parsing, protocol dispatch, and routing to specialist skills.
lev does not own lifecycle artifact schemas (report, proposal, spec, handoff).
work owns lifecycle stage detection and artifact generation contracts.
lev-builder owns build/migrate flows (POC → production placement and validation).
If a request asks for session continuity output (handoff, checkpoints, compact), lev routes to work manifesting behavior instead of embedding format logic here.
Use case: Prompt contains lev:// or skill:// reference, needs context injection
Steps:
Intercept protocol URIs in prompt (syscall pattern)
Resolve to skill or kernel function
Inject context at runtime
Execute with injected context
Example:
# Prompt: "Research auth using skill://lev-research and lev://get?query=auth"
↓ [syscall interception]
↓ skill://lev-research → resolve to ~/.claude/skills/lev-research/
↓ lev://get?query=auth → execute lev get with progressive depth
↓ [kernel mode: inject contexts]
↓ Return to user space with loaded contexts
skill://lev-computer-use - Computer use integration
Protocol Handlers
lev://get → lev.get primitive
lev://find → legacy alias to lev://get
lev://exec → bd execution engine
lev://lifecycle → lev-lifecycle state machine
lev://research → lev-research orchestrator
lev://align → work alignment gate
Lifecycle Artifacts
Reports (captured) → proposals (crystallizing)
Proposals (crystallizing) → specs (crystallized)
Specs (crystallized) → handoffs (manifesting)
Handoffs (manifesting) → archive (completed)
Constitutional References
Handoffs: "Load lev to resume work"
Proposals: "Use lev to convert to spec"
Specs: "Execute via lev://exec"
Reports: "Design solution with lev"
Validation Gates
Entry Gate (Before Route)
Request parsed successfully
Keywords detected
Lifecycle stage determined
Sub-skill available
Transition Gates (Between States)
captured → crystallizing:
Prior art check complete (BD, docs, skills)
No duplicate work found OR justified
Research findings documented
crystallizing → crystallized:
DoR validation complete
Alignment check passed (work alignment gate)
Design approved
crystallized → manifesting:
Validation suite passed
Spec approved
Tasks created (if BD available)
manifesting → completed:
Done state criteria met
All tasks closed
Artifacts archived
Exit Gate (After Execution)
Artifact generated
Lifecycle position updated
Next actions documented
Plankton reference included
Plankton Action Directives
In templates, always include:
Handoffs
## Next Steps
Load lev to resume work:
- Continue context gathering: `lev://get?query={topic}&depth=research`- Design solution: `lev://lifecycle?from=captured&to=crystallizing`- Execute spec: `lev://exec?epic={bd_epic_id}`
Proposals
## Next Steps
Use lev to advance this proposal:
- Create spec: `lev://lifecycle?from=crystallizing&to=crystallized`- Validate alignment: `skill://work`- Research alternatives: `lev://research?depth=deep&topic={topic}`
Specs
## Execution
Execute this spec:
- Scaffold epic: `lev://exec?spec=spec.md`- Team mode: `lev://exec?epic={bd_epic_id}`- Track progress: `skill://bd`
Reports
## Next Steps
Design solution from findings:
- Propose: `lev://lifecycle?from=captured&to=crystallizing`- Research more: `lev://get?query={topic}&depth=research`- Deep dive: `lev://research?depth=deep&topic={topic}`
Sub-Skills Reference
Each sub-skill has its own SKILL.md with full detail. Lev acts as router.
lev "design a solution for user authentication"
↓ keyword: "design"
↓ stage: crystallizing
↓ route: lev-cdo
↓ execute: strategic planning
↓ output: .lev/pm/proposals/auth-solution-2026-01-28.md
Example 4: Spec Authoring
lev "spec implementation behavior for auth system"
↓ keyword: "spec"
↓ stage: crystallized
↓ route: work
↓ execute: DoR-enforced spec generation
↓ output: .lev/pm/specs/auth-implementation-2026-01-28.md
Example 5: Lifecycle Transition
lev "transition idea-001 from captured to crystallizing"
↓ keyword: "lifecycle", "transition"
↓ route: lev-lifecycle
↓ execute: state machine transition
↓ output: state updated, proposal generated
Example 6: Alignment Check
lev "check if current work aligns with north star"
↓ keyword: "align", "north star"
↓ route: work (alignment gate)
↓ execute: drift detection + lifecycle validation
↓ output: alignment report
Example 7: Auto-Routed Work
lev "analyze test coverage and propose improvements"
↓ keyword: "analyze", "propose"
↓ ambiguous stage
↓ route: work (auto-detect)
↓ work determines: captured (research) → crystallizing (design)
↓ output: report.md + proposal.md
Integration Points
With Entity Lifecycle
Maps FSM states to appropriate sub-skills
Generates lifecycle-appropriate artifacts
Validates state transitions via gates
With BD (Beads)
Links specs to BD epics
Tracks tasks via BD CLI
Routes execution through BD
With FlowMind
Supports flowmind:// protocol handlers
Integrates with compiler/runtime
Enables YAML-first behavior
With Workshop
Routes intake requests to workshop plugins
Supports workshop:// protocol
Manages poc → poly transitions
With Team Mode
Delegates to planning skill for team decomposition
Coordinates multi-agent workflows
Tracks teammate assignments
Principles
Single Entry Point - All lev operations start here
Progressive Disclosure - Start simple, route to specialists as needed
Lifecycle Awareness - Route based on entity state
Protocol Driven - Support URI-based invocation
Plankton Behavior - Always include action directives
Plankton status: ✅ ACTIVE
Constitutional: ✅ YES
Always reference: In all lifecycle artifacts with action directives
Technique Map
Role definition - Clarifies operating scope and prevents ambiguous execution.
Context enrichment - Captures required inputs before actions.
Output structuring - Standardizes deliverables for consistent reuse.
Step-by-step workflow - Reduces errors by making execution order explicit.
Edge-case handling - Documents safe fallbacks when assumptions fail.
Technique Notes
These techniques improve reliability by making intent, inputs, outputs, and fallback paths explicit. Keep this section concise and additive so existing domain guidance remains primary.
Prompt Architect Overlay
Role Definition
You are the prompt-architect-enhanced specialist for lev, responsible for deterministic execution of this skill's guidance while preserving existing workflow and constraints.
Input Contract
Required: clear user intent and relevant context for this skill.
Preferred: repository/project constraints, existing artifacts, and success criteria.
If context is missing, ask focused questions before proceeding.
Output Contract
Provide structured, actionable outputs aligned to this skill's existing format.
Include assumptions and next steps when appropriate.
Preserve compatibility with existing sections and related skills.
Edge Cases & Fallbacks
If prerequisites are missing, provide a minimal safe path and request missing inputs.
If scope is ambiguous, narrow to the highest-confidence sub-task.
If a requested action conflicts with existing constraints, explain and offer compliant alternatives.
